21-堆栈

Stack(栈)

栈的结构：

下面是数据结构的集中类型：

 1 struct stu   //链表
 2 {
 3     int data;  //抽象出的一种数据
 4     struct stu *pnext;   //链表的指针
 5 };
 6 
 7 struct    //顺序表
 8 {
 9     int data[100];
10     int size;    //顺序表大小标志
11 };
12 
13 struct  //顺序结构的栈
14 {
15     int data[100];
16     int top; //栈顶标志
17 };

顺序结构的栈：

 1 #include <stdio.h>
 2 #define MAXSIZE 100
 3 
 4 typedef struct  //顺序结构的栈
 5 {
 6     int data[MAXSIZE];
 7     int top; //栈顶标志
 8 
 9 }SeqStack;
10 
11  
12 void StackInit(SeqStack *S);  //初始化
13 int StackPush(SeqStack *S, int data);//入栈
14 int StackPop(SeqStack *S,int *data);//出栈
15 
16 int main()
17 {
18     int data;
19     SeqStack myStack; //定义一个变量
20     StackInit(&myStack); //初始化栈
21 
22     for (int i = 0; i < 10; i++)
23     {
24         StackPush(&myStack, i+1);
25         printf("%d\t", myStack.data[i]);
26     }
27 
28     for (int i = 0; i < 10; i++)
29     {
30         StackPop(&myStack, &data);
31         printf("%d\t", data);
32     }
33 
34     return 0;
35 }
36 
37 
38 //初始化
39 void StackInit(SeqStack *S)
40 {
41     S->top = 0;
42 }
43 
44 //入栈
45 int StackPush(SeqStack *S, int data)
46 {
47     if (S->top >= MAXSIZE)  //判断栈是否满
48     {
49         printf("栈满！\n");
50         return 0;
51     }
52     else
53     {
54         S->data[S->top] = data;  //往栈顶加入数据
55         S->top++;
56         return 1;
57     }
58 }
59 
60 
61 //出栈  不是要删除  而是得到
62 int StackPop(SeqStack *S,int *data)
63 {
64     if (S->top <= 0)
65     {
66         printf("栈空\n");
67         return 0;
68     }
69     else
70     {
71         S->top--;
72         *data = S->data[S->top];
73         return 1;
74     }
75 }
76 
77  
78 //栈顶的元素  出栈判空  入栈判满  *data = S->data[S->top-1];
79 // 1 2 3 4 5 6 7 8 9 10

链式结构的栈：

 1 //链式栈
 2 #include <stdio.h>
 3 
 4 typedef struct node
 5 {
 6 int data;   
 7 struct node *pnext;
 8 }LsNode;
 9 
10  
11 void StackInit(LsNode **head);//初始化
12 void StackPush(LsNode *head, int data);  //入栈
13 int StackPop(LsNode *head, int *data); //出栈
14 
15 int main()
16 {
17     int data;
18     LsNode *head;  //在主函数中定义变量的时候，系统根据变量的数据类型开辟大小。int a 4  double b 8
19     //定义指针变量的时候必须用malloc去只指定内存的大小。
20     StackInit(&head);
21 
22     for (int i = 0; i < 10; i++)
23     {
24         StackPush(head, i + 1);
25     }
26 
27 
28     for (int i = 0; i < 10; i++)
29     {
30         StackPop(head, &data);
31         printf("%d\t", data);
32     }
33 
34     return 0;
35 }
36 
37  
38 //初始化
39 void StackInit(LsNode **head)
40 {
41     *head = (LsNode *)malloc(sizeof(LsNode));
42     (*head)->pnext = NULL;  //int =NULL;
43 }
44 
45 //入栈
46 void StackPush(LsNode *head,int data)
47 {
48     LsNode *p;  //从新定义一个节点
49     p = (LsNode *)malloc(sizeof(LsNode));  //为新的节点开辟空间
50 
51     //malloc 开辟一块内存 并且返回一个空指针类型,空指针类型可以强制转换为任意其他指针类型。
52     p->data = data; //对新节点的内容填充
53     p->pnext = head->pnext; //新节点的pnext指向NULL
54     head->pnext = p; //新节点的地址赋给head->pnext.
55 }
56 
57  
58 //出栈
59 int StackPop(LsNode *head,int *data)
60 {
61     LsNode *p = head->pnext;  //p指向哪里？ 指向第一个元素
62     if (NULL == p)
63     {
64         printf("栈空\n");
65         return 0;
66     }
67     else
68     {
69         head->pnext = p->pnext;     //让head->pnext指向下一个元素
70         *data = p->data; //得到需要的第一个元素保存在data变量中
71         free(p); //释放p指向的内存。
72         return 1;
73     }
74 }

//队列吗讲不完

注意：循环队列队列满头尾重合队列的大小 size 或者num 或者count计数

Typdef struct

｛

　　Int data[100];

　　Int front;

　　Int end;

　　Int count;

｝

链式：很灵活

作业：熟悉队列的结构并且尝试去操作队列。

猜你喜欢