设为首页收藏本站
切换到窄版

鱼C论坛

 找回密码
 立即注册
鱼C论坛»论坛 › 编程语言专区 › 数据结构与算法 › 栈知识总结
返回列表 发新帖
查看: 2386|回复: 1

[学习笔记] 栈知识总结

[复制链接]
Julia999
发表于 2019-10-6 12:14:32 | 显示全部楼层 |阅读模式

马上注册，结交更多好友，享用更多功能^_^

您需要 登录 才可以下载或查看，没有账号？立即注册

x
本帖最后由 Julia999 于 2019-10-6 12:14 编辑
栈---线性结构
从数据结构上看，栈和队列也是线性表，其特别之处在于他们的基本操作是线性表操作的子集，即他们是操作受限的线性表
栈：打个简单的比方：空栈就是一个空的水杯，如果你要往里面加水，只能从杯口加入（从栈顶加入），如果你要倒水也只能从杯口倒出（从栈顶删除），那么杯子的杯底就是栈的栈底
对应的来看，栈的插入和删除操作只能在表尾进行。
栈的特点：先进后出（想想水杯）


栈又可以分为顺序栈和链栈

顺序栈
顺序栈是指利用顺序存储的栈（同时设指针top指向栈顶元素在栈中的位置，以base指针指示栈底元素在顺序表中的位置）
所以当base和top相等时，表示为空栈

（1）base为栈底指针，初始化完成后，栈底指针base始终指向栈底的位置，若base的值为NULL时，则表明栈结构不存在。top为栈顶指针，其初始值指向栈底。
每当插入新的栈元素时，指针top增1，删除栈顶元素时，指针top减1。因此，栈空时，top和base相等，都指向栈底，栈非空时，top始终指向栈顶元素的上一个位置。


操作：
（1）初始化
顺序栈的初始化操作就是为顺序栈动态分配一个预定大小的数组空间。
a.为顺序栈动态分配一个最大容量为MAXSIZE的数组空间，使base指向这段空间的基地址，即栈底
b.栈顶指针top初始为base，表示栈为空
c.stacksize置为栈的最大容量MAXSIZE

（2）入栈
入栈操作是指在栈顶插入一个新的元素
a.判断栈是否已满，若满则返回false
b.将新的元素压入栈顶，栈顶指针加1
（3）出栈
将栈顶元素删除
a.判断栈是否为空，如果为空，返回false
b.栈顶指针减1，栈顶元素出栈
（4）取栈顶元素
当栈为非空时，此操作返回当前栈顶的元素的值，栈顶指针保持不变


链栈
顺序栈的操作受到容量的限制，所以我们要学习链栈
链栈是用链式存储结构实现的栈
tips：由于栈的主要操作是在栈顶上插入和删除，所以以链表的头部作为栈顶是最方便的，并且不需要像单链表那样附加一个头节点
操作：
（1）初始化
初始化就是构造一个空栈，因为没必要设头节点，所以直接将栈顶指针置为空即可。
（2）入栈
不需要判断栈是否满，只需要为入栈元素动态分配一个节点空间
a.为入栈元素e分配空间，用指针p指向
b.将新节点数据域置e
c.将新节点插入栈顶
d.修改栈顶指针为p
（3）出栈
需要注意的是，出栈后需要释放栈顶元素的内存空间
a.判断栈是否为空，是则返回false
b.将栈顶元素赋给e
c.临时保存栈顶元素的空间以便释放
d.修改栈顶指针，指向新的栈顶元素
e.释放原栈顶元素的空间
（4）取栈顶元素
返回栈顶元素的值，栈顶指针保持不变


栈与递归
栈有一个重要的应用是在程序设计语言中实现递归

