链表学习--双向链表实现

今天学习了链表的数据结构。他的主要思路为:
1. 他访问数据的方式不是数组的下标，而是他的节点的指针来访问。所以他可以更灵活的处理数据见得 相关信息。不过他的速度肯定没有数组下标快的，空间也没有数组利用率高，可他的灵活性给了我们很大的方便。我们用链表的时候还是很多的。
2. 链 表是用指针的指向来访问管理数据的，一个我们把数据存在一个节点里，一个节点包括：nData，节点的数据域，nNext，他指向的下一个指针，nPre 他的上一个指针。如果他没有下一个指针或上一个指针，我们指向空nil.
3. 一般一个链表有一个头节点。以他开始访问整个链表区域的数据。这样 我们就能更好的控制链表了，就像数组下标为0的元素一样。A[0]的地位。
截取书上的图：

这就是一个链表的样子了。呵呵 是不是很直观呢？
链表主要的操作包括：
插入，删除，查找，清空，等主要操作。
很重要的数据结构， 奉上源代码：

 

view plain copy to clipboard print ?

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. //定义链表的结构体。  
4. struct MyList  
5. {  
6.     int nData;  
7.     MyList* pPre;  
8.     MyList* pNext;  
9. };  
10. //全局的变量，保存链表的头  
11. MyList* g_pHead = NULL;  
12. //判断链表是否为空  
13. bool IsEmpty()  
14. {  
15.     //如果头指针指向的是空，链表为空  
16.     return g_pHead == NULL;  
17. }  
18. //清空链表  
19. int Clear()  
20. {  
21.     //删除所有数据，并把头指针指向为空  
22.     MyList* pTemp = g_pHead;  
23.     //遍历链表的数据。如果有数据，删除，然后进入下一个数据  
24.     while(g_pHead)  
25.     {  
26.         g_pHead = g_pHead->pNext;  
27.         delete pTemp;  
28.         pTemp = g_pHead;  
29.     }  
30.     return 1;  
31. }  
32. //插入数据到链表中  
33. int Insert(int nData)  
34. {  
35.     //这里是插入到头的位置，类似栈的操作。  
36.     MyList* pTemp = new MyList();    //申请一个新的空间存放数据。  
37.     pTemp->nData = nData;  
38.     pTemp->pPre = NULL;            //他的上一个没有  
39.     pTemp->pNext = g_pHead;        //他的next指向头节点，他作为头节点的上一个成为新头节点  
40.     if (g_pHead)  
41.     {  
42.         g_pHead->pPre = pTemp;    //如果头节点有数据，则把头节点的上一个指向该节点。  
43.     }  
44.     g_pHead = pTemp;            //是头节点指针指向他，他成为新的头节点  
45.     return 1;  
46. }  
47. //查找数据  
48. bool Find(int nData)  
49. {  
50.     MyList* pTemp = g_pHead;        //从头节点开始寻找。  
51.     //遍历数据  
52.     while(pTemp)  
53.     {  
54.         if (pTemp->nData == nData)    //如果找到该数据，  
55.         {  
56.             return true;            //返回真。  
57.         }  
58.         pTemp = pTemp->pNext;        //没有找到，进入下一个节点  
59.     }  
60.     return false;            //遍历之后没有找到，则没有该数据，返回false  
61. }  
62. //删除数据。  
63. bool Delete(int nData)  
64. {  
65.     //先找到数据，然后再删除。  
66.     MyList* pTemp = g_pHead;    //要删除的节点指针。      
67.     //遍历链表找到要删除的节点  
68.     while (pTemp)          
69.     {  
70.         if (pTemp->nData == nData)    //找到了，删除它  
71.         {  
72.             if (pTemp->pPre)    //如果他有前一个节点，则前一个节点的next指向他的下一个节点  
73.             {                    //这样就不会吊链了。  
74.                 pTemp->pPre->pNext = pTemp->pNext;  
75.             }  
76.             else        //没有上一个节点，则他就是头节点。  
77.             {  
78.                 g_pHead = pTemp->pNext;    //头节点指针指向他，他就可以安息了。  
79.             }  
80.             if (pTemp->pNext)    //处理他的下一个节点情况，和上节点类似  
81.             {  
82.                 pTemp->pNext->pPre = pTemp->pPre;  
83.             }  
84.             delete pTemp;    //删除它的数据空间  
85.             return true;    //返回true,删除成功  
86.         }  
87.     }  
88.     return false;    //没有找到数据，删除失败，返回false  
89. }  
90. int main()  
91. {  
92.     //测试，  
93.     for (int i = 0; i < 10; ++i)  
94.     {  
95.         Insert(i);    //插入数据  
96.     }  
97.     if (Find(5)) //查找数据  
98.     {  
99.         printf("Yes!/n");  
100.     }  
101.     if (!Find(11))  
102.     {  
103.         printf("No!/n");  
104.     }  
105.     while(!IsEmpty())    //逐一删除数据  
106.     {  
107.         printf("%d ", g_pHead->nData);  
108.         Delete(g_pHead->nData);  
109.     }  
110.     printf("/n");  
111.     for (int i = 0; i < 10; ++i)  
112.     {  
113.         Insert(i);  
114.     }  
115.     Clear();        //清空数据。  
116.     if (IsEmpty())  
117.     {  
118.         printf("Empty!/n");  
119.     }  
120.     system("pause");  
121.     return 0;  
122. }  

 

转载：http://blog.csdn.net/baiwujushi/archive/2010/06/04/5648501.aspx