复习 [数据结构] ---- 线性表

1. /*-------------------------------------
2.     顺序表插入删除
3. -------------------------------------*/
4. #include <stdio.h>
5. #define MaxLen 50
6. typedef char ElemType;
8. typedef struct
9. {
10.     ElemType data[MaxLen];
11.     int Len;
12. }Sqlist;
14. void setnull(Sqlist &L)     //置空表
15.     {   L.Len=0;    }
17. int length(Sqlist L)    //求长度
18.     {   return L.Len;   }
20. ElemType get(Sqlist L,int i)    //取表中第i个元素
21. {   
22.     if( i < 0 || i > L.Len-1 )
23.         printf("位置参数不正确/n");
24.     else
25.         return (L.data[i]);
26. }
28. int Locate(Sqlist L,ElemType x) //查找表中x元素
29. {
30.     int i=0;
31.     while( i < L.Len && L.data[i] != x)
32.         i++;
33.     if( i == L.Len)
34.         return -1;
35.     else
36.         return i;
37. }
39. int insnode(Sqlist &L,ElemType x,int i) //插入元素
40. {
41.     int j;
42.     if( i<0 || i>L.Len)
43.         return 0;
44.     else
45.     {
46.         L.Len++;
47.         for( j=L.Len-1 ; j>i ; j--)
48.             L.data[j]=L.data[j-1];
49.         L.data[j]=x;
50.         return 1;
51.     }
52. }
54. int delnode(Sqlist &L,int i)    //删除元素
55. {
56.     int j;
57.     if( i<0 || i>L.Len-1)
58.         return 0;
59.     else
60.     {
61.         for( j=i ; j<L.Len-1 ; j++)
62.             L.data[j]=L.data[j+1];
63.         L.Len--;
64.         return 1;
65.     }
66. }
68. void display(Sqlist L)
69. {
70.     int j;
71.     printf("顺序表:");
72.     if(L.Len==0)
73.         printf("空表/n");
74.     else
75.     {
76.         if(L.Len==1)
77.             printf("%c",L.data[0]);
78.         else
79.         {
80.             for(j=0;j<L.Len-1;j++)
81.                 printf("%c-> ",L.data[j]);
82.             printf("%c",L.data[j]);
83.         }
84.         printf("/n");
85.     }
86. }
88. void main()
89. {
90.     Sqlist S;
91.     setnull(S);         //初始化存入 ABCD
92.     insnode(S,'A',0);
93.     insnode(S,'B',1);
94.     insnode(S,'C',2);
95.     insnode(S,'D',3);
97.     printf("查找元素位置:%d/n",Locate(S,'D'));
98.     printf("取表中地3个元素:%c/n",get(S,3));
99.     display(S);
101.     insnode(S,'E',0);   //插入元素
102.     display(S);
104.     delnode(S,0);       //删除元素
105.     display(S);
106. }

 

 

 