顺序栈：
  1. #if 0

  3. #include<iostream>
  4. using namespace std;

  6. #define ElemType int
  7. #define Maxsize 100

  9. //栈的数据结构
  10. typedef struct stack
  11. {
  12.         ElemType *base; //栈底指针
  13.         ElemType *top;  //栈顶指针
  14.         int stacksize;  //栈可用的最大容量
  15. }Stack;

  17. //初始化函数
  18. void initStack(Stack &s)
  19. {
  20.         s.base = new ElemType[Maxsize];
  21.         if (s.base == NULL)
  22.         {
  23.                 cout << "内存分配失败！" << endl;
  24.                 return;
  25.         }
  26.         s.top = s.base;
  27.         s.stacksize = Maxsize;
  28. }

  30. //入栈
  31. void pushStack(Stack &s,ElemType a)
  32. {
  33.         //判断栈是否已满
  34.         if (s.top - s.base == s.stacksize)
  35.         {
  36.                 cout << "栈已满！" << endl;
  37.                 return;
  38.         }
  39.         *(s.top) = a;
  40.         s.top++;
  41. }

  43. void PopStack(Stack &s)
  44. {
  45.         //判断栈是否已满
  46.         if (s.top - s.base == s.stacksize)
  47.         {
  48.                 cout << "栈已满!" << endl;
  49.                 exit(0);
  50.         }
  51.         //栈空
  52.         if (s.top == s.base)
  53.         {
  54.                 cout << "栈空！" << endl;
  55.                 exit(0);
  56.         }
  57.         s.top--;
  58. }


  61. void GetTopElem(Stack s,ElemType &e)
  62. {
  63.         //栈空
  64.         if (s.top == s.base)
  65.         {
  66.                 cout << "栈空！" << endl;
  67.                 exit(0);
  68.         }
  69.         e = *(--s.top);
  70. }

  72. void display(Stack s)
  73. {
  74.         //栈为空
  75.         if (s.top == s.base)
  76.         {
  77.                 cout << "栈为空！" << endl;
  78.                 exit(0);
  79.         }
  80.         while (s.top != s.base)
  81.         {
  82.                 cout << *(--s.top) << "\t";
  83.         }
  84.         cout << endl;
  85. }

  87. //创建一个操作菜单
  88. void menu()
  89. {
  90.         cout << "*****************顺序栈的操作*****************" << endl;
  91.         cout << "**********************************************" << endl;
  92.         cout << "*         1.入栈           2.出栈            *" << endl;
  93.         cout << "*         3.取栈           4.显示            *" << endl;
  94.         cout << "*                  5.退出                    *" << endl;
  95.         cout << "**********************************************" << endl;

  97.         Stack s;
  98.         initStack(s);

  100.         int choice;
  101.         ElemType a;
  102.         ElemType e;

  104.         while (1)
  105.         {
  106.                 cout << "请输入你的操作：";
  107.                 cin >> choice;

  109.                 if (choice == 5)
  110.                         break;
  111.                 switch (choice)
  112.                 {
  113.                 case 1:
  114.                         cout << "请输入需要入栈的元素:";
  115.                         cin >> a;
  116.                         pushStack(s, a);
  117.                         break;
  118.                 case 2:
  119.                         PopStack(s);
  120.                         break;
  121.                 case 3:
  122.                         GetTopElem(s,e);
  123.                         cout << "栈顶元素是：" << e << endl;
  124.                         break;
  125.                 case 4:
  126.                         display(s);
  127.                         break;
  128.                 default:cout << "输入有误！" << endl;
  129.                 }
  130.         }
  131. }
  132. int main()
  133. {
  134.         menu();
  135.         system("pause");
  136.         return 0;
  137. }

  139. #endif
复制代码


由于链栈的操作跟链表很相似，所以顺便来温习一下链表：
  1. #if 0
  2. #include<iostream>
  3. using namespace std;

  5. struct Node
  6. {
  7.         int data;
  8.         struct Node *next;
  9. };

  11. //1.创建表 链表的实质就是结构体和结构体连在一起
  12. //创建表就是创建结构体变量 用指针去表示--->指针成为变量--->动态内存
  13. //如何去表示一个表： 用一个节点去表示整个链表
  14. struct Node* creatList()
  15. {
  16.         struct Node *head = new struct Node;
  17.         //变量规则：需要初始化才能使用
  18.         //data为什么没有初始化-->>有表头的链表
  19.         //差异化处理

  21.         head->next = NULL;
  22.         return head;
  23. }

  25. //创建节点，为插入做准备
  26. struct Node* creatNode(int data)
  27. {
  28.         //结构体指针-->结构体变量
  29.         struct Node* node = new struct Node;
  30.         //给结构体变量初始化
  31.         node->data = data;
  32.         node->next = NULL;
  33.         //返回创建节点
  34.         return node;
  35. }

  37. //插入节点
  38. //1.表头插入
  39. //函数的参数设计是有含义的：插入哪个链表？插入新节点的数据？
  40. void insertListByHead(struct Node *headNode, int a)
  41. {
  42.         //插之前：首先要有新的节点
  43.         struct Node* nextNode = creatNode(a);  //封装了一个创建节点的函数

  45.         nextNode->next = headNode->next;
  46.         headNode->next = nextNode;
  47. }

  49. //2.表尾插入
  50. //找到尾节点在哪里
  51. void insertListByTail(struct Node* headNode, int a)
  52. {
  53.         struct Node *newNode = creatNode(a);

  55.         struct Node* backNode = headNode;
  56.         while (backNode->next)
  57.         {
  58.                 backNode = backNode->next;
  59.         }

  61.         backNode->next = newNode;
  62.         newNode->next = NULL;
  63. }

  65. void printList(struct Node* headNode)
  66. {
  67.         //因为是有表头的，所以要从第2个节点开始打印
  68.         //怎么打印 要移动 动起来
  69.         struct Node* p = new struct Node;
  70.         p = headNode->next;
  71.         while (p)
  72.         {
  73.                 cout << p->data << "\t";
  74.                 p = p->next;
  75.         }
  76.         cout << endl;
  77. }

  79. int main()
  80. {
  81.         struct Node *List = creatList();
  82.         insertListByHead(List, 1);
  83.         insertListByHead(List, 2);
  84.         insertListByHead(List, 3);

  86.         insertListByTail(List, 4);
  87.         insertListByTail(List, 5);


  90.         printList(List);


  93.         system("pause");
  94.         return 0;
  95. }
  96. #endif
