C++基础-链表的建立、插入和删除

 数组作为存放同类数据的集合，给我们在程序设计时带来很多的方便，增加了灵活性。但数组也同样存在一些弊病。如数组的大小在定义时要事先规定，不能在程序中进行调整，这样一来，在程序设计中针对不同问题有时需要3 0个大小的数组，有时需要5 0个数组的大小，
难于统一。我们只能够根据可能的最大需求来定义数组，常常会造成一定存储空间的浪费。
我们希望构造动态的数组，随时可以调整数组的大小，以满足不同问题的需要。链表就是我们需要的动态数组。它是在程序的执行过程中根据需要有数据存储就向系统要求申请存储空间，决不构成对存储区的浪费。
链表是一种复杂的数据结构，其数据之间的相互关系使链表分成三种：单链表、循环链表、双向链表，下面将逐一介绍。
7.4.1 单链表
图7 - 3是单链表的结构。

单链表有一个头节点h e a d，指向链表在内存的首地址。链表中的每一个节点的数据类型为结构体类型，节点有两个成员：整型成员（实际需要保存的数据）和指向下一个结构体类型节点的指针即下一个节点的地址（事实上，此单链表是用于存放整型数据的动态数组）。链表按此结构对各节点的访问需从链表的头找起，后续节点的地址由当前节点给出。无论在表中访问那一个节点，都需要从链表的头开始，顺序向后查找。链表的尾节点由于无后续节点，其指针域为空，写作为N U L L。
图7 - 3还给出这样一层含义，链表中的各节点在内存的存储地址不是连续的，其各节点的地址是在需要时向系统申请分配的，系统根据内存的当前情况，既可以连续分配地址，也可以跳跃式分配地址。
看一下链表节点的数据结构定义：
suct node
{
int num;
suct node *p;
} ;
在链表节点的定义中，除一个整型的成员外，成员p是指向与节点类型完全相同的指针。
在链表节点的数据结构中，非常特殊的一点就是结构体内的指针域的数据类型使用了未定义成功的数据类型。这是在C中唯一规定可以先使用后定义的数据结构。
• 单链表的创建过程有以下几步：
1 ) 定义链表的数据结构。
2 ) 创建一个空表。
3 ) 利用m a l l o c ( )函数向系统申请分配一个节点。
4 ) 将新节点的指针成员赋值为空。若是空表，将新节点连接到表头；若是非空表，将新
节点接到表尾。
5 ) 判断一下是否有后续节点要接入链表，若有转到3 )，否则结束。
• 单链表的输出过程有以下几步
1) 找到表头。
2) 若是非空表，输出节点的值成员，是空表则退出。
3 ) 跟踪链表的增长，即找到下一个节点的地址。
4) 转到2 )。