1. /*-------------------------------------
2.     链式表插入删除
3. -------------------------------------*/
4. #include <stdio.h>
5. #include <stdlib.h>
6. #define ElemType char
8. typedef struct node //定义单链表节点类型
9. {
10.     ElemType data;      //数据域
11.     struct node *next;  //指针域
12. }SNode;
14. void CreateListF(SNode *&L,ElemType a[],int n)  //头插法建表
15. {
16.     SNode *s;int i;
17.     L=(SNode *)malloc(sizeof(SNode));       //创建头节点
18.     L->next=NULL;
19.     for( i=0 ; i<n ; i++)
20.     {
21.         s=(SNode *)malloc(sizeof(SNode));   //创建新节点
22.         s->data=a[i];
23.         s->next=L->next;    //接链
24.         L->next=s;
25.     }
26. }
28. void CreateListR(SNode *&L,ElemType a[],int n)  //尾插法建表
29. {
30.     SNode *s,*r;int i;
31.     L=(SNode *)malloc(sizeof(SNode));       //创建头节点
32.     L->next=NULL;
33.     r=L;                                    //r L同时指向头节点
34.     for( i=0 ; i<n ; i++)
35.     {
36.         s=(SNode *)malloc(sizeof(SNode));   //创建新节点
37.         s->data=a[i];
38.         r->next=s;
39.         r=s;
40.     }
41.     r->next=NULL;
42. }
44. void setnull(SNode *&p)                 //置空表
45. {
46.     p=(SNode *)malloc(sizeof(SNode));   //创建节点
47.     p->next=NULL;
48. }
50. int length(SNode *p)                    //求链表长度
51. {
52.     int n=0;
53.     SNode *q=p->next;
54.     while(q!=NULL)
55.     {
56.         n++;
57.         q=q->next;  
58.     }
59.     return n;
60. }
62. SNode *get(SNode *p,int i)
63. {
64.     int j=0;
65.     SNode *q=p->next;
66.     while( j<i && q!=NULL)
67.     {
68.         q=q->next;
69.         j++;
70.     }
71.     if(q!=NULL)
72.         return q;
73.     else
74.     {
75.         printf("位置参数i不正确/n");
76.         return NULL;
77.     }
78. }
80. int locate(SNode *p,ElemType x)     //查找数据域为X的节点的位置
81. {
82.     int i=0;
83.     SNode *q=p->next;
84.     while(q!=NULL && q->data!=x)
85.     {
86.         q=q->next;
87.         i++;
88.     }
89.     if(q==NULL)
90.         return -1;
91.     else
92.         return i;
93. }
95. int insnode(SNode *p,ElemType x,int i)
96. {
97.     SNode *s,*q;
98.     s=(SNode *)malloc(sizeof(SNode));   //建立要插入的节点S
99.     s->data=x;
100.     if(i==0)                            //*s作为首元素的节点
101.     {
102.         s->next=p->next;                //将*s插入到*p之后
103.         p->next=s;
104.     }
105.     else
106.     {
107.         q=get(p,i-1);                   //查找第i-1个节点*q
108.         if(q==NULL)                     //位置参数不正确
109.             return 0;                   //返回出错信息
110.         else
111.         {
112.             s->next=q->next;            //将*s插入到*q之后
113.             q->next=s;                  //断链
114.         }
115.     }
116.     return 1;                           //返回成功信息
117. }
119. int delnode(SNode *p,int i)
120. {
121.     SNode *q,*t;
122.     if(i==0)                            //*s作为首元素的节点
123.     {
124.         t=p->next;
125.         p->next=t->next;
126.         free(t);
127.     }
128.     else
129.     {
130.         q=get(p,i-1);                   //查找第i-1个节点*q
131.         if(q==NULL)                     //位置参数不正确
132.             return 0;                   //返回出错信息
133.         else
134.         {
135.             t=q->next;                  //t指向*q之后的节点既被删节点
136.             q->next=t->next;            //从链表中删除*t
137.             free(t);                    //释放t所指内存空间
138.         }
139.     }
140.     return 1;                           //返回成功信息
141. }
143. void display(SNode *p)      //显示链表内容
144. {
145.     int n=length(p),i;      //n为链表长度
146.     SNode *q=p->next;       //q指向首节点
147.     printf("单链表显示:");
148.     if(n==0)
149.         printf("空表");
150.     else if(n==1)           //只有一个元素
151.             printf("%c",q->data);
152.         else
153.         {
154.             for(i=1;i<n;i++)
155.             {
156.                 printf("%c-> ",q->data);
157.                 q=q->next;
158.             }
159.             printf("%c",q->data);
160.         }
161.     printf("/n");
162. }
164. void main()
165. {
166.     char array[4]={'A','B','C','D'};
168.     SNode *S;
169.     CreateListF(S,array,4);                 //建立链表
170.     printf("链表长度为:%d/n",length(S)); //显示链表长度
172.     display(S);
174.     insnode(S,'E',0);       //插入操作
175.     display(S);
177.     delnode(S,0);           //删除操作
178.     display(S);
179. }

 

 

