数据结构的概念、堆栈

数据结构与算法

数据结构研究步伐里怎样使用存储区存放数字，算法研究解决一些常见问题的通用方法。数字之间的关系可以从两个完全差别的角度描述。
逻辑关系（逻辑结构）描述数字之间与计算机无关的关系；物理关系（物理结构）描述存放数字的存储区之间的关系。
逻辑结构

1.集合结构：所有的数字可以被看做一个整体
2.线性结构：如果可以用一条有顺序的线把所有数字串起来则数字之间是线性结构的
3.树状结构：所有数据都是从一个数据向同一个方向扩展出来的，任何数字可以拓展出多个其他数字
4.网状结构：任何两个数字之间都可以有直接的联系，所有数字之间的联系没有同一的方向
物理结构

1.顺序结构：所有存储区在内存里连续排列，数组和动态分配内存都是顺序结构的例子，顺序结构里每个存储区都有一个编号，可以直接通过编号找到对应的存储区。顺序结构可以不通过其他存储区直接找到需要的存储区，这种能力叫随机访问能力。顺序结构里的存储区个数很难调整，轻易造成内存浪费。
2.链式结构：由多个相互独立的存储区构成，任何两个存储区之间可以用指针连接，链式物理结构里每个存储区都是一个结构体类型的存储区，他们叫做节点，单向线性链式物理结构中任何两个节点之间都有前后顺序（每个节点里只需要包罗一个指针）。单向线性链式物理结构里最后一个节点里的指针必须是空指针。可以在单向线性链式物理机构中最前面的节点前再增加一个节点，这个节点叫头节点。可以在单向线性链式物理结构中最后面的节点后再增加一个节点，这个节点叫尾节点。
链式物理结构不支持随机访问能力，链式物理结构适合进行插入或删除操作,链式物理结构里的节点个数可以随时调整，

1. /*
2. *
3. *链式物理结构固定代码
4. *
5. * */
6. #include<stdio.h>
7. typedef struct node {
8.         int num;
9.         struct node *p_next;
10. } node;
11. int main (){
12.     node node1 = {10}, node2 = {20}, node3 = {30},head = {0}, tail = {0};
13.         node *p_node = NULL;
14.         head.p_next = &node1;
15.         node1.p_next = &node2;
16.         node2.p_next = &node3;
17.         node3.p_next = &tail;
18.         /*
19.          *p_node指针循环变量会从头节点开始
20.          *向后依次捆绑每个节点，直到最后一个有效节点为止
21.          * */
22.         for (p_node = &head;p_node != &tail;p_node = p_node->p_next){
23.                 /*
24.                  *以下三个指针和三个相邻节点捆绑
25.                  * 其中p_first指针捆绑的节点在最前面
26.                  *p_last指针捆绑的节点在最后
27.                  *p_mid指针捆绑的节点在中间
28.                  *p_mid指针在循环过程中从第一个有效节点一直捆绑到尾节点
29.                  * */
30.                 node *p_first = p_node;
31.                 node *p_mid = p_first->p_next;
32.                 node *p_last = p_mid->p_next;
33.                 if (p_mid != &tail){
34.                         printf("%d ",p_mid->num);
35.                 }
36.         }
37.         printf("\n");
38.         return 0;
39. }

复制代码

插入删除操作

1. /*
2. *
3. *链式结构
4. *
5. * */
6. #include<stdio.h>
7. typedef struct node {
8.         int num;
9.         struct node *p_next;
10. } node;
11. int main (){
12.     node node1 = {10}, node2 = {20}, node3 = {30},head = {0}, tail = {0};
13.         node node4 = {15};
14.         node *p_node = NULL;
15.         head.p_next = &node1;
16.         node1.p_next = &node2;
17.         node2.p_next = &node3;
18.         node3.p_next = &tail;
19.         /*
20.          *p_node指针循环变量会从头节点开始
21.          *向后依次捆绑每个节点，直到最后一个有效节点为止
22.          *
23.          * */
24.         for (p_node = &head;p_node != &tail;p_node = p_node->p_next){
25.                 /*
26.                  *以下三个指针和三个相邻节点捆绑
27.                  * 其中p_first指针捆绑的节点在最前面
28.                  *p_last指针捆绑的节点在最后
29.                  *p_mid指针捆绑的节点在中间
30.                  *p_mid指针在循环过程中从第一个有效节点一直捆绑到尾节点
31.                  *
32.                  * */
33.                 node *p_first = p_node;
34.                 node *p_mid = p_first->p_next;
35.                 node *p_last = p_mid->p_next;
36.                 if (p_mid != &tail){
37.                         printf("%d ",p_mid->num);
38.                 }
39.         }
40.         printf("\n");
41.         /*
42.          *在链式结构里
43.          *删除数据
44.          * */
45.         for (p_node = &head;p_node != &tail;p_node = p_node->p_next){
46.                 node *p_first = p_node;
47.                 node *p_mid = p_first->p_next;
48.                 node *p_last = p_mid->p_next;
49.                 if (p_mid != &tail && p_mid->num == 20){
50.                         p_first->p_next = p_last;
51.                         break;
52.                 }
53.         }
54.         /*
55.          *链式结构插入数据
56.          *并保证排序从小到大
57.          * */
58.         for (p_node = &head;p_node != &tail;p_node = p_node->p_next){
59.                 node *p_first = p_node;
60.                 node *p_mid = p_first->p_next;
61.                 node *p_last = p_mid->p_next;
62.                 if (p_mid == &tail || p_mid->num > node4.num){
63.                         p_first->p_next = &node4;
64.                         node4.p_next = p_mid;
65.                         break;
66.                 }
67.         }
68.         for (p_node = &head;p_node != &tail;p_node = p_node->p_next){
69.                 node *p_first = p_node;
70.                 node *p_mid = p_first->p_next;
71.                 node *p_last = p_mid->p_next;
72.                 if (p_mid != &tail){
73.                         printf("%d ",p_mid->num);
74.                 }
75.         }
76.         printf("\n");
77.         return 0;
78. }