复制代码



链栈：
  1. #if 0

  3. #include<iostream>
  4. using namespace std;

  6. //节点结构体
  7. struct Node
  8. {
  9.         int data;
  10.         struct Node *next;

  12. };

  14. //创建节点
  15. struct Node* creatNode(int data)
  16. {
  17.         struct Node* newNode = new Node;
  18.         newNode->data = data;
  19.         newNode->next = NULL;

  21.         return newNode;
  22. }


  25. //既然是一个链栈，那我们可以写一个链栈的结构体
  26. struct Stack
  27. {
  28.         struct Node * StackTop;   //用栈顶指针表示整个链栈
  29.         int size;                 //数据结构的万金(栈的大小）
  30. };


  33. //一样的，首先我们需要创建栈
  34. struct Stack* creatStack()
  35. {
  36.         //指针-->变量
  37.         struct Stack *myStack = new Stack;
  38.         //初始化变量
  39.         myStack->StackTop = NULL;
  40.         myStack->size = 0;
  41.         //返回变量
  42.         return myStack;
  43. }

  45. //入栈
  46. void push(struct Stack *mystack, int data)
  47. {
  48.         //入栈->链表表头插入的操作
  49.         struct Node *newNode = creatNode(data);

  51.         //要注意的是，下面的插入的时候没有了头节点
  52.         newNode->next = mystack->StackTop;
  53.         mystack->StackTop = newNode;
  54.         mystack->size++;
  55. }

  57. //获取栈顶元素
  58. void top(struct Stack*mystack, int &e)
  59. {
  60.         if (mystack->size == 0)
  61.         {
  62.                 cout << "栈空！" << endl;
  63.                 exit(0);
  64.         }
  65.         e = mystack->StackTop->data;
  66. }


  69. //出栈
  70. void pop(struct Stack *mystack)
  71. {
  72.         if (mystack->size == 0)
  73.         {
  74.                 cout << "栈已空！" << endl;
  75.                 exit(0);
  76.         }
  77.         //在删除的时候特别需要注意的是，如果直接就删除了，那么就没法找到下面一个了
  78.         //所以我们需要把要删除的下一个节点保存起来再删除节点，再将指针往后移
  79.         //步骤：保存->删除->重置->长度-1
  80.         struct Node *nextNode = mystack->StackTop->next;
  81.         delete(mystack->StackTop);
  82.         mystack->StackTop = nextNode;
  83.         mystack->size--;
  84. }

  86. //判断栈是否为空
  87. int empty(struct Stack mystack)
  88. {
  89.         if (mystack.size == 0)
  90.         {
  91.                 return 1;
  92.         }
  93.         else
  94.         {
  95.                 return 0;
  96.         }
  97. }

  99. void display(struct Stack *mystack)
  100. {
  101.         struct Node *p = mystack->StackTop;
  102.         while (p->next)
  103.         {
  104.                 cout << p->data << "\t";
  105.                 p = p->next;
  106.         }
  107.         cout << p->data;
  108.         cout << endl;
  109. }

  111. //创建一个操作菜单
  112. void menu()
  113. {
  114.         cout << "******************链栈的操作******************" << endl;
  115.         cout << "**********************************************" << endl;
  116.         cout << "*         1.入栈           2.出栈            *" << endl;
  117.         cout << "*         3.取栈           4.显示            *" << endl;
  118.         cout << "*                  5.退出                    *" << endl;
  119.         cout << "**********************************************" << endl;

  121.         struct Stack *mystack = creatStack();

  123.         int choice;
  124.         int a;//入栈元素
  125.         int e; //取栈顶元素

  127.         while (1)
  128.         {
  129.                 cout << "请输入你的操作：";
  130.                 cin >> choice;

  132.                 if (choice == 5)
  133.                         break;
  134.                 switch (choice)
  135.                 {
  136.                 case 1:
  137.                         cout << "请输入需要入栈的元素:";
  138.                         cin >> a;
  139.                         push(mystack, a);
  140.                         break;
  141.                 case 2:
  142.                         pop(mystack);
  143.                         break;
  144.                 case 3:
  145.                         top(mystack, e);
  146.                         cout << "栈顶元素是：" << e << endl;
  147.                         break;
  148.                 case 4:
  149.                         display(mystack);
  150.                         break;
  151.                 default:cout << "输入有误！" << endl;
  152.                 }
  153.         }
  154. }
  155. int main()
  156. {
  157.         menu();

  159.         system("pause");
  160.         return 0;
  161. }
  162. #endif
复制代码



小甲鱼最新课程 -> https://ilovefishc.com
回复

使用道具 举报

_2_
发表于 2019-10-6 12:41:23 | 显示全部楼层
对不起，我还没学C语言
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

小黑屋|手机版|Archiver|鱼C工作室 ( 粤ICP备18085999号-1 | 粤公网安备 44051102000585号)

GMT+8, 2025-5-13 18:08

Powered by Discuz! X3.4

© 2001-2023 Discuz! Team.

快速回复 返回顶部 返回列表