1. /*-------------------------------------
2.     双链表插入删除
3. -------------------------------------*/
4. #include <stdio.h>
5. #include <stdlib.h>
6. #define ElemType char
8. typedef struct node
9. {
10.     ElemType data;      //数据域
11.     struct node *prior; //指向前驱节点的指针
12.     struct node *next;  //指向直接后续节点的指针
13. }DNode;
15. void setnull(DNode *&p)                 //p为引用型指针
16. {
17.     p=(DNode *)malloc(sizeof(DNode));   //创建节点
18.     p->next=p->prior=NULL;
19. }
21. int length(DNode *p)    //计算双链表长度
22. {
23.     int n=0;
24.     DNode *q=p->next;
25.     while(q!=NULL)
26.     {
27.         n++;
28.         q=q->next;
29.     }
30.     return n;
31. }
33. DNode *get(DNode *p,int i)//取双链表第i个节点的地址
34. {
35.     int j=0;
36.     DNode *q=p->next;
37.     while( j<i && q!=NULL)
38.     {
39.         q=q->next;
40.         j++;
41.     }
42.     if(q!=NULL)
43.         return q;
44.     else
45.     {
46.         printf("位置参数i不正确/n");
47.         return NULL;
48.     }
49. }
51. int locate (DNode *p,ElemType x)//按值查找
52. {
53.     int i=0;
54.     DNode *q=p->next;
55.     while( q!=NULL && q->data!=x)   //查找data域为x的第一个节点
56.     {
57.         q=q->next;
58.         i++;
59.     }
60.     if(q==NULL)                     //未找到
61.         return -1;
62.     else
63.         return i;                   //找到
64. }
66. int insnode(DNode *p,ElemType x,int i)  //在第i个位置插入新的元素
67. {
68.     DNode *s,*q;
69.     s=(DNode *)malloc(sizeof(DNode));   //建立要插入的节点S
70.     s->data=x;
71.     if(i==0)                            //*s作为首元素的节点
72.     {
73.         s->next=p->next;                //将*s插入到*p之后
74.         if(p->next!=NULL)
75.             p->next->prior=s;
76.         s->prior=p;
77.         p->next=s;
78.     }
79.     else
80.     {
81.         q=get(p,i-1);                   //查找第i-1个节点*q
82.         if(q==NULL)                     //位置参数不正确
83.             return 0;                   //返回出错信息
84.         else
85.         {
86.             s->next=q->next;            //将*s插入到*q之后
87.             if(q->next!=NULL)
88.                 q->next->prior=s;
89.             s->prior=q;
90.             q->next=s;                  //断链
91.         }
92.     }
93.     return 1;                           //返回成功信息
94. }
96. int delnode(DNode *p,int i)             //删除节点
97. {
98.     DNode *q,*s;
99.     if(i==0)                            //删除首元素的节点
100.     {
101.         s=p->next;
102.         p->next=s->next;
103.         if(s->next!=NULL)
104.             s->next->prior=p;
105.         free(s);
106.     }
107.     else
108.     {
109.         q=get(p,i-1);                   //查找第i-1个节点*q
110.         if(q==NULL)                     //位置参数不正确
111.             return 0;                   //返回出错信息
112.         else
113.         {
114.             s=q->next;                  //s指向*q之后的节点既被删节点
115.             q->next=s->next;            //从链表中删除*s
116.             if(s->next!=NULL)
117.                 s->next->prior=q;
118.             free(s);                    //释放s所指内存空间
119.         }
120.     }
121.     return 1;                           //返回成功信息
122. }
124. void display(DNode *p)      //显示链表内容
125. {
126.     int n=length(p),i;
127.     DNode *q=p->next;
128.     printf("双链表显示:");
129.     if(n==0)
130.         printf("空表");
131.     else if(n==1)           //只有一个元素
132.             printf("%c",q->data);
133.         else
134.         {
135.             for(i=1;i<n;i++)
136.             {
137.                 printf("%c-> ",q->data);
138.                 q=q->next;
139.             }
140.             printf("%c",q->data);
141.         }
142.     printf("/n");
143. }
145. void main()
146. {
147.     DNode *L;
148.     setnull(L);
149.     insnode(L,'A',0);
150.     insnode(L,'B',1);
151.     insnode(L,'C',2);
152.     insnode(L,'D',3);
154.     display(L);
156.     delnode(L,3);
158.     display(L);
159. }