复制代码

数据结构

数据结构由一组存储区和相干的管理函数构成，这些函数提供了对存储区的使用方法，步伐里的其他语句都只能通过这些函数使用这些存储区。
栈

栈是一种数据结构，栈可以用来存放数字，栈里的数字有前后顺序，先进入栈的数字在前，后进入栈的数字在后，每次只能从栈里获得一个数字，这个数字必须是最后一个放进去的数字，这种使用数字的方法叫后进先出。
push和pop

编写栈的时候需要提供一个函数用来向栈里加入数字，这个函数名称通常叫push，编写栈的时候需要提供一个函数用来从栈里获得数字，这个函数名称通常叫pop。
栈练习：编写步伐从键盘得到多个非负整数，把他们倒序显示在屏幕上，要求用栈实现。

1. /*
2. *栈演示主函数
3. * */
4. #include<stdio.h>
5. #include"1stack.h"
6. int main (){
7.         int num = 0;
8.         stack stk = {0};
9.         stack_init(&stk);
10.         while (1){
11.                 printf("请输入一个数字:");
12.                 scanf("%d",&num);
13.                 if (num < 0){
14.                         break;
15.                 }
16.                 if (!stack_push(&stk,num)){
17.                         break;
18.                 }
19.         }
20.         while (1){
21.                 if (!stack_pop(&stk,&num)){
22.                         break;
23.                 }
24.                 printf("%d ",num);
25.         }
26.         printf("\n");
27.         stack_deinit(&stk);
28.         return 0;
29. }

复制代码

1. /*
2. *栈演示头文件
3. * */
4. #ifndef         _1STACK_H_
5. #define         _1STACK_H_
6. typedef struct {
7.         int buf[SIZE];
8.         int qty;
9. } stack;
10. //栈初始化函数
11. void stack_init (stack *);
12. //栈清理函数
13. void stack_deinit (stack *);
14. //统计栈里有效数字个数
15. int stack_size (const stack *);
16. //判断栈是否已经满了
17. int stack_full (const stack *);
18. //判断栈是否为空
19. int stack_empty (const stack *);
20. //向栈里加入数字的函数
21. int stack_push (stack *,int);
22. //从栈里获得数字的函数(从栈里删除数字)
23. int stack_pop (stack *,int *);
24. //从栈里获得数字的函数（不会删除数字）
25. int stack_top (const stack *,int *);
26. #endif                         //_1STACK_H_

复制代码

1. /*
2. *栈演示源文件
3. * */
4. #include"1stack.h"
5. //栈初始化函数
6. void stack_init (stack *p_stack){
7.         p_stack->qty = 0;
8. }
9. //栈清理函数
10. void stack_deinit (stack *p_stack){
11.         p_stack->qty = 0;
12. }
13. //统计栈里有效数字个数
14. int stack_size (const stack *p_stack){
15.         return p_stack->qty;
16. }
17. //判断栈是否已经满了
18. int stack_full (const stack *p_stack){
19.         return p_stack->qty >= SIZE;
20. }
21. //判断栈是否为空
22. int stack_empty (const stack *p_stack){
23.         return !(p_stack->qty);
24. }
25. //向栈里加入数字的函数
26. int stack_push (stack *p_stack,int num){
27.         if (p_stack->qty >= SIZE){
28.                 return 0;
29.         }
30.         p_stack->buf[p_stack->qty] = num;
31.         p_stack->qty++;
32.         return 1;
33. }
34. //从栈里获得数字的函数(从栈里删除数字)
35. int stack_pop (stack *p_stack,int *p_num){
36.         if (!(p_stack->qty)){
37.                 return 0;
38.         }
39.         *p_num = p_stack->buf[p_stack->qty - 1];
40.         p_stack->qty--;
41.         return 1;
42. }
43. //从栈里获得数字的函数（不会删除数字）
44. int stack_top (const stack *p_stack,int *p_num){
45.         if (!(p_stack->qty)){
46.                 return 0;
47.         }
48.         *p_num = p_stack->buf[p_stack->qty - 1];
49.         return 1;
50. }

复制代码

说明：步伐执行后，根据数据输入非负数，数据输入完成时，以负数结束输入。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。