[已解决]新手关于静态链表定义的一些问题

猪猪虾

1.静态链表是怎么定义的，我看了书上的代码 很迷茫，书上定义静态链表的节点的时候，也是用结构体来定义的，一个结构体里面存放节点的值和游标
2.但是如果是类似单链表的形式，用结构体来定义每一个节点，那么访问每一个节点的时候，必然是用结构体指针来访问，而书上的访问形式是数组以及结构体指针混用来访问，例如定义了结构体people,结构体里面游标是cur,访问元素的时候就是people.cur
3.还是说静态链表的定义其实是两个一维数组，一个数组存对应的元素，一个数组存对应的游标

1. //用C++新建一个类，实现静态表的初始化, 获取元素的值，插入，删除操作
   
2. //要求：
   
3. //1.数据类型可以存储字符串
   
4. //2.插入数据，是插入数据后，链表的数据顺序如下：
   
5. //"ZHAO"
   
6. //"QIAN"
   
7. //"SUN"
   
8. //"LI"
   
9. //"ZHOU"
   
10. //"WU"
    
11. //"ZHENG"
    
12. //"WANG"
    
13. 
    
14. #include<winuser.inl>
    
15. #include<stdio.h>
    
16. #include <cstdlib>
    
17. #include<string.h>
    
18. 
    
19. #define MAXSIZE 100;
    
20. 
    
21. struct People
    
22. {
    
23.         char name[20];
    
24.         int cur;
    
25.         struct People* next;
    
26. };
    
27. 
    
28. void InitialList(struct People *head)
    
29. {
    
30.         struct People* people;
    
31.         people = head;
    
32.         int i;
    
33.         for(i = 0; i < MAXSIZE - 1 ; i++)
    
34.         {
    
35.                 people[i].cur = i + 1;
    
36.         }
    
37.         people[MAXSIZE - 1].cur = 0;
    
38. }
    
39. 
    
40. void getInput(struct People* people)
    
41. {
    
42.         printf("enter name:");
    
43.         scanf_s("%s", people->name, 20);
    
44. }
    
45. 
    
46. void printfInfo(struct People* head)
    
47. {
    
48.         struct People* people;
    
49.         people = head;
    
50.         printf("name: %s \n", people->name);
    
51. }
    
52. 
    
53. void tail_add(struct People** head)
    
54. {
    
55.         struct People* people, * temp;
    
56.         people = (struct People*)(malloc(sizeof(struct People)));  //动态申请结构体
    
57. 
    
58.         if (people == NULL)
    
59.         {
    
60.                 printf("memory failed");
    
61.                 exit(1);
    
62.         }
    
63. 
    
64.         getInput(people, 0);
    
65. 
    
66.         //找尾节点
    
67.         if (*head == NULL)
    
68.         {
    
69.                 *head = people;
    
70.                 people->next = NULL;
    
71.         }
    
72.         else
    
73.         {
    
74.                 temp = *head;
    
75.                 while (temp->next != NULL)
    
76.                 {
    
77.                         temp = temp->next;
    
78.                 }
    
79.                 temp->next = people;
    
80.                 people->next = NULL;
    
81.         }
    
82. 
    
83. }
    
84. 
    
85. void find(struct People** head, char find_name[])
    
86. {
    
87.         struct People* people;
    
88.         people = *head;
    
89.         //判断书否为空链表，为空，直接结束
    
90.         if (people == NULL)
    
91.         {
    
92.                 printf("no contact people!!!!\n");
    
93.         }
    
94.         else
    
95.         {
    
96.                 while (people != NULL)
    
97.                 {
    
98.                         if (!strcmp(people->name, find_name))
    
99.                         {
    
100.                                 printfInfo(people);
     
101.                                 break;
     
102.                         }
     
103.                         else
     
104.                         {
     
105.                                 people = people->next;
     
106.                         }
     
107.                 }
     
108.         }
     
109.         //while循环查找是否有符合条件的人或者到达链表的末端，跳出循环，
     
110.         //找到相应的人，打印信息
     
111. }
     
112. 
     
113. void releaseMemory(struct People** head)
     
