线性表
经历过了测试，如有不妥的地方，望请雅正！！！
Matrix.h
1 /*单链表：
2 *基本操作：头结点创建以及尾节点创建
3 * 查找节点的值以及位置
4 * 插入节点以及删除节点
5 * 销毁节点以及显示链表的值
6 */
7 typedef struct LNode
8 {
9 int data;
10 struct LNode *next;
11 }LinkList;
12
13 void CreateListF(LinkList *L,int a[],int n);
14 void CreateListR(LinkList *L,int a[],int n);
15 int FindNode(LinkList L,int i,int &e);
16 int LocateElem(LinkList L,int &e);
17 void InsertNode(LinkList &L,int i,int e);
18 void DeleteNode(LinkList &L,int i,int &e);
19 void DisplayList(LinkList L);
20 void DestroyList(LinkList &L);
21
22
23 /*双链表：
24 *基本操作：头结点创建以及尾节点创建
25 * 查找节点的值以及位置
26 * 插入节点以及删除节点
27 * 销毁节点以及显示链表的值
28 */
29 typedef struct DNode
30 {
31 int data;
32 struct DNode *prev;
33 struct DNode *next;
34 }DLinkList;
35
36 void CreateDListF(DLinkList *L,int a[],int n);
37 void CreateDListR(DLinkList *L,int a[],int n);
38 //int FindDNode(DLinkList L,int i,int &e);
39 //int LocateDElem(DLinkList L,int &e);
40 void InsertDNode(DLinkList &L,int i,int e);
41 void DeleteDNode(DLinkList &L,int i,int &e);
42 void DisplayDList(DLinkList L);
43 void DestroyDList(DLinkList &L);
44
45 /*
46 *顺序表：随即存取特性；物理位置连续，逻辑相邻。
47 */
48 #define MaxSize 100
49 typedef struct List
50 {
51 int data[MaxSize];
52 int length;
53 }SqlList;
Matrix.cpp
1 #include <iostream>
2 #include "Matrix.h"
3 using namespace std;
4
5
6 /*
7 *单链表部分
8 */
9 void CreateListF(LinkList *L,int a[],int n)
10 {
11 LinkList *s;
12 for(int i=0;i<n;i++)
13 {
14 s=(LinkList*)malloc(sizeof(LinkList));
15 s->data=a[i];
16 s->next=L->next;
17 L->next=s;
18 }
19 }
20
21 void CreateListR(LinkList *L,int a[],int n)
22 {
23 LinkList *s,*r=L;
24 for(int i=0;i<n;i++)
25 {
26 s=(LinkList*)malloc(sizeof(LinkList));
27 s->data=a[i];
28 r->next=s;
29 r=s;
30 }
31 }
32 int FindNode(LinkList L,int i,int &e)
33 {
34 LinkList *p=&L;
35 int j=0;
36 while(p&&j<i)
37 {
38 p=p->next;
39 j++;
40 }
41 if(p==NULL)
42 {
43 cout<<"NO ELEMENT!!!"<<endl;
44 return 0;
45 }
46 else if(j>i)
47 {
48 cout<<"WRONG POSITION!!!"<<endl;
49 return 0;
50 }
51 else
52 {
53 e=p->data;
54 return 1;
55 }
56 }
57
58 int LocateElem(LinkList L,int &e)
59 {
60 LinkList *p=&L;
61 int j=0;
62 while(p->data!=e)
63 {
64 p=p->next;
65 j++;
66 }
67 if(p==NULL)
68 {
69 cout<<"NO ELEMENT!!!"<<endl;
70 return 0;
71 }
72 else
73 {
74 return j;
75 }
76 }
77 void InsertNode(LinkList &L,int i,int e)
78 {
79 LinkList *p=&L;
80 int j=0;
81 while(j<i-1&&p)
82 {
83 p=p->next;
84 j++;
85 }
86 if(p==NULL)
87 {
88 cout<<"NO ELEMENT!!!"<<endl;
89 }
90 else if(j>i)
91 {
92 cout<<"WRONG POSITION!!!"<<endl;
93 }
94 else
95 {
96 LinkList *s=(LinkList*)malloc(sizeof(LinkList));
97 s->data=e;
98 s->next=p->next;
99 p->next=s;
100 }
101 }
102 void DeleteNode(LinkList &L,int i,int &e)
103 {
104 LinkList* p=&L;
105 int j=0;
106 while(p&&j<i)
107 {
108 p=p->next;
109 j++;
110 }
111 if(p==NULL)
112 {
113 cout<<"NO ELEMENT!!!"<<endl;
114 }
115 else if(j>i)
116 {
117 cout<<"WRONG POSITION!!!"<<endl;
118 }
119 else
120 {
121 e=p->next->data;
122 p->next=p->next->next;
123 }
124 }
125
126 void DisplayList(LinkList L)
127 {
128 LinkList *p=L.next;
129 while(p)
130 {
131 cout<<p->data<<"";
132 p=p->next;
133 }
134 p=NULL;
135 cout<<endl;
136 }
137
138 void DestroyList(LinkList &L)
139 {
140 LinkList *p=&L;
141 LinkList *s;
142 while(p)
143 {
144 s=p->next;
145 p->next=NULL;
146 p=s;
147 }
148 }
149
150
151
152 /*
153 *双链表部分
154 */
155
156 void CreateDListF(DLinkList *L,int a[],int n)
157 {
158 DLinkList *s;
159 for(int i=0;i<n;i++)
160 {
161 s=(DLinkList*)malloc(sizeof(DLinkList));
162 s->data=a[i];
163 s->next=L->next;
164 s->prev=L;
165 L->next=s;
166 }
167 }
168
169 //尾节点插入构建单链表：？？？出现野指针计算错误！！！
170 void CreateDListR(DLinkList *L,int a[],int n)
171 {
172 DLinkList *s,*r=L;
173 for(int i=0;i<n;i++)
174 {
175 s=(DLinkList*)malloc(sizeof(DLinkList));
176 s->data=a[i];
177 r->next=s;
178 s->prev=r;
179 r=s;
180 }
181 }
182
183
184 //int FindDNode(DLinkList L,int i,int &e);
185 //int LocateDElem(DLinkList L,int &e);
186 void InsertDNode(DLinkList &L,int i,int e)
187 {
188 DLinkList *p=&L;
189 int j=0;
190 while(j<i-1&&p)
191 {
192 p=p->next;
193 j++;
194 }
195 if(p==NULL)
196 {
197 cout<<"NO ELEMENT!!!"<<endl;
198 }
199 else if(j>i)
200 {
201 cout<<"WRONG POSITION!!!"<<endl;
202 }
203 else
204 {
205 DLinkList *s=(DLinkList*)malloc(sizeof(DLinkList));
206 s->data=e;
207 s->next=p->next;
208 p->next->prev=s;
209 p->next=s;
210 s->prev=p;
211 }
212 }
213 void DeleteDNode(DLinkList &L,int i,int &e)
214 {
215 DLinkList* p=&L;
216 int j=0;
217 while(p&&j<i)
218 {
219 p=p->next;
220 j++;
221 }
222 if(p==NULL)
223 {
224 cout<<"NO ELEMENT!!!"<<endl;
225 }
226 else if(j>i)
227 {
228 cout<<"WRONG POSITION!!!"<<endl;
229 }
230 else
231 {
232 e=p->next->data;
233 p->next=p->next->next;
234 p->next->prev=p;
235 }
236 }
237 void DisplayDList(DLinkList L)
238 {
239 DLinkList *p=L.next;
240 while(p)
241 {
242 cout<<p->data<<"";
243 p=p->next;
244 }
245 p=NULL;
246 cout<<endl;
247 }
248 void DestroyDList(DLinkList &L)
249 {
250 DLinkList *p=&L;
251 DLinkList *s;
252 while(p)
253 {
254 s=p->next;
255 p->next=NULL;
256 p->prev=NULL;
257 p=s;
258 }
259 }
Index.cpp:
1 #include <iostream>
2 #include "Matrix.h"
3 using namespace std;
4
5 int main()
6 {
7
8 /*
9 *单链表:链表之间的关系使用next指向来指明。
10 */
11 //头节点插入构建单链表
12 int c[10]={20,19,18,13,16,12,17,11,15,14};
13 LinkList *F=(LinkList*)malloc(sizeof(LinkList));
14 F->next=NULL;
15 CreateListF(F,c,10);
16 DisplayList(*F);
17
18 //尾节点插入构建单链表：？？？出现野指针计算错误！！！
19 //int d[10]={10,20,30,40,50,60,70,80,90,100};
20 //LinkList *R=(LinkList*)malloc(sizeof(LinkList));
21 //R->next=NULL;
22 //CreateListR(R,d,10);
23 //DisplayList(*R);
24 //R=NULL;
25
26 //查找链表第五个位置的值
27 int e=0;
28 FindNode(*F,5,e);
29 cout<<"c[5]="<<e<<endl;
30
31 //查找等于17的链表的位置
32 int f=17;
33 int p=LocateElem(*F,f);
34 cout<<"The Location of 17 is "<<p<<endl;
35
36 //插入21到第五个位置的前面
37 int g=21;
38 InsertNode(*F,5,g);
39 DisplayList(*F);
40
41 //删除位置7的链表
42 int h=7,k=0;
43 DeleteNode(*F,h,k);
44 DisplayList(*F);
45
46 //销毁链表
47 DestroyList(*F);
48 DisplayList(*F);
49
50
51 /*
52 *双链表：尾节点next指向NULL，头节点prev指向也为NULL；每个节点均有两个指针。
53 */
54 //头节点创建双链表
55 int dl[10]={20,19,18,13,16,12,17,11,15,14};
56 DLinkList *D=(DLinkList*)malloc(sizeof(DLinkList));
57 D->next=NULL;
58 D->prev=NULL;
59 CreateDListF(D,dl,10);
60 DisplayDList(*D);
61
62 //在值为12前插入节点21
63 int dli=32;
64 InsertDNode(*D,5,dli);
65 DisplayDList(*D);
66
67 //删除值为16节点
68 int dlj=0;
69 DeleteDNode(*D,6,dlj);
70 DisplayDList(*D);
71
72 //查找节点的值以及节点的位置与单链表雷同，此处略去！！！
73
74
75 //销毁双链表
76 DestroyDList(*D);
77 DisplayDList(*D);
78
79 /*
80 *循环链表:尾节点next指向头节点,头节点prev指向尾节点(循环双链表)
81 * 主要有两种：循环单链表：与单链表雷同
82 * 循环双链表：与双链表雷同
83 * 实现比较简单，这里略去！！！
84 */
85 //头、尾节点创建循环链表与双链表雷同
86
87 //判断是否是尾节点的条件是：p->next=CL;
88 //插入节点与删除节点分两种情况（单链表与双链表）考虑。
89
90
91 /*
92 *这里特别提出一种逻辑结构：有序表(并不是顺序表，顺序表是利用物理位置连续表示元素之间逻辑关系的线性表)
93 * 有序表是一种元素有序，元素时必须考虑他们之间的有序关系，
94 *不能再像一般的线性表那样0~n+1随便插入。
95 */
96
97
98 return 0;
99 }
结果示下：
