『壹』 c語言教程的內容是
C語言學習從入門到精通的一套經典視頻教程，本課程通過高清晰的視頻、概念詳解、實例精講、習題測試讓你很快的掌握C語言的相關知識，並領略運用到實例中去。在針對一些用戶認為C語言比較難學的情況下，本課程從初中級用戶的角度出發，進行合理的內容安排，突出學、練、用、鞏固相結合的特點，以通俗易懂的語言，豐富多彩的實例，詳細介紹了使用C語言進行程序開發應該掌握的各方面知識。本課程主要給大家講解了C語言概述，演算法，數據類型，運算符與表達式，常用的數據輸入、輸出函數，選擇結構程序設計，循環控制，數組，函數，指針，結構體和共用體，位運算，預處理，模塊化編程，編程規范，C語言常見問題及分析，習題測試等內容。所有知識都結合具體實例進行介紹，涉及的程序代碼給出了詳細的講解，可以使讀者輕松領會C語言程序開發的精髓，快速提高開發技能。
課程內容詳盡，實例豐富，非常適合作為單片機及編程初學者的學習課程，也可作為大中院校相關專業在校學生及畢業生的教學輔導課程、短期C語言培訓課程，是C語言編程愛好者從入門到深入的經典課程。
課程共分為15講，每節課的內容大綱如下：
第1課 C語言概述
1、幾種常見的程序設計語言
2、C語言出現的歷史背景
3、C語言的特點
4、簡單的C程序介紹
5、C程序的上機步驟
6、習題測試
第2課 程序的靈魂-演算法
1、程序設計過程
2、演算法的基本概念
3、演算法的特徵
4、演算法的表示方法（流程圖）
5、結構化程序設計方法
6、習題測試
第3課 C語言的數據類型
1、預備知識
2、C語言的數據類型
3、常量與變數
4、不同數據類型之間的轉換
5、運算符號和表達
6、習題測試
第4課 C語言順序程序設計
1、C語句概述
2、賦值語句
3、數據的輸入輸出
4、字元數據輸入輸出
5、格式輸入輸出
6、順序程序舉例
7、習題測試
第5課 C語言選擇程序設計
1、關系運算符和關系表達式
2、邏輯運算符和邏輯表達式
3、if 語句---條件判斷
4、條件運算符
5、switch 語句
6、選擇程序舉例
7、習題測試
第6課 C語言的循環控制
1、概述
2、goto語句及與if語句構成循環
3、while語句
4、do …while語句
5、for語句
6、循環的嵌套
7、幾種循環的比較
8、break語句和contiune語句
9、程序舉例
10、習題測試
第7課 C語言數組
1、一維數組
2、二維數組及多維數組
3、字元數組和字元串
4、程序舉例
5、習題測試
第8課 函數
1、概述
2、函數定義的一般格式
3、函數的返回值
4、函數的調用
5、函數參數及其傳遞方式
6、函數的嵌套與遞歸調用
7、數組作為函數參數
8、變數的存儲屬性
9、內部函數和外部函數
10、習題測試
第9課 C語言預處理命令
1、編譯預處理
2、宏定義
3、文件包含
4、條件編譯
5、習題測試
第10課 指針
1、指針的概念
2、指針變數
3、指針與數組
4、指針與字元串
5、指針與函數
6、返回指針值的函數
7、指針數組和多級指針
8、習題測試
第11課 結構體與共用體
1、結構類型與結構變數的定義
2、結構變數的引用與初始化
5、結構數組
6、指向結構類型數據的指針
7、用指針處理鏈表
8、共用體
9、枚舉類型
10、用typedef定義別名
11、程序舉例
12、習題測試
第12課 位運算
1、位運算概述
2、位運算符的使用方法
3、習題測試
第13課 單片機C語言的模塊化編程
1、模塊化編程的優點
2、C語言源文件(*.c)文件和頭文件(*.h)的的作用
3、模塊化編程設計步驟
4、程序實例
5、模塊化程序的移植
6、習題測試
第14課 C語言編程規范
1、編碼規范概述
2、編程排版規范
3、編程注釋規范
4、命名規則
5、可讀性規范
6、變數與結構規范
7、函數與過程規范
8、編程效率規范
9、質量保證規范
10、宏規范
11、代碼編輯
12、編譯
13、審查
14、代碼測試
15、維護
16、習題測試
第15課 C語言編程常見出錯問題及分析
1、C語言的一些基本概念
2、位(bit)和位元組(byte)
3、變數和數據存儲
4、數據文件
5、字元串操作
6、數組
7、指針和內存分配
8、函數
9、編譯預處理
10、標准庫函數
11、系統調用
12、可移植性
13、編程風格和標准
14、程序的編寫和編譯
15、調試
『貳』 計算機二級考試C語言知識點歸納
2017年計算機二級考試C語言知識點歸納
計算機二級考試是全國計算機等級考試(National Computer Rank Examination，簡稱NCRE)四個等級中的一個等級，考核計算機基礎知識和使用一種高級計算機語言編寫程序以及上機調試的基本技能。下面是2017年計算機二級考試C語言知識點歸納。歡迎閱讀。
總體上必須清楚的
1)程序結構是三種：順序結構 ，循環結構
(三個循環結構)，選擇結構(if 和 switch)
2)讀程序都要從main()入口，然後從最上面順序
往下讀(碰到循環做循環,碰到選擇做選擇)。
3)計算機的數據在電腦中保存是以二進制的形式。
數據存放的位置就是他的地址。
4)bit是位 是指為0 或者1。 byte 是指位元組，
一個位元組 = 八個位。
5)一定要記住二進制如何劃成十進制。
概念常考到的：
1)、編譯預處理不是C語言的一部分，不再運行
時間。C語言編譯的程序稱為源程序，
它以ASCII數值存放在文本文件中。
2)、每個C語言程序中main函數是有且只有一個。
3)、在函數中不可以再定義函數。
4)、演算法是一定要有輸出的，他可以沒有輸入。
5)、break可用於循環結構和switch語句。
6)、逗號運算符的級別最低。
第一章
1)合法的用戶標識符考查：
合法的要求是由字母，數字，下劃線組成。
有其它元素就錯了。
並且第一個必須為字母或則是下劃線。
第一個為數字就錯了。
關鍵字不可以作為用戶標識符號。
main define scanf printf 都不是關鍵字。迷惑你的
地方If是可以做為用戶標識符。因為If中的
第一個字母大寫了，所以不是關鍵字。
2)實型數據的合法形式：
2.333e-1 就是合法的，且數據是2.333×10-1。
考試口訣：e前e後必有數，e後必為整數。.
3)字元數據的合法形式:：
'1'是字元佔一個位元組，"1"是字元串占兩個
位元組(含有一個結束符號)。
'0' 的ASCII數值表示為48，'a' 的ASCII數值是97，
'A'的ASCII數值是65。
4) 整型一般是兩個位元組, 字元型是一個位元組，
雙精度一般是4個位元組：
考試時候一般會說，在16位編譯系統，或者
是32位系統。碰到這種情況，不要去管，一樣做題。
掌握整型一般是兩個位元組, 字元型是一個位元組，
雙精度一般是4個位元組就可以了。
5)轉義字元的考查：
在程序中 int a = 0x6d，是把一個十六進制的數給
變數a 注意這里的0x必須存在。
在程序中 int a = 06d, 是一個八進制的形式。
在轉義字元中，’x6d’才是合法的，0不能寫，
並且x是小寫。
‘141’是合法的。
‘108’是非法的，因為不可以出現8。
轉義字元意義 ASCII碼值(十進制)
a 響鈴(BEL) 007
退格(BS) 008
f 換頁(FF) 012
換行(LF) 010
回車(CR) 013
水平製表(HT) 009
v 垂直製表(VT) 011
\ 反斜杠 092
? 問號字元 063
' 單引號字元 039
" 雙引號字元 034
空字元(NULL) 000
ddd 任意字元三位八進制
xhh 任意字元二位十六進制
6)算術運算符號的優先順序別：
同級別的有的是從左到右，有的是從右到左。
7)強制類型轉換：
一定是(int)a 不是 int(a)，注意類型上
一定有括弧的。
注意(int)(a+b)和(int)a+b 的區別。
前是把a+b轉型，後是把a轉型再加b。
8)表達式的考查：
是表達式就一定有數值。
賦值表達式：表達式數值是最左邊的數值，
a=b=5;該表達式為5，常量不可以賦值。
自加、自減表達式：假設a=5，++a(是為6)，
a++(為5);
運行的機理：++a 是先把變數的數值加上1，
然後把得到的數值放到變數a中，然後再用這
個++a表達式的數值為6，而a++是先用該表達
式的數值為5，然後再把a的數值加上1為6，
再放到變數a中。 進行了++a和a++後在下面的
程序中再用到a的話都是變數a中的6了。
考試口訣：++在前先加後用，++在後先用後加。
逗號表達式：優先順序別最低 ;表達式的數值
逗號最右邊的那個表達式的數值。
(2，3，4)的表達式的數值就是4。
9)位運算的考查：
會有一到二題考試題目。
總的處理方法：幾乎所有的'位運算的題目
都要按這個流程來處理(先把十進制變成
二進制再變成十進制)。
例1：char a = 6, b;
b = a<<2; 這種題目的計算是先要把a的十進
制6化成二進制，再做位運算。
例2：一定要記住，
例3：在沒有捨去數據的時候，<<左移一位表示
乘以2;>>右移一位表示除以2。
10)018的數值是非法的，八進制是沒有8的，
逢8進1。
11)%符號兩邊要求是整數。不是整數就錯了。
12)兩種取整丟小數的情況：
1、int a =1.6;
2、(int)a;
第二章
1)printf函數的格式考查：
%d對應整型;%c對應字元;%f對應單精度等等。
寬度的，左對齊等修飾。
%ld對應 long int;%lf 對應double。
2)scanf函數的格式考察：
注意該函數的第二個部分是&a 這樣的地址，不是a;
Scanf(“%d%d%*d%d”,&a,&b,&c);跳過輸入的
第三個數據。
3)putchar ,getchar 函數的考查：
char a = getchar() 是沒有參數的，從鍵盤得到
你輸入的一個字元給變數a。
putchar(‘y’)把字元y輸出到屏幕中。
4)如何實現兩個變數x ，y中數值的互換
(要求背下來)
不可以把 x=y,y=x; 要用中間變數 t=x;x=y;y=t。
5)如何實現保留三位小數，第四位四捨五入
的程序，(要求背下來)
x=(int)(x*1000+0.5)/1000.0
這個有推廣的意義，注意 x = (int)x 這樣是
把小數部分去掉。
第三章
特別要注意：c語言中是用非0表示邏輯真的，
用0表示邏輯假的。
1)關系表達式：
表達式的數值只能為1(表示為真)，
或0(表示假)
當關系的表達是為真的時候得到1。
如 9>8這個是真的，所以表達式的數值就是1;
2)邏輯表達式：
只能為1(表示為真)，或0(表示假)
a) 共有&& || ! 三種邏輯運算符號。
b) !>&&>|| 優先的級別。
c) 注意短路現象。考試比較喜歡考到。
d) 要表示 x 是比0大，比10小的方法。0
不可以的(一定記住)。是先計算0
結果為1或則0;再用0，或1與10比較得到的
總是真(為1)。所以一定要用(0
示比0大比10小。
3)if 語句
else 是與最接近的if且沒有else的相組合的。
4)條件表達式：
表達式1 ?表達式2 ：表達式3
注意是當非0時候是表達式2的數值，當為0是
就是表達式2的數值。
考試口訣：真前假後。
5)switch語句：
a)一定要注意有break 和沒有break的差別，
沒有break時候，只要有一個case匹配了，剩下
的都要執行，有break則是直接跳出了swich語句。
b)switch只可以和break一起用，不可以
和continue用。
第四章
1)三種循環結構：
a)for(); while(); do- while()三種。
b)for循環當中必須是兩個分號，千萬不要忘記。
c)寫程序的時候一定要注意，循環一定要有結束
的條件，否則成了死循環。
d) do-while()循環的最後一個while();的分號一定
不能夠丟。(當心上機改錯)
2) break 和 continue的差別
記憶方法：
break：是打破的意思，(破了整個循環)所以
看見break就退出真個一層循環。
continue：是繼續的意思，(繼續循環運算)，
但是要結束本次循環，就是循環體內剩下的語句
不再執行，跳到循環開始，然後判斷循環條件，
進行新一輪的循環。
3)嵌套循環
就是有循環裡面還有循環，這種比較復雜，要一層
一層一步一步耐心的計算，一般記住兩層是處理
二維數組的。
4) while((c=getchar())!=’ ’)和
while(c=getchar() !=’ ’)的差別
先看a = 3 != 2 和(a=3)!=2 的區別：
(!=號的級別高於=號 所以第一個先計算 3!=2)
第一個a的數值是得到的1;第二個a的數值是3。
考試注意點: 括弧在這里的重要性。
第五章
函數：是具有一定功能的一個程序塊;
1) 函數的參數，返回數值(示意圖)：
main()
{
int a = 5,b=6,c;
c = add(a,b);
printf(“%d”,c);
}
調用函數
a,b是實參
整個函數得到一個數值就是
Add函數的返回數值。
int add ( int x,int y)
{
int z;
z=x+y;
return z;
}
被調用函數
x，y是形式參數
函數返回數值是整型
z就是這個add函數計算後得到的結果，就是函數
返回給主程序的返回數值。
程序是在從上往下順序執行，當碰到了函數add後，
把a，b的數值穿給調用函數，程序暫時中斷等待返回數值。
當得到了返回數值後，再順序的往下執行
2)一定要注意參數之間的傳遞
實參和形參之間 傳數值，和傳地址的差別。(考試的重點)
傳數值的話，形參的變化不會改變實參的變化。
傳地址的話，形參的變化就會有可能改變實參的變化。
3)函數聲明的考查：
一定要有：函數名，函數的返回類型，函數的參數類型。
不一定要有：形參的名稱。
第六章
指針變數的本質是用來放地址，而一般的變數是放數值的。
int *p 中 *p和p的差別：
*p可以當做變數來用;*的作用是取後面地址p裡面的數值
p是當作地址來使用。
*p++ 和 (*p)++的之間的差別：改錯題目中很重要
*p++是 地址會變化。
(*p)++ 是數值會要變化。
三名主義：(考試的重點)
數組名：表示第一個元素的地址。數組名不可以自加，
他是地址常量名。(考了很多次)
函數名：表示該函數的入口地址。
字元串常量名：表示第一個字元的地址。
第七章
1一維數組的重要概念：
對a[10]這個數組的討論。
1、a表示數組名，是第一個元素的地址，也就是
元素a[10]的地址。
2、a是地址常量，所以只要出現a++，或者
是a=a+2賦值的都是錯誤的。
3、a是一維數組名，所以它是列指針，也就是
說a+1是跳一列。
對a[3][3]的討論。
1、a表示數組名，是第一個元素的地址，也就是
元素a[10]的地址。
2、a是地址常量，所以只要出現a++，或者
是a=a+2賦值的都是錯誤的。
3、a是二維數組名，所以它是行指針，也就
是說a+1是跳一行。
4、a[0]、a[1]、a[2]也都是地址常量，不可以對
它進行賦值操作，同時它們都是列指針，a[0]+1，
a[1]+1，a[2]+1都是跳一列。
5、注意a和a[0] 、a[1]、a[2]是不同的，它們的
基類型是不同的。前者是一行元素，後三者是一列元素。
二維數組做題目的技巧：
如果有a[3][3]={1,2,3,4,5,6,7,8,9}這樣的題目。
步驟一：把他們寫成：
第一列第二列第三列
a[0]à 1 2 3 ->第一行
a[1]à 4 5 6—>第二行
a[2]à 7 8 9->第三行
步驟二：這樣作題目間很簡單：
*(a[0]+1)我們就知道是第一行的第一個元素往後
面跳一列，那麼這里就是a[0][1]元素，所以是1。
*(a[1]+2)我們就知道是第二行的第一個元素往後面
跳二列。那麼這里就是a[1][2]元素，所以是6。
一定記住：只要是二維數組的題目，一定是寫成如
上的格式，再去做題目，這樣會比較簡單。
數組的初始化，一維和二維的，一維可以不寫，
二維第二個一定要寫
int a[]={1，2} 合法。 int a[][4]={2，3，4}合法。
但int a[4][]={2，3，4}非法。
二維數組中的行指針
int a[1][2];
其中a現在就是一個行指針，a+1跳一行數組元素。
搭配(*)p[2]指針
a[0]，a[1]現在就是一個列指針。a[0]+1 跳一個數組
元素。搭配*p[2]指針數組使用
還有記住脫衣服法則：
a[2] 變成 *(a+2) a[2][3]變成 *(a+2)[3]再
可以變成 *(*(a+2)+3)
;『叄』 c語言程序設計
第一章 程序設計的基本概念
第一節 C語言的發展歷史與特點
第二節 程序與程序設計
第三節 演算法與演算法的描述
第四節 C語言的上機操作
思考題與習題
第二章 C語言程序設計基礎
第一節 C語言的程序結構
第二節 數據類型
第三節 運算符與表達式
思考題與習題
第三章 C程序控制結構
第一節 C程序的三種基本控制結構
第二節 順序結構
第三節 選擇結構
第四節 循環結構
思考題與習題
第四章 數組
第一節 數組與數組元素的概念
第二節 一維數組
第三節 二維數組及多維數組
第四節 字元串與字元數組
思考題與習題
第五章 指針
第一節 指針與指針變數的概念
第二節 指針變數的定義和引用
第三節 指針變數與數組
思考題與習題
第六章 函數
第一節 函數的定義
第二節 函數的嵌套調用
第三節 數組作為函數參數
第四節 指針與函數
第五節 變數的使用范圍與存儲類別
第六節 不同文件中的函數使用
思考題與習題
第七章 編譯預處理
第一節 宏定義
第二節 文件包含
第三節 條件編譯
思考題與題
第八章 結構體與共用體
第一節 結構體基礎
第二節 結構體數組
第三節 結構體指針
第四節 鏈表
第五節 位段
第六節 共用體
第七節 枚舉類型與自定義類型
思考題與習題
第九章 文件
第一節 文件概述
第二節 文件的打開與關閉
第三節 文件的讀/寫
第四節 文件的定位
思考題與習題
第十章 程序設計方法
第一節 程序設計的基本概念
第二節 結構化程序設計方法
第三節 程序效率
第四節 程序設計風格
思考題與習題
附錄
附錄A C語言實驗
附錄B 標准ABSII碼表
附錄C C語言中的關鍵字
附錄D 運算符的優先順序與結合性
『肆』 C語言哪部分重要
重點：
首先是第三章 數據類型、運算符、表達式
這些都是基礎，很簡單，但是不看的話後面寫程序經常會出錯的
第四章 第五章 第六章 主要講程序設計結構，
掌握三種程序設計結構：順序結構、選擇結構、循環結構即可
第七章數組第八章指針很重要！如果你還要學習數據結構等等，那麼最好掌握結構體哪一章
應該說 數組、指針、結構體 是c中最難也最重要的知識點吧！不過也不是很難啦 呵呵~難只是一個傳說
另外,團IDC網上有許多產品團購,便宜有口碑
『伍』 C語言的指針是什麼
第一章。指針的概念
指針是一個特殊的變數，它裡面存儲的數值被解釋成為內存里的一個地址。要搞清一個指針需要搞清指針的四方面的內容：指針的類型，指針
所指向的類型，指針的值或者叫指針所指向的內存區，還有指針本身所佔據的內存區。讓我們分別說明。
先聲明幾個指針放著做例子：
例一：
(1)int *ptr;
(2)char *ptr;
(3)int **ptr;
(4)int (*ptr)[3];
(5)int *(*ptr)[4];
如果看不懂後幾個例子的話，請參閱我前段時間貼出的文章 < <如何理解c和c++的復雜類型聲明>>。
1。 指針的類型。
從語法的角度看，你只要把指針聲明語句里的指針名字去掉，剩下的部分就是這個指針的類型。這是指針本身所具有的類型。讓我們看看例一
中各個指針的類型：
(1)int *ptr; //指針的類型是int *
(2)char *ptr; //指針的類型是char *
(3)int **ptr; //指針的類型是 int **
(4)int (*ptr)[3]; //指針的類型是 int(*)[3]
(5)int *(*ptr)[4]; //指針的類型是 int *(*)[4]
怎麼樣？找出指針的類型的方法是不是很簡單？
2。指針所指向的類型。
當你通過指針來訪問指針所指向的內存區時，指針所指向的類型決定了編譯器將把那片內存區里的內容當做什麼來看待。
從語法上看，你只須把指針聲明語句中的指針名字和名字左邊的指針聲明符*去掉，剩下的就是指針所指向的類型。例如：
(1)int *ptr; //指針所指向的類型是int
(2)char *ptr; //指針所指向的的類型是char
(3)int **ptr; //指針所指向的的類型是 int *
(4)int (*ptr)[3]; //指針所指向的的類型是 int()[3]
(5)int *(*ptr)[4]; //指針所指向的的類型是 int *()[4]
在指針的算術運算中，指針所指向的類型有很大的作用。
指針的類型(即指針本身的類型)和指針所指向的類型是兩個概念。當你對C越來越熟悉時，你會發現，把與指針攪和在一起的「類型」這個概念
分成「指針的類型」和「指針所指向的類型」兩個概念，是精通指針的關鍵點之一。我看了不少書，發現有些寫得差的書中，就把指針的這兩
個概念攪在一起了，所以看起書來前後矛盾，越看越糊塗。
3。 指針的值，或者叫指針所指向的內存區或地址。
指針的值是指針本身存儲的數值，這個值將被編譯器當作一個地址，而不是一個一般的數值。在32位程序里，所有類型的指針的值都是一個32
位整數，因為32位程序里內存地址全都是32位長。
指針所指向的內存區就是從指針的值所代表的那個內存地址開始，長度為sizeof(指針所指向的類型)的一片內存區。以後，我們說一個指針的
值是XX，就相當於說該指針指向了以XX為首地址的一片內存區域；我們說一個指針指向了某塊內存區域，就相當於說該指針的值是這塊內存區
域的首地址。
指針所指向的內存區和指針所指向的類型是兩個完全不同的概念。在例一中，指針所指向的類型已經有了，但由於指針還未初始化，所以它所
指向的內存區是不存在的，或者說是無意義的。
以後，每遇到一個指針，都應該問問：這個指針的類型是什麼？指針指向的類型是什麼？該指針指向了哪裡？
4。 指針本身所佔據的內存區。
指針本身佔了多大的內存？你只要用函數sizeof(指針的類型)測一下就知道了。在32位平台里，指針本身占據了4個位元組的長度。
指針本身占據的內存這個概念在判斷一個指針表達式是否是左值時很有用。
第二章。指針的算術運算
指針可以加上或減去一個整數。指針的這種運算的意義和通常的數值的加減運算的意義是不一樣的。例如：
例二：
1。 char a[20];
2。 int *ptr=a;
...
...
3。 ptr++;
在上例中，指針ptr的類型是int*,它指向的類型是int，它被初始化為指向整形變數a。接下來的第3句中，指針ptr被加了1，編譯器是這樣處理
的：它把指針ptr的值加上了sizeof(int)，在32位程序中，是被加上了4。由於地址是用位元組做單位的，故ptr所指向的地址由原來的變數a的地
址向高地址方向增加了4個位元組。
由於char類型的長度是一個位元組，所以，原來ptr是指向數組a的第0號單元開始的四個位元組，此時指向了數組a中從第4號單元開始的四個位元組。
我們可以用一個指針和一個循環來遍歷一個數組，看例子：
例三：
int array[20];
int *ptr=array;
...
//此處略去為整型數組賦值的代碼。
...
for(i=0;i <20;i++)
{
(*ptr)++;
ptr++；
}
這個例子將整型數組中各個單元的值加1。由於每次循環都將指針ptr加1，所以每次循環都能訪問數組的下一個單元。再看例子：
例四：
1。 char a[20];
2。 int *ptr=a;
...
...
3。 ptr+=5;
在這個例子中，ptr被加上了5，編譯器是這樣處理的：將指針ptr的值加上5乘sizeof(int)，在32位程序中就是加上了5乘4=20。由於地址的單
位是位元組，故現在的ptr所指向的地址比起加5後的ptr所指向的地址來說，向高地址方向移動了20個位元組。在這個例子中，沒加5前的ptr指向數
組a的第0號單元開始的四個位元組，加5後，ptr已經指向了數組a的合法范圍之外了。雖然這種情況在應用上會出問題，但在語法上卻是可以的。
這也體現出了指針的靈活性。
如果上例中，ptr是被減去5，那麼處理過程大同小異，只不過ptr的值是被減去5乘sizeof(int)，新的ptr指向的地址將比原來的 ptr所指向的地
址向低地址方向移動了20個位元組。
總結一下，一個指針ptrold加上一個整數n後，結果是一個新的指針ptrnew，ptrnew的類型和ptrold的類型相同，ptrnew所指向的類型和ptrold
所指向的類型也相同。ptrnew的值將比ptrold的值增加了n乘sizeof(ptrold所指向的類型)個位元組。就是說，ptrnew所指向的內存區將比ptrold
所指向的內存區向高地址方向移動了n乘sizeof(ptrold所指向的類型)個位元組。一個指針ptrold減去一個整數n後，結果是一個新的指針ptrnew
，ptrnew的類型和ptrold的類型相同，ptrnew所指向的類型和ptrold所指向的類型也相同。ptrnew的值將比ptrold的值減少了n乘sizeof
(ptrold所指向的類型)個位元組，就是說，ptrnew所指向的內存區將比ptrold所指向的內存區向低地址方向移動了n乘 sizeof(ptrold所指向的類
型)個位元組。
第三章。運算符&和*
這里&是取地址運算符，*是...書上叫做「間接運算符」。&a的運算結果是一個指針，指針的類型是a的類型加個*，指針所指向的類型是a的類
型，指針所指向的地址嘛，那就是a的地址。*p的運算結果就五花八門了。總之*p的結果是p所指向的東西，這個東西有這些特點：它的類型是p
指向的類型，它所佔用的地址是p所指向的地址。
例五：
int a=12;
int b;
int *p;
int **ptr;
p=&a;//&a的結果是一個指針，類型是int*，指向的類型是int，指向的地址是a的地址。
*p=24;//*p的結果，在這里它的類型是int，它所佔用的地址是p所指向的地址，顯然，*p就是變數a。
ptr=&p;//&p的結果是個指針，該指針的類型是p的類型加個*，在這里是int**。該指針所指向的類型是p的類型，這里是int*。該指針所指向的
地址就是指針p自己的地址。
*ptr=&b;//*ptr是個指針，&b的結果也是個指針，且這兩個指針的類型和所指向的類型是一樣的，所以?amp;b來給*ptr賦值就是毫無問題的了
。
**ptr=34;//*ptr的結果是ptr所指向的東西，在這里是一個指針，對這個指針再做一次*運算，結果就是一個int類型的變數。
第四章。指針表達式。
一個表達式的最後結果如果是一個指針，那麼這個表達式就叫指針表達式。下面是一些指針表達式的例子：
例六：
int a,b;
int array[10];
int *pa;
pa=&a;//&a是一個指針表達式。
int **ptr=&pa;//&pa也是一個指針表達式。
*ptr=&b;//*ptr和&b都是指針表達式。
pa=array;
pa++;//這也是指針表達式。
例七：
char *arr[20];
char **parr=arr;//如果把arr看作指針的話，arr也是指針表達式
char *str;
str=*parr;//*parr是指針表達式
str=*(parr+1);//*(parr+1)是指針表達式
str=*(parr+2);//*(parr+2)是指針表達式
由於指針表達式的結果是一個指針，所以指針表達式也具有指針所具有的四個要素：指針的類型，指針所指向的類型，指針指向的內存區，指
針自身占據的內存。
好了，當一個指針表達式的結果指針已經明確地具有了指針自身占據的內存的話，這個指針表達式就是一個左值，否則就不是一個左值。 在例
七中，&a不是一個左值，因為它還沒有占據明確的內存。*ptr是一個左值，因為*ptr這個指針已經占據了內存，其實*ptr就是指針 pa，既然pa
已經在內存中有了自己的位置，那麼*ptr當然也有了自己的位置。
第五章。數組和指針的關系
如果對聲明數組的語句不太明白的話，請參閱我前段時間貼出的文章 < <如何理解c和c++的復雜類型聲明>>。 數組的數組名其實可以看作一個
指針。看下例：
例八：
int array[10]={0,1,2,3,4,5,6,7,8,9},value;
...
...
value=array[0];//也可寫成：value=*array;
value=array[3];//也可寫成：value=*(array+3);
value=array[4];//也可寫成：value=*(array+4);
上例中，一般而言數組名array代表數組本身，類型是int [10]，但如果把array看做指針的話，它指向數組的第0個單元，類型是int *，所指
向的類型是數組單元的類型即int。因此*array等於0就一點也不奇怪了。同理，array+3是一個指向數組第3個單元的指針，所以* (array+3)等
於3。其它依此類推。
例九：
char *str[3]={
"Hello,this is a sample!",
"Hi,good morning.",
"Hello world"
};
char s[80]；
strcpy(s,str[0]);//也可寫成strcpy(s,*str);
strcpy(s,str[1]);//也可寫成strcpy(s,*(str+1));
strcpy(s,str[2]);//也可寫成strcpy(s,*(str+2));
上例中，str是一個三單元的數組，該數組的每個單元都是一個指針，這些指針各指向一個字元串。把指針數組名str當作一個指針的話，它指
向數組的第0號單元，它的類型是char**，它指向的類型是char *。
*str也是一個指針，它的類型是char*，它所指向的類型是char，它指向的地址是字元串"Hello,this is a sample!"的第一個字元的地址，
即'H'的地址。 str+1也是一個指針，它指向數組的第1號單元，它的類型是char**，它指向的類型是char *。
*(str+1)也是一個指針，它的類型是char*，它所指向的類型是char，它指向"Hi,good morning."的第一個字元'H'，等等。
下面總結一下數組的數組名的問題。聲明了一個數組TYPE array[n]，則數組名稱array就有了兩重含義：第一，它代表整個數組，它的類型是
TYPE [n]；第二，它是一個指針，該指針的類型是TYPE*，該指針指向的類型是TYPE，也就是數組單元的類型，該指針指向的內存區就是數組第
0號單元，該指針自己佔有單獨的內存區，注意它和數組第0號單元占據的內存區是不同的。該指針的值是不能修改的，即類似array++的表達式
是錯誤的。
在不同的表達式中數組名array可以扮演不同的角色。
在表達式sizeof(array)中，數組名array代表數組本身，故這時sizeof函數測出的是整個數組的大小。
在表達式*array中，array扮演的是指針，因此這個表達式的結果就是數組第0號單元的值。sizeof(*array)測出的是數組單元的大小。
表達式array+n（其中n=0，1，2，....。）中，array扮演的是指針，故array+n的結果是一個指針，它的類型是TYPE*，它指向的類型是TYPE，
它指向數組第n號單元。故sizeof(array+n)測出的是指針類型的大小。
例十：
int array[10];
int (*ptr)[10];
ptr=&array;
上例中ptr是一個指針，它的類型是int (*)[10]，他指向的類型是int [10]，我們用整個數組的首地址來初始化它。在語句ptr=&array中，
array代表數組本身。
本節中提到了函數sizeof()，那麼我來問一問，sizeof(指針名稱)測出的究竟是指針自身類型的大小呢還是指針所指向的類型的大小？答案是
前者。例如：
int (*ptr)[10];
則在32位程序中，有：
sizeof(int(*)[10])==4
sizeof(int [10])==40
sizeof(ptr)==4
實際上，sizeof(對象)測出的都是對象自身的類型的大小，而不是別的什麼類型的大小。
第六章。指針和結構類型的關系
可以聲明一個指向結構類型對象的指針。
例十一：
struct MyStruct
{
int a;
int b;
int c;
}
MyStruct ss={20,30,40};//聲明了結構對象ss，並把ss的三個成員初始化為20，30和40。
MyStruct *ptr=&ss;//聲明了一個指向結構對象ss的指針。它的類型是
MyStruct*,它指向的類型是MyStruct。
int *pstr=(int*)&ss;//聲明了一個指向結構對象ss的指針。但是它的類型和它指向的類型和ptr是不同的。
請問怎樣通過指針ptr來訪問ss的三個成員變數？
答案：
ptr->a;
ptr->b;
ptr->c;
又請問怎樣通過指針pstr來訪問ss的三個成員變數？
答案：
*pstr；//訪問了ss的成員a。
*(pstr+1);//訪問了ss的成員b。
*(pstr+2)//訪問了ss的成員c。
呵呵，雖然我在我的MSVC++6.0上調式過上述代碼，但是要知道，這樣使用pstr來訪問結構成員是不正規的，為了說明為什麼不正規，讓我們看
看怎樣通過指針來訪問數組的各個單元：
例十二：
int array[3]={35,56,37};
int *pa=array;
通過指針pa訪問數組array的三個單元的方法是：
*pa;//訪問了第0號單元
*(pa+1);//訪問了第1號單元
*(pa+2);//訪問了第2號單元
從格式上看倒是與通過指針訪問結構成員的不正規方法的格式一樣。
所有的C/C++編譯器在排列數組的單元時，總是把各個數組單元存放在連續的存儲區里，單元和單元之間沒有空隙。但在存放結構對象的各個成
員時，在某種編譯環境下，可能會需要字對齊或雙字對齊或者是別的什麼對齊，需要在相鄰兩個成員之間加若干個「填充位元組」，這就導致各
個成員之間可能會有若干個位元組的空隙。
所以，在例十二中，即使*pstr訪問到了結構對象ss的第一個成員變數a，也不能保證*(pstr+1)就一定能訪問到結構成員b。因為成員a和成員b
之間可能會有若干填充位元組，說不定*(pstr+1)就正好訪問到了這些填充位元組呢。這也證明了指針的靈活性。要是你的目的就是想看看各個結構
成員之間到底有沒有填充位元組，嘿，這倒是個不錯的方法。
通過指針訪問結構成員的正確方法應該是象例十二中使用指針ptr的方法。
第七章。指針和函數的關系
可以把一個指針聲明成為一個指向函數的指針。
int fun1(char*,int);
int (*pfun1)(char*,int);
pfun1=fun1;
....
....
int a=(*pfun1)("abcdefg",7);//通過函數指針調用函數。
可以把指針作為函數的形參。在函數調用語句中，可以用指針表達式來作為實參。
例十三：
int fun(char*);
int a;
char str[]="abcdefghijklmn";
a=fun(str);
...
...
int fun(char*s)
{
int num=0;
for(int i=0;i <strlen(s);i++)
{
num+=*s;s++;
}
return num;
}
這個例子中的函數fun統計一個字元串中各個字元的ASCII碼值之和。前面說了，數組的名字也是一個指針。在函數調用中，當把str作為實參傳
遞給形參s後，實際是把str的值傳遞給了s，s所指向的地址就和str所指向的地址一致，但是str和s各自佔用各自的存儲空間。在函數體內對s
進行自加1運算，並不意味著同時對str進行了自加1運算。
第八章。指針類型轉換
當我們初始化一個指針或給一個指針賦值時，賦值號的左邊是一個指針，賦值號的右邊是一個指針表達式。在我們前面所舉的例子中，絕大多
數情況下，指針的類型和指針表達式的類型是一樣的，指針所指向的類型和指針表達式所指向的類型是一樣的。
例十四：
1。 float f=12.3;
2。 float *fptr=&f;
3。 int *p;
在上面的例子中，假如我們想讓指針p指向實數f，應該怎麼搞？是用下面的語句嗎？
p=&f;
不對。因為指針p的類型是int*，它指向的類型是int。表達式&f的結果是一個指針，指針的類型是float*,它指向的類型是 float。兩者不一致
，直接賦值的方法是不行的。至少在我的MSVC++6.0上，對指針的賦值語句要求賦值號兩邊的類型一致，所指向的類型也一致，其它的編譯器上
我沒試過，大家可以試試。為了實現我們的目的，需要進行「強制類型轉換」：
p=(int*)&f;
如果有一個指針p，我們需要把它的類型和所指向的類型改為TYEP*和TYPE，那麼語法格式是：
(TYPE*)p；
這樣強制類型轉換的結果是一個新指針，該新指針的類型是TYPE*，它指向的類型是TYPE，它指向的地址就是原指針指向的地址。而原來的指針
p的一切屬性都沒有被修改。
一個函數如果使用了指針作為形參，那麼在函數調用語句的實參和形參的結合過程中，也會發生指針類型的轉換。
例十五：
void fun(char*);
int a=125,b;
fun((char*)&a);
...
...
void fun(char*s)
{
char c;
c=*(s+3);*(s+3)=*(s+0);*(s+0)=c;
c=*(s+2);*(s+2)=*(s+1);*(s+1)=c;
}
注意這是一個32位程序，故int類型佔了四個位元組，char類型佔一個位元組。函數fun的作用是把一個整數的四個位元組的順序來個顛倒。注意到了
嗎？在函數調用語句中，實?amp;a的結果是一個指針，它的類型是int *，它指向的類型是int。形參這個指針的類型是char*，它指向的類型是
char。這樣，在實參和形參的結合過程中，我們必須進行一次從int*類型到char*類型的轉換。結合這個例子，我們可以這樣來想像編譯器進行
轉換的過程：編譯器先構造一個臨時指針 char*temp，然後執行temp=(char*)&a，最後再把temp的值傳遞給s。所以最後的結果是：s的類型是
char*,它指向的類型是char，它指向的地址就是a的首地址。
我們已經知道，指針的值就是指針指向的地址，在32位程序中，指針的值其實是一個32位整數。那可不可以把一個整數當作指針的值直接賦給
指針呢？就象下面的語句：
unsigned int a;
TYPE *ptr;//TYPE是int，char或結構類型等等類型。
...
...
a=20345686;
ptr=20345686;//我們的目的是要使指針ptr指向地址20345686（十進制）
ptr=a;//我們的目的是要使指針ptr指向地址20345686（十進制）
編譯一下吧。結果發現後面兩條語句全是錯的。那麼我們的目的就不能達到了嗎？不，還有辦法：
unsigned int a;
TYPE *ptr;//TYPE是int，char或結構類型等等類型。
...
...
a=某個數，這個數必須代表一個合法的地址；
ptr=(TYPE*)a；//呵呵，這就可以了。
嚴格說來這里的(TYPE*)和指針類型轉換中的(TYPE*)還不一樣。這里的(TYPE*)的意思是把無符號整數a的值當作一個地址來看待。
上面強調了a的值必須代表一個合法的地址，否則的話，在你使用ptr的時候，就會出現非法操作錯誤。
想想能不能反過來，把指針指向的地址即指針的值當作一個整數取出來。完全可以。下面的例子演示了把一個指針的值當作一個整數取出來，
然後再把這個整數當作一個地址賦給一個指針：
例十六：
int a=123,b;
int *ptr=&a;
char *str;
b=(int)ptr;//把指針ptr的值當作一個整數取出來。
str=(char*)b;//把這個整數的值當作一個地址賦給指針str。
好了，現在我們已經知道了，可以把指針的值當作一個整數取出來，也可以把一個整數值當作地址賦給一個指針。
第九章。指針的安全問題
看下面的例子：
例十七：
char s='a';
int *ptr;
ptr=(int*)&s;
*ptr=1298；
指針ptr是一個int*類型的指針，它指向的類型是int。它指向的地址就是s的首地址。在32位程序中，s佔一個位元組，int類型佔四個位元組。最後
一條語句不但改變了s所佔的一個位元組，還把和s相臨的高地址方向的三個位元組也改變了。這三個位元組是干什麼的？只有編譯程序知道，而寫程
序的人是不太可能知道的。也許這三個位元組里存儲了非常重要的數據，也許這三個位元組里正好是程序的一條代碼，而由於你對指針的馬虎應用
，這三個位元組的值被改變了！這會造成崩潰性的錯誤。讓我們再來看一例：
例十八：
1。 char a;
2。 int *ptr=&a;
...
...
3。 ptr++;
4。 *ptr=115;
該例子完全可以通過編譯，並能執行。但是看到沒有？第3句對指針ptr進行自加1運算後，ptr指向了和整形變數a相鄰的高地址方向的一塊存儲
區。這塊存儲區里是什麼？我們不知道。有可能它是一個非常重要的數據，甚至可能是一條代碼。而第4句竟然往這片存儲區里寫入一個數據！
這是嚴重的錯誤。所以在使用指針時，程序員心裡必須非常清楚：我的指針究竟指向了哪裡。
在用指針訪問數組的時候，也要注意不要超出數組的低端和高端界限，否則也會造成類似的錯誤。
在指針的強制類型轉換：ptr1=(TYPE*)ptr2中，如果sizeof(ptr2的類型)大於sizeof(ptr1的類型)，那麼在使用指針ptr1來訪問ptr2所指向的
存儲區時是安全的。如果sizeof(ptr2的類型)小於sizeof(ptr1的類型)，那麼在使用指針ptr1來訪問ptr2所指向的存儲區時是不安全的。至於
為什麼，讀者結合例十七來想一想，應該會明白的。
請寫出以下程序的運行結果：
#include <stdio.h>
int *p;
pp(int a,int *b);
main()
{
int a=1,b=2,c=3;
p=&b;
pp(a+c,&b);
printf("(1)%d%d%dn",a,b,*p);
}
pp(int a,int *b)
{int c=4;
*p=*b+c;
a=*p-c;
printf("(2)%d%d%dn",a,*b,*p);
}
『陸』 c語言程序設計蘇小紅版第七章課後實驗答案
不知道你說的是不是這一次實驗
2.2.7實驗7：二維數組和函數綜合編程練習
成績排名次
某班期末考試科目為數學（MT）、英語（EN）和物理（PH），有最多不超過30人參加考試。考試後要求：
（1）計算每個學生的總分和平均分；
（2）按總分成績由高到低排出成績的名次；
（3）列印出名次表，表格內包括學生編號、各科分數、總分和平均分；
（4）任意輸入一個學號，能夠查找出該學生在班級中的排名及其考試分數。
【思考題】請讀者思考如下問題。
①如果增加一個要求：要求按照學生的學號由小到大對學號、成績等信息進行排序，那麼程序如何修改呢？
②如果要求程序運行後先列印出一個菜單，提示用戶選擇：成績錄入、成績排序、成績查找，在選擇某項功能後執行相應的操作，那麼程序如何修改呢？
答案
#include <stdio.h>
#define STU 30
#define COURSE 3
void Input(long num[],int score[][COURSE],int n);
void GetSumAver(int score[][COURSE],int n,int sum[],float aver[]);
void Sort(long num[],int score[][COURSE],int n,int sum[],float aver[]);
void Print(long num[],int score[][COURSE],int n,int sum[],float aver[]);
int Search(long num[], int n, long x);
main()
{
int n, score[STU][COURSE], sum[STU], pos;
long num[STU], x;
float aver[STU];
printf("Please enter the total number of the students(n<=30):");
scanf("%d", &n); /*輸入參加考試的學生人數*/
printf("Enter No. and score as: MT EN PH ");
Input(num, score, n); /*輸入學生成績*/
GetSumAver(score, n, sum, aver); /*計算總分和平均分*/
printf("Before sort: ");
Print(num, score, n, sum, aver);
Sort(num, score, n, sum, aver); /*排名次*/
printf("After sort: ");
Print(num, score, n, sum, aver);
printf("Please enter searching number:");
scanf("%ld", &x); /*以長整型格式輸入待查找學生的學號*/
pos = Search(num, n, x); /*名次查詢*/
if (pos != -1)
{
printf("position: NO MT EN PH SUM AVER ");
printf("%8d %4ld %4d %4d %4d %5d %5.0f ",
pos+1,num[pos], score[pos][0],score[pos][1],
score[pos][2], sum[pos],aver[pos]);
}
else
{
printf("Not found! ");
}
}
/* 函數功能：輸入某班學生期末考試三門課程成績
函數參數：長整型數組num，存放學生學號
整型數組score，存放學生成績
整型變數n，存放學生人數
函數返回值：無
*/
void Input(long num[], int score[][COURSE], int n)
{
int i, j;
for (i=0; i<n; i++)
{
scanf("%ld", &num[i]);
for (j=0; j<COURSE; j++)
{
scanf("%d", &score[i][j]);
}
}
}
/* 函數功能：計算每個學生的總分和平均分
函數參數： 整型數組score，存放學生成績
整型變數n，存放學生人數
整型數組sum，計算得到的每個學生的總分
實型數組aver，計算得到的每個學生的平均分
函數返回值：無
*/
void GetSumAver(int score[][COURSE], int n, int sum[], float aver[])
{
int i, j;
for (i=0; i<n; i++)
{
sum[i] = 0;
for (j=0; j<COURSE; j++)
{
sum[i] = sum[i] + score[i][j];
}
aver[i] = (float)sum[i] / COURSE;
}
}
/* 函數功能：按總分成績由高到低排出成績的名次
函數參數：長整型數組num，存放學生學號
整型數組score，存放學生成績
整型變數n，存放學生人數
整型數組sum，存放每個學生的總分
實型數組aver，存放每個學生的平均分
函數返回值：無
*/
void Sort(long num[],int score[][COURSE], int n, int sum[], float aver[])
{
int i, j, k, m;
int temp1;
long temp2;
float temp3;
for (i=0; i<n-1; i++)
{
k = i;
for (j=i+1; j<n; j++)
{
if (sum[j] > sum[k]) k = j;
}
if (k != i)
{
temp1 = sum[k]; sum[k] = sum[i]; sum[i] = temp1;
temp2 = num[k]; num[k] = num[i]; num[i] = temp2;
temp3 = aver[k]; aver[k] = aver[i]; aver[i] = temp3;
for (m=0; m<COURSE; m++)
{
temp1 = score[k][m];
score[k][m] = score[i][m];
score[i][m] = temp1;
}
}
}
}
/* 函數功能： 列印名次表，表格內包括學生編號、各科分數、總分和平均分
函數參數： 長整型數組num，存放學生學號
整型數組score，存放學生成績
整型變數n，存放學生人數
整型數組sum，存放每個學生的總分
實型數組aver，存放每個學生的平均分
函數返回值：無
*/
void Print(long num[], int score[][COURSE], int n,
int sum[], float aver[])
{
int i, j;
printf(" NO | MT EN PH SUM AVER ");
printf("---------------------------------------------------- ");
for (i=0; i<n; i++)
{
printf("%ld | ", num[i]);
for (j=0; j<COURSE; j++)
{
printf("%4d ", score[i][j]);
}
printf("%5d %5.0f ", sum[i], aver[i]);
}
}
/* 函數功能：在學號數組中順序查找學生的學號
函數參數：長整型數組num，存放學生學號
整型變數n，存放學生人數
長整型變數x，存放待查找學生的學號
函數返回值：找到時，返回學生學號在學號數組中的下標位置，否則返回值-1
*/
int Search(long num[], int n, long x)
{
int i;
for (i=0; i<n; i++)
{
if (num[i] == x) return(i);
}
return (-1);
}
『柒』 如何學好C語言
就把譚浩強那本書高透了 基礎打好了就好說了
比如最基礎的 數組 符號 遞歸 循環 等最基礎的東西打牢.
『捌』 C語言程序設計這門課一共有多少章節
這門課一共有10個章節。包括：第一章C語言編程基礎（初級）,第二章流程式控制制（初級）,第三章綜合實例（初級）,第四章數組（中級）,第五章指針初步（中級）,第六章字元串（中級）,第七章結構體和共用體（中級）,第八章函數進階（中級）,第九章預處理指令、綜合案例（中級）,第十章指針進階（高級）,。
『玖』 c語言數據結構（考題，測試你的能力）－－編寫源代碼
P88 稀疏矩陣十字鏈表相加演算法如下：
/*假設ha為A稀疏矩陣十字鏈表的頭指針，hb為B稀疏矩陣十字鏈表的頭指針*/
#include<stdio.h>
#define maxsize 100
struct linknode
{ int i,j;
struct linknode *cptr,*rptr;
union vnext
{ int v;
struct linknode *next;} k;
};
struct linknode creatlindmat( ) /*建立十字鏈表*/
{ int x, m, n, t, s, i, j, k;
struct linknode *p , *q, *cp[maxsize],*hm;
printf("請輸入稀疏矩陣的行、列數及非零元個數\n");
scanf("%d%d%d",&m,&n,&t);
if (m>n) s=m; else s=n;
hm=(struct linknode*)malloc(sizeof(struct linknode)) ;
hm->i=m; hm->j=n;
cp[0]=hm;
for (i=1; i<=s;i++)
{ p=(struct linknode*)malloc(sizeof(struct linknode)) ;
p->i=0; p->j=0;
p->rptr=p; p->cptr=p;
cp[i]=p;
cp[i-1]->k.next=p;
}
cp[s]->k.next=hm;
for( x=1;x<=t;x++)
{ printf("請輸入一個三元組(i,j,v)\n");
scanf("%d%d%d",&i,&j,&k);
p=(struct linknode*)malloc(sizeof(struct linknode));
p->i=i; p->j=j; p->k.v=k;
/*以下是將p插入到第i行鏈表中 */
q=cp[i];
while ((q->rptr!=cp[i]) &&( q->rptr->j<j))
q=q->rptr;
p->rptr=q->rptr;
q->rptr=p;
/*以下是將P插入到第j列鏈表中*/
q=cp[j];
while((q->cptr!=cp[j]) &&( q->cptr->i<i))
q=q->cptr;
p->cptr=q->cptr;
q->cptr=p;
}
return hm;
}
/* ha和hb表示的兩個稀疏矩陣相加，相加的結果放入ha中*/
struct linknode *matadd(struct linknode *ha, struct linknode *hb)
{ struct linknode *pa, *pb, *qa, *ca,*cb,*p,*q;
struct linknode *hl[maxsize];
int i , j, n;
if((ha->i!=hb->i)||(ha->j!=hb->j))
printf("矩陣不匹配,不能相加\n");
else
{ p=ha->k.next; n=ha->j;
for (i=1;i<=n; i++)
{ hl[i]=p;
p=p->k.next;
}
ca=ha->k.next; cb=hb->k.next;
while(ca->i==0)
{pa=ca->rptr; pb=cb->rptr;
qa=ca;
while(pb->j!=0)
{ if((pa->j<pb->j)&&(pa->j!=0))
{ qa=pa; pa=pa->rptr;}
else if ((pa->j>pb->j)||(pa->j==0)) /*插入一個結點*/
{ p=(struct linknode*)malloc(sizeof(struct linknode));
p->i=pb->i; p->j=pb->j;
p->k.v=pb->k.v;
qa->rptr=p; p->rptr=pa;
qa=p; pb=pb->rptr;
j=p->j; q=hl[j]->cptr;
while((q->i<p->i)&&(q->i!=0))
{ hl[j]=q; q=hl[j]->cptr;}
hl[j]->cptr=p; p->cptr=q;
hl[j]=p;
}
else
{pa->k.v=pa->k.v+pb->k.v;
if(pa->k.v==0) /*刪除一個結點*/
{ qa->rptr=pa->rptr;
j=pa->j; q=hl[j]->cptr;
while (q->i<pa->i)
{hl[j]=q; q=hl[j]->cptr;}
hl[j]->cptr=q->cptr;
pa=pa->rptr; pb=pb->rptr;
free(q);
}
else
{ qa=pa; pa=pa->rptr;
pb=pb->rptr;
}
}
}
ca=ca->k.next; cb=cb->k.next;
}
}
return ha;
}
void print(struct linknode *ha) /*輸出十字鏈表*/
{ struct linknode *p,*q;
p=ha->k.next;
while(p->k.next!=ha)
{ q=p->rptr;
while(q->rptr!=p)
{ printf("%3d%3d%3d\t",q->i,q->j,q->k.v);
q=q->rptr;
}
if(p!=q)
printf("%3d%3d%3d",q->i,q->j,q->k.v);
printf("\n");
p=p->k.next;
}
q=p->rptr;
while(q->rptr!=p)
{ printf("%3d%3d%3d\t",q->i,q->j,q->k.v);
q=q->rptr;
}
if(p!=q)
printf("%3d%3d%3d",q->i,q->j,q->k.v);
printf("\n");
}
void main()
{
struct linknode *ha=NULL,*hb=NULL,*hc=NULL;
ha=creatlindmat( ); /*生成一個十字鏈表ha*/
hb=creatlindmat( ); /*生成另一個十字鏈表hb*/
printf("A:\n"); /*輸出十字鏈表ha*/
print(ha);printf("\n");
printf("B:\n"); /*輸出十字鏈表hb*/
print(hb);printf("\n");
hc=matadd(ha,hb); /*十字鏈表相加*/
printf("A+B:\n"); /*輸出相加後的結果*/
print(hc);printf("\n");
}
P94 數據類型描述如下：
#define elemtype char
struct node1
{ int atom;
struct node1 *link;
union
{
struct node1 *slink;
elemtype data;
} ds;
}
P95 數據類型描述如下：
struct node2
{ elemtype data;
struct node2 *link1,*link2;
}
P96 求廣義表的深度depth(LS)
int depth(struct node1 *LS)
{
int max=0,dep;
while(LS!=NULL)
{ if(LS->atom==0) //有子表
{ dep=depth(LS->ds.slink);
if(dep>max) max=dep;
}
LS=LS->link;
}
return max+1;
}
P96 廣義表的建立creat(LS)
void creat(struct node1 *LS)
{
char ch;
scanf("%c",&ch);
if(ch=='#')
LS=NULL;
else if(ch=='(')
{LS=(struct node*)malloc(sizeof(struct node));
LS->atom=0;
creat(LS->ds.slink);
}
else
{ LS=(struct node*)malloc(sizeof(struct node));
LS->atom=1;
LS->ds.data=ch;
}
scanf("%c",&ch);
if(LS==NULL);
else if(ch==',')
creat(LS->link);
else if((ch==')')||(ch==';'))
LS->link=NULL;
}
P97 輸出廣義表print(LS)
void print(struct node1 *LS)
{
if(LS->atom==0)
{
printf("(");
if(LS->ds.slink==NULL)
printf("#");
else
print(LS->ds.slink);
}
else
printf("%c ",LS->ds.data);
if(LS->atom==0)
printf(")");
if(LS->link!=NULL)
{
printf(";");
print(LS->link);
}
}
P98 該演算法的時間復雜度為O(n)。整個完整程序如下：
#include<stdio.h>
#define elemtype char
struct node1
{ int atom;
struct node1 *link;
union
{
struct node1 *slink;
elemtype data;
} ds;
};
void creat(struct node1 LS) /*建立廣義表的單鏈表*/
{
char ch;
scanf("%c",&ch);
if(ch=='#')
LS=NULL;
else if(ch=='(')
{LS=(struct node1*)malloc(sizeof(struct node1));
LS->atom=0;
creat(LS->ds.slink);
}
else
{ LS=(struct node1*)malloc(sizeof(struct node1));
LS->atom=1;
LS->ds.data=ch;
}
scanf("%c",&ch);
if(LS==NULL);
else if(ch==',')
creat(LS->link);
else if((ch==')')||(ch==';'))
LS->link=NULL;
}
void print(struct node1 LS) /*輸出廣義單鏈表*/
{
if(LS->atom==0)
{
printf("(");
if(LS->ds.slink==NULL)
printf("#");
else
print(LS->ds.slink);
}
else
printf("%c",LS->ds.data);
if(LS->atom==0)
printf(")");
if(LS->link!=NULL)
{
printf(";");
print(LS->link);
}
}
int depth(struct node1 LS) /*求廣義表的深度*/
{
int max=0;
while(LS!=NULL)
{ if(LS->atom==0)
{ int dep=depth(LS->ds.slink);
if(dep>max) max=dep;
}
LS=LS->link;
}
return max+1;
}
main()
{ int dep;
struct node1 *p=NULL;
creat(p); /*建立廣義表的單鏈表*/
print(p); /*輸出廣義單鏈表*/
dep=depth(p); /*求廣義表的深度*/
printf("%d\n",dep);
}
第六章 樹
P109 二叉鏈表的結點類型定義如下：
typedef struct btnode
{ anytype data;
struct btnode *Lch,*Rch;
}tnodetype;
P109 三叉鏈表的結點類型定義如下：
typedef struct btnode3
{ anytype data;
struct btnode *Lch,*Rch，*Parent ;
}tnodetype3;
P112 C語言的先序遍歷演算法：
void preorder (tnodetype *t)
/*先序遍歷二叉樹演算法，t為指向根結點的指針*/
{ if (t!=NULL)
{printf("%d ",t->data);
preorder(t->lch);
preorder(t->rch);
}
}
P113 C語言的中序遍歷演算法：
void inorder(tnodetype *t)
/*中序遍歷二叉樹演算法，t為指向根結點的指針*/
{
if(t!=NULL)
{inorder(t->lch);
printf("%d ",t->data);
inorder(t->rch);
}
}
P113 C語言的後序遍歷演算法：
void postorder(tnodetype *t)
/*後序遍歷二叉樹演算法，t為指向根結點的指針*/
{
if(t!=NULL)
{ postorder(t->lch);
postorder(t->rch);
printf("%d ",t->data);
}
}
P114 如果引入隊列作為輔助存儲工具，按層次遍歷二叉樹的演算法可描述如下：
void levelorder(tnodetype *t)
/*按層次遍歷二叉樹演算法，t為指向根結點的指針*/
{tnodetype q[20]; /*輔助隊列*/
front=0;
rear=0; /*置空隊列*/
if (t!=NULL)
{ rear++;
q[rear]=t; /*根結點入隊*/
}
while (front!=rear)
{ front++;
t=q [front];
printf ("%c\n",t->data);
if (t->lch!=NULL) /*t的左孩子不空，則入隊*/
{ rear++;
q [rear]=t->lch;
}
if (t->rch!=NULL) /*t的右孩子不空，則入隊*/
{ rear++;
q [rear]=t->rch;
}
}
}
P115 以中序遍歷的方法統計二叉樹中的結點數和葉子結點數，演算法描述為：
void inordercount (tnodetype *t)
/*中序遍歷二叉樹，統計樹中的結點數和葉子結點數*/
{ if (t!=NULL)
{ inordercount (t->lch); /*中序遍歷左子樹*/
printf ("%c\n",t->data); /*訪問根結點*/
countnode++; /*結點計數*/
if ((t->lch==NULL)&&(t->rch==NULL))
countleaf++; /*葉子結點計數*/
inordercount (t->rch); /*中序遍歷右子樹*/
}
}
P115 可按如下方法計算一棵二叉樹的深度：
void preorderdeep (tnodetype *t,int j)
/*先序遍歷二叉樹，並計算二叉樹的深度*/
{ if (t!=NULL)
{ printf ("%c\n",t->data); /*訪問根結點*/
j++;
if (k<j) k=j;
preorderdeep (t->lch,j); /*先序遍歷左子樹*/
preorderdeep (t->rch,j); /*先序遍歷右子樹*/
}
}
P117 線索二叉樹的結點類型定義如下：
struct nodexs
{anytype data;
struct nodexs *lch, *rch;
int ltag,rtag; /*左、右標志域*/
}
P117 中序次序線索化演算法
void inorderxs (struct nodexs *t)
/*中序遍歷t所指向的二叉樹，並為結點建立線索*/
{ if (t!=NULL)
{ inorderxs (t->lch);
printf ("%c\n",t->data);
if (t->lch!=NULL)
t->ltag=0;
else { t->ltag=1;
t->lch=pr;
} /*建立t所指向結點的左線索，令其指向前驅結點pr*/
if (pr!=NULL)
{ if (pr->rch!=NULL)
pr->rtag=0;
else { pr->rtag=1;
pr->rch=p;
}
} /*建立pr所指向結點的右線索，令其指向後繼結點p*/
pr=p;
inorderxs (t->rch);
}
}
P118 在中根線索樹上檢索某結點的前驅結點的演算法描述如下：
struct nodexs * inpre (struct nodexs *q)
/*在中根線索樹上檢索q所指向的結點的前驅結點*/
{ if (q->ltag==1)
p=q->lch;
else { r=q->lch;
while (r->rtag!=1)
r=r->rch;
p=r;
}
return (p);
}
P119 在中根線索樹上檢索某結點的後繼結點的演算法描述如下：
struct nodexs * insucc (struct nodexs *q)
/*在中根線索樹上檢索q所指向的結點的後繼結點*/
{ if (q->rtag==1)
p=q->rch;
else { r=q->rch;
while (r->ltag!=1)
r=r->lch;
p=r;
}
return (p);
}
P120 演算法程序用C語言描述如下：
void sortBT(BT *t,BT *s) /*將指針s所指的結點插入到以t為根指針的二叉樹中*/
{ if (t==NULL) t=s; /*若t所指為空樹，s所指結點為根*/
else if (s->data < t->data)
sortBT(t->lch,s); /*s結點插入到t的左子樹上去*/
else
sortBT(t->rch,s); /*s結點插入到t的右子樹上去*/
}
P121 二叉排序樹結點刪除演算法的C語言描述如下：
void delnode(bt,f,p)
/*bt為一棵二叉排序樹的根指針，p指向被刪除結點，f指向其雙親*/
/*當p=bt時f為NULL*/
{ fag=0; /*fag=0時需修改f指針信息，fag=1時不需修改*/
if (p->lch==NULL)
s=p->rch; /*被刪除結點為葉子或其左子樹為空*/
else if (p->rch==NULL)
s=p->lch;
else { q=p; /*被刪除結點的左、右子樹均非空*/
s=p->lch;
while (s->rch!=NULL)
{ q=s;
s=s->rch;
} /*尋找s結點*/
if (q=p)
q->lch=s->lch;
else q->rch=s->lch;
p->data=s->data; /*s所指向的結點代替被刪除結點*/
DISPOSE(s);
Fag=1;
}
if (fag=0) /*需要修改雙親指針*/
{ if (f=NULL)
bt=s; /*被刪除結點為根結點*/
else if (f->lch=p)
f->lch=s;
else f->rch=s;
DISPOSE(p); /*釋放被刪除結點*/
}
}
第七章 圖
P134 用鄰接矩陣表示法表示圖，除了存儲用於表示頂點間相鄰關系的鄰接矩陣外，通常還需要用一個順序表來存儲頂點信息。其形式說明如下：
# define n 6 /*圖的頂點數*/
# define e 8 /*圖的邊(弧)數*/
typedef char vextype; /*頂點的數據類型*/
typedef float adjtype; /*權值類型*/
typedef struct
{vextype vexs[n];
adjtype arcs[n][n];
}graph;
P135 建立一個無向網路的演算法。
CREATGRAPH(ga) /*建立無向網路*/
Graph * ga;
{
int i,j,k;
float w;
for(i＝0;i<n;i++ )
ga ->vexs[i]＝getchar(); /*讀入頂點信息，建立頂點表*/
for(i＝0;i<n;i++ )
for(j＝0;j<n;j++)
ga ->arcs[i][j]＝0; /*鄰接矩陣初始化*/
for(k＝0;k<e;k++) /*讀入e條邊*/
(scanf("％d％d％f",&I,&j,&w); /*讀入邊(vi,vj)上的權w */
ga ->arcs[i][j]＝w;
ga - >arcs[j][i]＝w;
}
} /*CREATGRAPH*/
P136 鄰接表的形式說明及其建立演算法：
typedef struct node
{int adjvex; /*鄰接點域*/
struct node * next; /*鏈域*/
}edgenode; /*邊表結點*/
typedef struct
{vextype vertex; /*頂點信息*/
edgenode link; /*邊表頭指針*/
}vexnode; /*頂點表結點*/
vexnode ga[n];
CREATADJLIST(ga) /*建立無向圖的鄰接表*/
Vexnode ga[ ];
{int i,j,k;
edgenode * s;
for(i=o;i<n;i++＝ /*讀入頂點信息*/
(ga[i].vertex＝getchar();
ga[i].1ink＝NULL; /*邊表頭指針初始化*/
}
for(k＝0;k<e;k++＝ /*建立邊表*/
{scanf("％d％d",&i,&j); /*讀入邊(vi , vj)的頂點對序號*/
s＝malloc(sizeof(edgenode)); /*生成鄰接點序號為j的表結點*s */
s-> adjvex＝j;
s- - >next：＝ga[i].Link;
ga[i].1ink＝s; /*將*s插入頂點vi的邊表頭部*/
s＝malloc(size0f(edgende)); /*生成鄰接點序號為i的邊表結點*s */
s ->adjvex＝i;
s ->next＝ga[j].1ink;
ga[j].1ink＝s; /*將*s插入頂點vj的邊表頭部*/
}
} /* CREATADJLIST */
P139 分別以鄰接矩陣和鄰接表作為圖的存儲結構給出具體演算法，演算法中g、g1和visited為全程量，visited的各分量初始值均為FALSE。
int visited[n] /*定義布爾向量visitd為全程量*/
Graph g; /*圖g為全程量*/
DFS(i) /*從Vi+1出發深度優先搜索圖g，g用鄰接矩陣表示*/
int i;
{ int j;
printf("node：％c＼n" , g.vexs[i]); /*訪問出發點vi+1 */
Visited[i]＝TRUE; /*標記vi+l已訪問過*/
for (j＝0;j<n;j++) /*依次搜索vi+1的鄰接點*/
if((g.arcs[i][j]＝＝1) ＆＆(! visited[j]))
DFS(j); /*若Vi+l的鄰接點vj+l未曾訪問過，則從vj+l出發進行深度優先搜索*/
} /*DFS*/
vexnode gl[n] /*鄰接表全程量*/
DFSL(i) /*從vi+l出發深度優先搜索圖g1，g1用鄰接表表示*/
int i;
{ int j;
edgenode * p;
printf("node：％C\n" ,g1[i].vertex);
vistited[i]＝TRUE;
p＝g1[i].1ink; /*取vi+1的邊表頭指針*/
while(p !＝NULL) /*依次搜索vi+l的鄰接點*/
{
if(! Vistited[p ->adjvex])
DFSL(p - >adjvex); /*從vi+1的未曾訪問過的鄰接點出發進行深度優先搜索*/
p＝p - >next; /*找vi+l的下一個鄰接點*/
}
} /* DFSL */
P142 以鄰接矩陣和鄰接表作為圖的存儲結構，分別給出寬度優先搜索演算法。
BFS(k) /＊從vk+l出發寬度優先搜索圖g，g用鄰接矩陣表示，visited為訪問標志向量*/
int k;
{ int i,j;
SETNULL(Q); /*置空隊Q */
printf("％c＼n"，g.vexs[k]); /*訪問出發點vk+l*x/
visited[k]＝TRUE; /*標記vk+l已訪問過*/
ENQUEUE(Q，K); /*已訪問過的頂點(序號)入隊列*/
While(!EMPTY(Q)) /*隊非空時執行*/
{i＝DEQUEUE(Q); /*隊頭元素序號出隊列*/
for(j＝0;j<n;j++)
if((g.arcs[i][j]＝＝1)＆＆(! visited[j]))
{printf("％c＼n" , g.vexs[j]); /*訪問vi+l的未曾訪問的鄰接點vj+l */
visited[j]＝TRUE;
ENQUEUE(Q,j); /*訪問過的頂點入隊*/
}
}
} /* BFS */
BFSL(k) /*從vk+l出發寬度優先搜索圖g1，g1用鄰接表表示*/
int k
{ int i;
edgenode * p;
SETNULL(Q);
printf("％c＼n" , g1[k].vertex);
visited[k]＝TRUE;
ENQUEUE(Q,k);
while(! EMPTY(Q));
{ i＝DEQUEUE(Q);
p＝g1[i].1ink /*取vi+l的邊表頭指針*/
while(p !＝NULL) /*依次搜索vi+l的鄰接點*/
{ if( ! visited[p - >adjvex]) /*訪問vi+l的未訪問的鄰接點*/
{ printf{"％c＼n" , g1[p - >adjvex].vertex};
visited[p - >adjvex]＝TRUE;
ENQUEUE(Q,p - >adjvex); /*訪問過的頂點入隊*/
}
p＝p - >next; /*找vi+l的下一個鄰接點*/
}
}
} /*BFSL*/
P148 在對演算法Prim求精之前，先確定有關的存儲結構如下：
typdef struct
{Int fromvex，endvex; /*邊的起點和終點*/
float length; /*邊的權值*/
} edge;
float dist[n][n]; /*連通網路的帶權鄰接矩陣*/
edgeT[n-1]; /*生成樹*/
P149 抽象語句(1)可求精為：
for(j=1;j<n;j++) /*對n-1個藍點構造候選紫邊集*/
{T[j-1].fromvex＝1}; /*紫邊的起點為紅點*/
T[j-1].endvex＝j+1; /*紫邊的終點為藍點*/
T[j-1].1ength＝dist[0][j]; /*紫邊長度*/
}
P149 抽象語句(3)所求的第k條最短紫邊可求精為：
min＝max; /*znax大於任何邊上的權值*/
for (j＝k;j<n-1;j++) /*掃描當前候選紫邊集T[k]到T[n-2]，找最短紫邊*/
if(T[j].1ength<min)
{min＝T[j].1ength;m＝j; /*記錄當前最短紫邊的位置*/
}
P149 抽象語句(4)的求精：
e＝T[m];T[m]＝T[k];T[k]＝e， /* T[k]和T[m]交換*/
v＝T[kl.Endvex]; /* v是剛被塗紅色的頂點*/
P149 抽象語句(5)可求精為：
for(j＝k+1;j<n-1;j++) /*調整候選紫邊集T[k+1]到T[n-2]*/
{d＝dist[v-1][T[j].endvex-1]; /*新紫邊的長度*/
if(d<T[j].1ength) /*新紫邊的長度小於原最短紫邊*/
{T[j].1ength＝d;
T[j].fromvex＝v; /*新紫邊取代原最短紫邊*/
}
}
P150 完整的演算法：
PRIM() /*從第一個頂點出發構造連通網路dist的最小生成樹，結果放在T中*/
{int j , k , m , v , min , max＝l0000;
float d;
edge e;
for(j=1;j<n;j++) /*構造初始候選紫邊集*/
{T[j-1].formvex＝1; /*頂點1是第一個加入樹中的紅點*/
T[j-1].endvex＝j+1;
T[j-1].length＝dist[o][j];
}
for(k＝0;k<n-1;k++) /*求第k條邊*/
{min＝max;
for(j＝k;j<n-1;j++) /*在候選紫邊集中找最短紫邊*/
if(T[j].1ength<min)
{min＝T[j].1ength;
m＝j;
} /*T[m]是當前最短紫邊*/
}
e＝T[m];T[m]＝T[k];T[k]＝e; /*T[k]和T[m]交換後，T[k]是第k條紅色樹邊*/
v＝T[k].endvex ; /* v是新紅點*/
for(j＝k+1;j<n-1;j++) /*調整候選紫邊集*/
{d＝dist[v-1][T[j].endvex-1];
if(d<T[j].1ength);
{T[j].1ength＝d;
T[j].fromvex＝v;
}
}
} /* PRIM */
P151 Kruskl演算法的粗略描述：
T＝(V,φ);
While(T中所含邊數<n-1)
{從E中選取當前最短邊(u,v);
從E中刪去邊(u,v);
if((u,v)並入T之後不產生迴路，將邊(u,v)並入T中;
}
P153 迪傑斯特拉演算法實現。演算法描述如下：
#define max 32767 /*max代表一個很大的數*/
void dijkstra (float cost[][n],int v)
/*求源點v到其餘頂點的最短路徑及其長度*/
{ v1=v-1;
for (i=0;i<n;i++)
{ dist[i]=cost[v1][i]; /*初始化dist*/
if (dist[i]<max)
pre[i]=v;
else pre[i]=0;
}
pre[v1]=0;
for (i=0;i<n;i++)
s[i]=0; /*s數組初始化為空*/
s[v1]=1; /*將源點v歸入s集合*/
for (i=0;i<n;i++)
{ min=max;
for (j=0;j<n;j++)
if (!s[j] && (dist[j]<min))
{ min=dist[j];
k=j;
} /*選擇dist值最小的頂點k+1*/
s[k]=1; /*將頂點k+1歸入s集合中*/
for (j=0;j<n;j++)
if (!s[j]&&(dist[j]>dist[k]+cost[k][j]))
{ dist[j]=dist[k]+cost[k][j]; /*修改 V-S集合中各頂點的dist值*/
pre[j]=k+1; /*k+1頂點是j+1頂點的前驅*/
}
} /*所有頂點均已加入到S集合中*/
for (j=0;j<n;j++) /*列印結果*/
{ printf("%f\n%d",dist[j],j+1;);
p=pre[j];
while (p!=0)
{ printf("%d",p);
p=pre[p-1];
}
}
}
P155 弗洛伊德演算法可以描述為：
A(0)[i][j]=cost[i][j]; //cost為圖的鄰接矩陣
A(k)[i][j]=min{A(k-1) [i][j],A(k-1) [i][k]+A(k-1) [k][j]}
其中 k=1,2,…,n
P155 弗洛伊德演算法實現。演算法描述如下：
int path[n][n]; /*路徑矩陣*/
void floyd (float A[][n],cost[][n])
{ for (i=0;i<n;i++) /*設置A和path的初值*/
for (j=0;j<n;j++)
{ if (cost[i][j]<max)
path[i][j]=j;
else { path[i][j]=0;
A[i][j]=cost[i][j];
}
}
for (k=0;k<n;k++)
/*做n次迭代，每次均試圖將頂點k擴充到當前求得的從i到j的最短路徑上*/
for (i=0;i<n;i++)
for (j=0;j<n;j++)
if (A[i][j]>(A[i][k]+A[k]