第五篇：基本数据结构——线性表的链式表示

以下为操作链表的算法，该链表为动态单链表。
链表以头指针为索引，头指针指向头节点，头节点指向首节点，以此类推，直到尾节点。
头节点中不存放数据，只存放指向首节点的指针，
设置头节点的目的是为了方便对链表的操作，如果不设置头节点，而是直接由头指针指向首节点，
这样在对头指针后的节点进行插入删除操作时就会与其他节点进行该操作时有所不同，便要作为一种特殊情况来分析

操作系统：ubuntu

编译软件：gcc 

结果截图：

源代码：

[cpp] view plain copy

1. #include<stdio.h>  
2. #include<stdlib.h>  
3. #include<stdbool.h>  
4.   
5. typedef struct Node  
6. {  
7.  int data;  
8.  struct Node *pNext;  
9. }NODE,*PNODE;  
10.   
11. PNODE create_list();        
12. void traverse_list(PNODE);  
13. bool is_empty(PNODE);      
14. int length_list(PNODE);  
15. void sort_list(PNODE);     
16. bool insert_list(PNODE,int,int);  
17. bool delete_list(PNODE,int,int *);  
18. void clear_list(PNODE);  
19.   
20. int main(void)  
21. {  
22.  int len;  
23.  int data_del;  
24.  PNODE pHead = NULL;  
25.   
26.  //创建链表并遍历输出  
27.   pHead = create_list();  
28.  traverse_list(pHead);  
29.   
30.  //求链表长度，并输出  
31.  len = length_list(pHead);  
32.  if(!is_empty(pHead))  
33.   printf("the length of the list is:%d\n",len);  
34.    
35.  //向链表中插入数据，并重新遍历输出  
36.  if(insert_list(pHead,3,78))  
37.   printf("insert succeed,");  
38.  else  
39.   printf("insert failed,");  
40.  traverse_list(pHead);  
41.   
42.  //从链表中删除数据，并重新遍历输出  
43.  if(delete_list(pHead,3,&data_del))  
44.   {  
45.     printf("delete succeed,the deleted data is:%d\n",data_del);  
46.   }  
47.  else  
48.   printf("delete failed,");  
49.  traverse_list(pHead);  
50.    
51.  //对链表排序，重新遍历输出  
52.  sort_list(pHead);  
53.  printf("After sorted,");  
54.  traverse_list(pHead);   
55.    
56.  //清空链表，遍历输出（无数据输出）  
57.  clear_list(pHead);  
58.  printf("After cleared,");  
59.  traverse_list(pHead);   
60.  return 0;  
61. }  
62.   
63. //子函数：创建一个链表,并返回头指针  
64. PNODE create_list()  
65. {  
66.  int val;  
67.  PNODE pHead =(PNODE)malloc(sizeof(NODE));  
68.  PNODE pCurrent = pHead;  
69.  pCurrent->pNext = NULL;  
70.  if(NULL == pHead)  
71.  {  
72.   printf("pHead malloc failed!");  
73.   exit(-1);  
74.  }  
75.  printf("Input first data(q to quit):");  
76.  while(scanf("%d",&val)==1)  
77.  {  
78.   PNODE pNew = (PNODE)malloc(sizeof(NODE));  
79.   if(NULL == pNew)  
80.   {  
81.    printf("pNew malloc failed!");  
82.    exit(-1);  
83.   }  
84.   pNew->data = val;  
85.   pCurrent->pNext = pNew;  
86.   pNew->pNext = NULL;  
87.   pCurrent = pNew;  
88.   printf("Input next data(q to quit):");  
89.  }   
90.  return pHead;   
91. }  
92.   
93. //子函数：遍历链表  
94.   
95. void traverse_list(PNODE pHead)  
96. {  
97.  PNODE pCurrent = pHead->pNext;  
98.  printf("now dataes in the list are:\n");  
99.  while(pCurrent != NULL)  
100.  {   
101.   printf("%d ",pCurrent->data);  
102.   pCurrent = pCurrent->pNext;  
103.  }  
104.  printf("\n");  
105.  return ;  
106. }   
107. //子函数：判断链表是否为空  
108. bool is_empty(PNODE pNode)  
109. {  
110.  if(NULL == pNode->pNext)  
111.   return true;  
112.  else  
113.   return false;  
114. }  
115.   
116. //子函数：求链表长度（不计入头结点）  
117. int length_list(PNODE pNode)  
118. {  
119.  int count = 0;  
120.  PNODE pCurrent = pNode->pNext;  
121.  while(pCurrent != NULL)  
122.  {  
123.   count++;  
124.   pCurrent = pCurrent->pNext;    
125.  }  
126.   
127.  return count;  
128. }  
129.   
130. //子函数：冒泡法对链表排序  
131. void sort_list(PNODE pHead)  
132. {  
133.  PNODE p,q;  
134.  int temp;  
135.  for(p=pHead->pNext;p!=NULL;p=p->pNext)  
136.      for(q=p->pNext;q!=NULL;q=q->pNext)  
137.   {  
138.      if(p->data>q->data)  
139.                {  
140.     temp = p->data;  
141.     p->data = q->data;  
142.     q->data = temp;  
143.         }  
144.   }  
145.   
146.  return ;  
147. }  
148.   
149. //子函数：在第pos个节点的后面插入一个新的节点，该节点中的数据为val  
150. bool insert_list(PNODE pHead,int pos,int val)  
151. {  
152.  int i = 0;  
153.  PNODE p = pHead;  
154.   
155.  //i为0时，p指向第0个节点（这里指没有实际数据的头节点，不计入链表节点总数），  
156.  //i为1时，p指向第1个节点，i为几，p就指向第几个节点  
157.  while(p!=NULL && i<pos)  
158.  {  
159.     p = p->pNext;  
160.     i++;  
161.  }  
162.   
163.  //当pos的值大于链表长度时或者pos<0时，便会出现这种情况  
164.  if(i>pos || p==NULL)  
165.     return false;  
166.   
167.  PNODE pNew = (PNODE)malloc(sizeof(NODE));  
168.  if(NULL == pNew)  
169.  {  
170.     printf("pNew malloc failed!");  
171.     exit(-1);  
172.  }  
173.  pNew->data = val;  
174.  pNew->pNext = p->pNext;  
175.  p->pNext = pNew;  
176.   
177.  return true;  
178. }  
179.   
180. //子函数：删除第pos个节点，并将删除的数据保存在pData指针所指向的位置  
181. bool delete_list(PNODE pHead,int pos,int *pData)  
182. {  
183.  int i = 0;  
184.  PNODE p = pHead;  
185.   
186.  //p最终指向第pos个节点前面的节点,这里同样以头结点为第0个节点  
187.  //如果下面两句分别改为while(p!=NULL && i<pos)和if(i>pos-1 || p==NULL)，则p最终指向第pos个节点，  
188.  //这样因为得不到第pos个节点前面的那个节点，因此无法将pos前后两个节点连结起来  
189.  while(p->pNext!=NULL && i<pos)  
190.   
191.  {  
192.     p = p->pNext;  
193.     i++;  
194.  }  
195.   
196.  //当pos的值大于链表长度时或者pos<1时，便会出现这种情况，第0个节点，即头结点是不能被删除的。  
197.  if(i>pos-1 || p->pNext==NULL)  
198.     return false;  
199.   
200.  PNODE q = p->pNext;  
201.  *pData = q->data;  
202.  p->pNext = p->pNext->pNext;  
203.  free(q);  
204.  q = NULL;  
205.  return true;  
206. }  
207.   
208. //子函数：清空链表，即使链表只剩下头节点（头节点中没有数据）  
209. void clear_list(PNODE pHead)  
210. {  
211.  PNODE p = pHead->pNext;  
212.  PNODE r = NULL;  
213.  while(p != NULL)  
214.  {  
215.     r = p->pNext;  
216.     free(p);  
217.     p = r;  
218.  }  
219.  pHead->pNext = NULL;  
220.  return ;  
221. }