1. #include "stdio.h"
2. #include "string.h"
3. #include "assert.h"
4. #include "stdlib.h"
5. #include "windows.h"
7. #define COUNT 3
9. //定义一个节点结构体
10. struct NODE
11. {
12.     unsigned long uID;
13.     char strName[16]; //用指针的话会出访问冲突异常
14.     NODE *next;
15. };
17. //创建一个具有n个节点的链表，从键盘输入数据将其初始化，并返回链表的首节点指针
18. NODE *createNode(int n)
19. {
20.     NODE *pHead, //首节点指针 
21.         *pRear, //尾节点指针
22.         *pNew; //新节点指针
23.     int i;
24.     char *strName = new char[16];
25.     for (i=0; i<n; i++)
26.     {
27.         pNew = new NODE;
28.         do
29.         {
30.             printf("请输入ID和名称： ");
31.             scanf("%d %s",&pNew->uID, strName);    
32.             if (strlen(strName) > 16)
33.             {
34.                 printf("输入名称长度超出范围，请重新输入： ");
35.                 Sleep(1000);
36.             }
37.         }while(strlen(strName)>16);
38.         strcpy(pNew->strName, strName);
39.         
40.         if (0==i)
41.         {
42.             pRear = pHead = pNew;
43.         }
44.         else
45.         {
46.             pRear->next = pNew;//未节点的下一个地址等于新地址
47.         }
48.         pNew->next = NULL;
49.         pRear = pNew;
50.     }
51.     delete []strName;
52.     return pHead;
53. }
55. //打印链表中所有节点的数据
56. void printNode(NODE *pHead)
57. {
58.     NODE *pTemp = pHead;
59.     assert(pTemp != NULL);
60.     while(pTemp != NULL)
61.     {
62.         printf("%d %s ",pTemp->uID, pTemp->strName);
63.         pTemp = pTemp->next;
64.     }
65. }
67. //查询链表中具有指定ID的节点，并返回此节点指针
68. NODE *searchNode(NODE *pHead, unsigned long uID)
69. {
70.     NODE *pDest = pHead;
71.     assert(pDest != NULL);
72.     while (pDest->next!=NULL && pDest->uID!=uID)
73.     {
74.         pDest = pDest->next;
75.     }
76.     if (pDest->uID == uID)
77.     {
78.         return pDest;
79.     }
80.     else
81.     {
82.         printf("搜索失败，未找到找定ID的节点！ ");
83.         return NULL;
84.     }
85. }
87. //删除指定ID的节点
88. NODE *deleteNode(NODE *pHead, unsigned long uID)
89. {
90.     NODE *pDest, //要删除的节点
91.         *pBefore; //前一个节点
92.     pDest = pHead;
93.     assert(pDest != NULL);
94.     while (pDest->next!=NULL && pDest->uID!=uID)
95.     {
96.         pBefore = pDest;
97.         pDest = pDest->next;
98.     }
99.     if (pDest->uID == uID)
100.     {
101.         if (pDest == pHead)
102.         {
103.             pHead = pDest->next;
104.         } 
105.         else
106.         {
107.             pBefore->next = pDest->next;
108.         }
109.         free(pDest);
110.         printf("节点已被删除！ ");
111.     } 
112.     else
113.     {
114.         printf("未找到指定节点，无法将其删除！ ");
115.     }
116.     return pHead;
117. }
119. //在指定ID的节点后插入一个新的节点
120. NODE *insertNode(NODE *pHead, unsigned long uID)
121. {
122.     NODE *pDest, *pNew;
123.     pDest = pHead;
124.     assert(pDest != NULL);
125.     while(pDest->next!=NULL && pDest->uID!=uID)
126.     {
127.         pDest = pDest->next;
128.     }
129.     if(pDest->uID == uID)
130.     {
131.         pNew = new NODE;
132.         printf("请输入新节点的ID和名称： ");
133.         scanf("%d %s",&pNew->uID,pNew->strName);
134.         pNew->next = pDest->next;
135.         pDest->next = pNew;
136.         printf("节点插入完成！ ");
137.     }
138.     else
139.     {
140.         printf("未找到指定节点！ ");
141.     }
142.     return pHead;
143. }
145. void main()
146. {
147.     NODE *pHead, *pDest;
148.     int nSelect;
149.     bool isExit = false;
150.     unsigned long uID;
151.     printf("请根据提示输入数据初始化链表： ");
152.     pHead = createNode(COUNT);
153.     assert(pHead != NULL);
154.     printf("链表创建成功！存储数据如下： ");
155.     printNode(pHead);
156.     while (!isExit)
157.     {
158.         printf("-------------------------- ");
159.         printf("请选择要进行的操作： ");
160.         printf("1.打印出链表所有节点数据： ");
161.         printf("2.输入ID查询名称。 ");
162.         printf("3.删除指定ID的节点。 ");
163.         printf("4.在指定ID的节点后插入一个新的节点。 ");
164.         printf("5.退出。 ");
165.         printf("--------------------------- ");
166.         scanf("%d",&nSelect);
167.         switch(nSelect)
168.         {
169.         case 1:
170.             printf("链表所有节点数据如下： ");
171.             printNode(pHead);
172.             break;
173.         case 2:
174.             printf("请输入要查询的节点的ID： ");
175.             scanf("%d",&uID);
176.             pDest = searchNode(pHead, uID);
177.             if (pDest != NULL)
178.             {
179.                 printf("已找到节点，名字为：%s ",pDest->strName);
180.             }
181.             break;
182.         case 3:
183.             printf("请输入要删除的节点的ID： ");
184.             scanf("%d",&uID);
185.             pHead = deleteNode(pHead, uID);
186.             break;
187.         case 4:
188.             printf("请输入要删除的节点的ID： ");
189.             scanf("%d",&uID);
190.             pHead = insertNode(pHead, uID);
191.             break;
192.         case 5:
193.             isExit = true;
194.             printf("程序已退出！ ");
195.             break;
196.         default:
197.             printf("按键错误，请重新选择！ ");
198.             break;
199.         }
200.     }
201. }

自己写的简单单链表程序。包含 创建 插入 查询 删除 显示功能

 