114. {
     
115.         struct People* people, * temp;
     
116.         people = *head;
     
117.         while (people->next != NULL)
     
118.         {
     
119.                 temp = people;
     
120.                 people = people->next;
     
121.                 free(temp);
     
122.         }
     
123. }
     
124. 
     
125. void chang_info(struct People** head, char find_name[])
     
126. {
     
127.         struct People* people;
     
128.         people = *head;
     
129. 
     
130.         //遍历链表，找到姓名相同的联系人，修改其信息
     
131.         if (people == NULL)
     
132.         {
     
133.                 printf("no contact people!!!!\n");
     
134.         }
     
135.         else
     
136.         {
     
137.                 while (people != NULL)
     
138.                 {
     
139.                         if (!strcmp(people->name, find_name))
     
140.                         {
     
141.                                 getInput(people, 1);
     
142.                                 break;
     
143.                         }
     
144.                         else
     
145.                         {
     
146.                                 people = people->next;
     
147.                         }
     
148.                 }
     
149.         }
     
150. }
     
151. 
     
152. void delete_info(struct People** head, char delete_name[])
     
153. {
     
154.         struct People* previous, * current;
     
155.         //直接给previous赋值null,current赋值头节点，后面就不需要再用中间变量来存储之后，再进行交换地址了
     
156.         //current此时就是一个空的结构体，头指针给他之后，他指向了链表的头节点
     
157.         current = *head;
     
158.         previous = NULL;
     
159. 
     
160.         //找到删除值的位置的前后节点的位置
     
161.         while (current != NULL && !strcmp(current->name, delete_name))
     
162.         {
     
163.                 previous = current;
     
164.                 current = current->next;
     
165.         }
     
166. 
     
167.         //改变链表节点的指向，删除节点
     
168.         if (previous == NULL)  //空链表,直接将头指针指向他
     
169.         {
     
170.                 printf("not found anything\n");
     
171.         }
     
172.         else
     
173.         {
     
174.                 if (previous == NULL)  //链表只有一个节点
     
175.                 {
     
176.                         *head = current->next;
     
177.                 }
     
178.                 else
     
179.                 {
     
180.                         previous->next = current->next;//前面用的是current 来判断有没有找到要删除的节点的位置，所以删除就是currennt的节点指向下一个
     
181.                 }
     
182.                 free(current);
     
183.         }
     
184. 
     
185. }
     
186. 
     
187. void show_all(struct People** head)
     
188. {
     
189.         struct People* people;
     
190.         people = *head;
     
191.         printf("all people in the phonebook is:\n");
     
192.         while (people != NULL)
     
193.         {
     
194.                 printfInfo(people);
     
195.                 people = people->next;
     
196.         }
     
197.         printf("\n");
     
198. 
     
199. }
     
200. 
     
201. int main()
     
202. {
     
203.        
     
204. 
     
205. }

复制代码

最佳答案

月排行榜 / 总排行榜

永恒的蓝色梦想

2021-2-20 19:04:26

猪猪虾 发表于 2021-2-20 16:49
我看书上也说是数组，但是初始化的时候就是结构体。。
按照你说的静态链表就是数组，他有游标和数据两个 ...

你不能用结构体？结构体的数组不就行了

跳转到最佳答案楼层

永恒的蓝色梦想

静态链表不就是一个 array 嘛。。。百度百科上写的挺明确的

猪猪虾

永恒的蓝色梦想 发表于 2021-2-20 13:40
静态链表不就是一个 array 嘛。。。百度百科上写的挺明确的

我看书上也说是数组，但是初始化的时候就是结构体。。
按照你说的静态链表就是数组，他有游标和数据两个部分，用一个数组存这两个东西，两个一维数组吗

永恒的蓝色梦想

猪猪虾 发表于 2021-2-20 16:49
我看书上也说是数组，但是初始化的时候就是结构体。。
按照你说的静态链表就是数组，他有游标和数据两个 ...

你不能用结构体？结构体的数组不就行了

猪猪虾

永恒的蓝色梦想 发表于 2021-2-20 19:04
你不能用结构体？结构体的数组不就行了

傻了，明白了，谢谢