1. # include <iostream.h>
2. # include "stdio.h"
3. # include "string.h"
4. /********定义一个链表结构*****/
6. struct link
7. {
8.     int BikeNum;
9.     link *Next;
10. };
12. link* Create();//创建一个新节点
13. link* Search(int SeaID,link*);
14. link* insert(int i,int date,link*);
15. link* Delnode(int DelID,link*);
16. void Output(link *p);
18. void main()
19. {
20.    link* Lhead;
21.    Lhead=Create();
22.    Output(Lhead);
23.    bool quit=false;
24.    int sel=0;
25.    while(!quit)
26.    {
27.        cout<<"1 插入数据；2 删除数据；3 查询数据；4 显示数据；5 退出；"<<endl;
28.        cin>>sel;
29.        int row=0,date=0;
30.        link* sch=NULL;
31.        switch(sel)
32.        {
33.        case 1://插入
34.            {
35.                cout<<"输入要插入的位置"<<endl;
36.                cin>>row;
37.                cout<<"输入要插入的数据"<<endl;
38.                cin>>date;
39.                Lhead=insert(row,date,Lhead);
40.            }
41.            break;
42.        case 2://删除
43.            cout<<"输入要删除的号码"<<endl;
44.            cin>>date;
45.            Lhead=Delnode(date,Lhead);
46.                break;
47.        case 3://查询
48.            cout<<"输入要查询的数字"<<endl;
49.             cin>>date;
50.             sch=Search(date,Lhead);
51.             if(NULL==sch)
52.             {
53.                 cout<<"没有相关的数据"<<endl;
54.             }
55.             else
56.             {
57.                 cout<<"查找的结果是："<<sch->BikeNum<<endl;
58.             }
59.             delete sch;
60.            break;
61.        case 4://显示
62.            Output(Lhead);
63.            break;
64.        case 5://quit
65.            quit=true;
66.            break;
67.        default:
68.            break;
69.        }
70.    }
71. }
73. link* Create()
74. {
75.     link *pHead=NULL, //首节点指针 
76.         *pRear=NULL, //尾节点指针
77.         *pNew=NULL; //新节点指针
78.     int b=0;
79.     cout<<"创建链表，填入数据"<<endl;
80.     for(int a=0;a<3;a++)
81.     {
82.         pNew= new link;
83.         cin>>b;
84.         pNew->BikeNum=b;
85.         if(0==a)
86.         {
87.             pHead=pRear=pNew;//头指针
88.         }
89.         else
90.         {
91.            pRear->Next=pNew;//NEXT等于当前的地址
92.            pNew->Next=NULL;//当前指针的下一个默认是空的。
93.         }
94.         pRear=pNew;//尾节点等于当前地址
95.     }
96.     cout<<"填写完成"<<endl;
97.     return pHead;
98. }
99. void Output(link *p)
100. {
101.    cout<<"显示链表中的数据"<<endl;
102.    link* node;
103.    if(p!=NULL)
104.    {
105.        node=p;
106.        do
107.        {
108.            cout<<node->BikeNum<<endl;
109.            node=node->Next;
110.        }while(node!=NULL);
111.    }
112.    else
113.    {
114.        cout<<"链表中没有数据"<<endl;
115.    }
116. }
117. link* insert(int i,int date,link* p)
118. {
119.     link* head=p;
120.     link* insert;
121.     int count=0;
122.     if(p==NULL)//当没有数据时。插入头链表
123.     {
124.         insert=new link;
125.         insert->BikeNum=date;
126.         insert->Next=NULL;//连接后面的
127.         head=insert;
128.         return head;
129.     }
130.     else
131.     {
132.         for(int a=0;a<i-1;a++)
133.         {
134.             p=p->Next;
135.         }
136.         if(0==i)
137.         {
138.            insert=new link;
139.            insert->BikeNum=date;
140.            insert->Next=p;
141.            head=insert;
142.            return head;
143.         }
144.         else
145.         {
146.             insert=new link;
147.             insert->BikeNum=date;
148.             insert->Next=p->Next;
149.             p->Next=insert;
150.             return head;
151.         }
152.     }
153.     return head;
154. }
155. link* Delnode(int DelID,link* p)
156. {
157.     link* del;
158.     link* head=p;
159.     while(p!=NULL)
160.     {
161.         if(DelID==p->BikeNum)
162.         {
163.             if(head==p)
164.             {
165.                 head=p->Next;
166.                 delete p;//从堆中删除内存
167.                 return head;
168.             }
169.             else
170.             {
171.                 del->Next=p->Next;
172.                 delete p;//从堆中删除内存
173.                 return head;
174.             }
175.         }
176.         del=p;
177.         p=p->Next;
178.     }
179.     cout<<"删除失败，没有找到节点"<<endl;
180.     return head;
181. }
182. link* Search(int date,link* p)
183. {
184.     link* re=NULL;
185.     while(p!=NULL)
186.     {
187.       if(p->BikeNum==date)
188.       {
189.          re=p;
190.          return re;
191.       }
192.       p=p->Next;
193.     }
194.     return re;
195. }

在链表的创建过程中，链表的头指针是非常重要的参数。因为对链表的输出和查找都要从链表的头开始，所以链表创建成