数据结构面试之三——栈的常见操作

最新推荐文章于 2024-09-12 23:51:43 发布
原创 最新推荐文章于 2024-09-12 23:51:43 发布 · 置顶 · 743 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍了如何使用数组和链表两种不同数据结构实现栈的基本操作，包括初始化、销毁、判断栈是否为空或满、入栈、出栈等核心功能，并提供了完整的C++代码实现。

数据结构面试之三——栈的常见操作

题注：《面试宝典》有相关习题，但思路相对不清晰，排版有错误，作者对此参考相关书籍和自己观点进行了重写，供大家参考。

三、栈的基本操作

3.1用数组构造栈

【注意以下几点】：

1.基于数组的栈的三要素：1）栈的最大容量maxSize; 2)栈的当前容量=当前栈中元素的个数=栈顶top-1；3）动态数组存储栈的元素 Type* list；

       2.对于出栈、入栈的操作要对应先判断栈空、栈满；如果空、满要有异常处理或错误提示。

       3.注意入栈push操作，先入栈后top+1；出栈pop则相反，先top-1，再出栈。【注意因为，top指向数组中最后一个元素的下一个位置】。

       4.拷贝构造函数和赋值函数要注意，尤其赋值的时候，避免自身赋值、同时要注意大小不一致的不能完成赋值操作，要有相关提示。

      

[cpp]  view plain copy
  1.  template<typenameType>  
  2. class arrStack  
  3. {  
  4. public:  
  5.        arrStack(intnSize=100);  
  6.        ~arrStack();  
  7.        arrStack(constarrStack& copyStack);  
  8.        arrStack&operator=(const arrStack& otherStack);  
  9.    
  10.        voidinitializeStack();  
  11.        void destroyStack();  
  12.        bool isStackEmpty();  
  13.        bool isStackFull();  
  14.        void push(constType& item);  
  15.        void pop(Type&poppedItem);  
  16.    
  17. private:  
  18.        int maxSize;  
  19.        int top;  
  20.        Type* list;  
  21. };  
  22.    
  23. template<typename Type>  
  24. arrStack<Type>::arrStack(int nSize=100)  
  25. {  
  26.        if(nSize < 0)  
  27.        {  
  28.               nSize = 100;  
  29.               list = newType[nSize];  
  30.               top = 0;  
  31.               maxSize = 100;  
  32.        }  
  33.        else  
  34.        {  
  35.               list = newType[nSize];  
  36.               top = 0;  
  37.               maxSize =nSize;  
  38.        }  
  39. }  
  40.    
  41. template<typename Type>  
  42. arrStack<Type>::~arrStack()  
  43. {  
  44.        if(!list)  
  45.        {  
  46.               delete[]list;                //注意数组的删除，为delete []list;  
  47.               list = NULL;  
  48.        }  
  49. }  
  50.    
  51. template<typename Type>  
  52. arrStack<Type>::arrStack(const arrStack& copyStack)  
  53. {  
  54.        maxSize =copyStack.maxSize;  
  55.        top = copyStack.top;  
  56.        list = newType[maxSize];           //注意需要自定义大小,容易出错.  
  57.        for( int i = 0; i <top; i++)  
  58.        {  
  59.               list[i] =copyStack.list[i];  
  60.        }  
  61. }  
  62.    
  63. template<typename Type>  
  64. arrStack<Type>& arrStack<Type>::operator=(constarrStack& otherStack)  
  65. {  
  66.        if(this ==&otherStack)  
  67.        {  
  68.               cout <<"can't copy oneSelf!" << endl;  
  69.               return *this;  
  70.        }  
  71.        else  
  72.        {  
  73.               if(maxSize !=otherStack.maxSize)  
  74.               {  
  75.                      cout<< "The Size of two stack are not equal!" << endl;  
  76.                      return*this;  
  77.               }  
  78.               else  
  79.               {  
  80.                      maxSize= otherStack.maxSize;  
  81.                      top =otherStack.top;  
  82.                      for( inti = 0; i < top; i++)  
  83.                      {  
  84.                             list[i]= otherStack.list[i];  
  85.                      }//endfor  
  86.                      return*this;  
  87.               }  
  88.        }//end else  
  89. }  
  90.    
  91. template<typename Type>  
  92. void arrStack<Type>::initializeStack()  
  93. {  
  94.        destroyStack();  
  95. }  
  96.    
  97. template<typename Type>  
  98. void arrStack<Type>::destroyStack()  
  99. {  
  100.        top = 0;  
  101. }  
  102.    
  103. template<typename Type>  
  104. bool arrStack<Type>::isStackEmpty()  
  105. {  
  106.        return (top == 0);  
  107. }  
  108.    
  109. template<typename Type>  
  110. bool arrStack<Type>::isStackFull()  
  111. {  
  112.        return (top ==maxSize);  
  113. }  
  114.    
  115. template<typename Type>  
  116. void arrStack<Type>::push(const Type& item)  
  117. {  
  118.        if(!isStackFull())  
  119.        {  
  120.               list[top] =item;  
  121.               top++;  
  122.        }  
  123.        else  
  124.        {  
  125.               cout <<"The Stack was already Full!" << endl;  
  126.        }  
  127. }  
  128.    
  129. template<typename Type>  
  130. void arrStack<Type>::pop(Type& poppedItem)  
  131. {  
  132.        if(!isStackEmpty())  
  133.        {  
  134.               top--;  
  135.               poppedItem =list[top];  
  136.        }  
  137.        else  
  138.        {  
  139.               cout <<"The Stack was already Empty!" << endl;  
  140.        }  
  141. }  

3.2用链表构造栈

链表构造栈注意：

1） 判断栈空的标记是top==NULL；由于栈的空间可以动态分配，因此可以认为链栈不会满。

2） 栈的入栈Push操作要先判定栈是否已经满，非满才可以入栈。先入栈，再调整top指针；

3） 栈的出栈Pop操作要先判定栈是否已空，非空才可以出栈。先调整top指针，再出栈，并删除原结点。

4） 可以加count判定当前结点的个数。

[cpp]  view plain copy
  1. template<typename Type>  
  2. struct nodeType  
  3. {  
  4.        Type info;  
  5.        nodeType* link;  
  6. };  
  7.    
  8. template<typename Type>  
  9. class linkedStack  
  10. {  
  11. public:  
  12.        linkedStack();  
  13.        ~linkedStack();  
  14.        linkedStack(constlinkedStack<Type>&);  
  15.        linkedStack&operator=(const linkedStack<Type>&);  
  16.    
  17.        voidinitializeStack();  
  18.        void destroyStack();  
  19.        bool isStackEmpty()const;  
  20.        bool isStackFull()const;  
  21.        void push(constType& item);  
  22.        void pop(Type&poppedItem);  
  23.        void nodeCount();  
  24.         
  25.        voidreversePrint();          //逆向打印的非递归实现...  
  26.    
  27. private:  
  28.        nodeType<Type>*top;  
  29.        int count;         //统计节点个数  
  30. };  
  31.    
  32. template<typename Type>  
  33. linkedStack<Type>::linkedStack()  
  34. {  
  35.        count = 0;  
  36.        top = NULL;  
  37. }  
  38.    
  39. template<typename Type>  
  40. linkedStack<Type>::~linkedStack()  
  41. {  
  42.        while( top != NULL )  
  43.        {  
  44.               nodeType<Type>*tempNode = new nodeType<Type>;  
  45.               tempNode = top;  
  46.               top =top->link;  
  47.    
  48.               deletetempNode;  
  49.        }//end if  
  50. }  
  51.   
  52.    
  53. template<typename Type>  
  54. linkedStack<Type>::linkedStack(constlinkedStack<Type>& copyStack)  
  55. {  
  56.        if(copyStack.top !=NULL)  
  57.        {  
  58.               nodeType<Type>*current;  
  59.               nodeType<Type>*first;  
  60.               nodeType<Type>*newNode;  
  61.                
  62.               top = newnodeType<Type>;  
  63.               top->info =copyStack.top->info;                //此处的top不能直接用，内存报错！  
  64.               top->link =copyStack.top->link;  
  65.    
  66.               first =top;                        //first跟进当前链表...  
  67.               current =copyStack.top->link;      //current跟进copy链表...  
  68.               while( current!= NULL)  
  69.               {  
  70.                      newNode= new nodeType<Type>;  
  71.                      newNode->link= current->link;  
  72.                      newNode->info= current->info;  
  73.    
  74.                      first->link= newNode;  
  75.                      first =newNode;  
  76.                      current= current->link;  
  77.               }//end while  
  78.               count =copyStack.count;  
  79.        }//end if  
  80.        else  
  81.        {  
  82.               top = NULL;  
  83.               count = 0;  
  84.        }  
  85. }  
  86.    
  87. template<typename Type>  
  88. linkedStack<Type>&linkedStack<Type>::operator=(const linkedStack<Type>&otherStack)  
  89. {  
  90.        //1避免自身赋值  
  91.        if(this ==&otherStack)  
  92.        {  
  93.               cout <<"Can't copy oneself!" << endl;  
  94.               return *this;  
  95.        }  
  96.        //2其他  
  97.        else  
  98.        {  
  99.               if(top != NULL)  
  100.               {  
  101.                      destroyStack();  
  102.               }  
  103.               if(otherStack.top!= NULL)  
  104.               {  
  105.                      nodeType<Type>*current;  
  106.                      nodeType<Type>*first;  
  107.                      nodeType<Type>*newNode;  
  108.    
  109.                      top =new nodeType<Type>;  
  110.                      top->info= otherStack.top->info;  
  111.                      top->link= otherStack.top->link;  
  112.                      first =top;                        //first跟进当前链表...  
  113.                      current= otherStack.top->link;      //current跟进copy链表...  
  114.                      while(current != NULL)  
  115.                      {  
  116.                             newNode= new nodeType<Type>;  
  117.                             newNode->link= current->link;  
  118.                             newNode->info= current->info;  
  119.    
  120.                             first->link= newNode;  
  121.                             first= newNode;  
  122.                             current= current->link;  
  123.                      }//endwhile  
  124.                      count =otherStack.count;  
  125.               }//end if  
  126.               else  
  127.               {  
  128.                      top =NULL;  
  129.                      count =0;  
  130.               }  
  131.               return *this;  
  132.        }  
  133. }  
  134.    
  135. template<typename Type>  
  136. void linkedStack<Type>::initializeStack()  
  137. {  
  138.        destroyStack();  
  139. }  
  140.    
  141. template<typename Type>  
  142. void linkedStack<Type>::destroyStack()  
  143. {  
  144.        count = 0;  
  145.        top = NULL;  
  146. }  
  147.    
  148. template<typename Type>  
  149. bool linkedStack<Type>::isStackEmpty() const  
  150. {  
  151.        return (count == 0);  
  152. }  
  153.    
  154. template<typename Type>  
  155. bool linkedStack<Type>::isStackFull() const //空间非固定，动态申请!  
  156. {  
  157.        return false;  
  158. }  
  159.    
  160. template<typename Type>  
  161. void linkedStack<Type>::push(const Type& item)  
  162. {  
  163.        if(!isStackFull())  
  164.        {  
  165.               nodeType<Type>*newNode = new nodeType<Type>;  
  166.               newNode->info= item;  
  167.               newNode->link= NULL;  
  168.    
  169.               if(top == NULL)  
  170.               {  
  171.                      top = newNode;  
  172.               }  
  173.               else  
  174.               {  
  175.                      newNode->link= top;  
  176.                      top =newNode;  
  177.               }  
  178.               count++;  
  179.               cout <<item << " was pushed!" << endl;  
  180.        }  
  181. }  
  182.    
  183. template<typename Type>  
  184. void linkedStack<Type>::pop(Type& poppedItem)  
  185. {  
  186.        if(!isStackEmpty())  
  187.        {  
  188.               nodeType<Type>*temp = new nodeType<Type>;  
  189.               temp = top;  
  190.               poppedItem =top->info;  
  191.               top =top->link;  
  192.                
  193.               count--;  
  194.               cout <<poppedItem << " was popped!" << endl;  
  195.               delete temp;  
  196.        }  
  197. }  
  198.    
  199. template<typename Type>  
  200. void linkedStack<Type>::nodeCount()  
  201. {  
  202.        cout <<"nodeCount = " << count << endl;  
  203. }  
  204.    
  205. //上一节的递归实现逆向链表打印，这是非递归的实现。  
  206. template<typename Type>  
  207. void linkedStack<Type>::reversePrint()          //逆向打印的非递归实现...  
  208. {  
  209. //  注释部分可作为链表调用栈的非递归实现。  
  210. //    nodeType<Type>*current = new nodeType<Type>;  
  211. //    current = top;  
  212. //    while(current != NULL)  
  213. //    {  
  214. //           pop(current->info);  
  215. //           current =current->link;  
  216. //    }  
  217.        int poppedItem = 0;  
  218.        while(!isStackEmpty())  
  219.        {  
  220.               pop(poppedItem);  
  221.        }  
实验三 栈的基本操作
沉默的大多数
10-29 2万+
实验三 栈的基本操作一、实验目的 1．掌握栈的存储结构的表示和实现方法。 2．掌握栈的入栈和出栈等基本操作算法实现。 3．了解栈在解决实际问题中的简单应用。二、实验内容 1．建立顺序栈，并在顺序栈上实现入栈和出栈操作。 2．建立链栈，并在链栈上实现入栈和出栈操作。三、实验要求 1．建立顺序栈，并在顺序栈上实现入栈和出栈操作。 （1）根据输入的栈中元素个数n和各元素值建立一个顺序栈
栈（面试一锅端了系列之数据结构栈）
weixin_44003176的博客
06-19 247
前言:本文结构 1.什么是栈 2.如何实现栈—>jdk如何实现栈 3.栈的应用 4.栈常见的算法题------>单调栈 5.未完待续 一切解决问题思路：栈先入后出的数据结构 1.什么是栈？ 1)栈(Stack)是一种先入后出的线性表 2)栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶(Top)（我们在栈顶进行的插入和删除称为入栈和出栈）另一端为固定的一端，称为栈底(Bottom)。 3)根据栈的定义可知，最先放
【数据结构之栈系列】栈及其经典面试题详解
胡坚涛的博客
01-11 1205
前面学习的线性表中包含顺序表和链表，这两种数据结构允许在任意位置进行插入和删除，那么有没有一种数据结构是不能在任意位置进行插入删除，而只允许在一边进行插入删除的呢？？当然有的，这就是我们今天要学习的一种新的数据结构：栈
【数据结构】栈和队列面试题
如风逝去
08-03 434
1、实现一个栈，要求实现Push（出栈）、Pop（入栈）、Min（返回最 小值的操作）的时间复杂度为O(1) 针对这个问题我们可以有两种方法来解决，第一种方法： 我们每次压栈的时候压两个数字，先压数据，然后压最小值，每次压之前和数据比较一下，如果数据比最小值还小就把最小值更新成数据，然后再压数据和最小值，这就是压栈操作。这样可以保证栈顶就是最小值。 接下来是出栈操作，因为我们每次多压了一个...
栈的基本概念及顺序栈的定义
最新发布
qq_35899077的博客
09-12 526
​ 栈(Stack)是只允许在一端进行插入或删除操作的线性表栈顶：允许插入和删除的一端栈底：不允许插入和删除的一端。固定的空栈：不含任何元素的空表后进先出(Last In First Out) 即LIFO#define MaxSize 10 //定义栈中元素的最大个数//静态数组存放栈中元素int top;//栈顶指针}SqStack;SqStack S;//声明一个顺序栈//判断栈是否为空 利用top的指向判断//栈空else//非空。
【JS数据结构】线性结构——栈结构
早睡早起长头发的博客
10-13 850
一. 认识栈结构 1.栈结构 1.1栈（stack） 1.2 生活中类似于栈的 1.3 栈结构的图解 1.4 程序中的函数调用栈是使用栈实现的呢? 1.5 栈面试题 二. 栈结构实现 1.栈的创建 1.1 创建一个栈的类, 用于封装栈相关的操作 1.2 代码解析: 2.栈的操作 2.1 方式一 2.2 方式二 3.栈的使用 三. 栈结构应用 1.十进制转二进制 1.1 为什么需要十进制转二进制 1.2 如何实现十进制转二进制 1.3 代码来实现十进制转二进制
算法与数据结构面试宝典——常见的数据结构都有哪些？详细示例（C#，C++）
qq_35320456的博客
06-30 926
本文详细讲解了C#和C++中常见的数据结构及其应用场景，并提供了示例代码。掌握这些数据结构对于算法与数据结构面试至关重要。希望读者通过本文能够更好地理解和应用这些数据结构。
数据结构——栈（栈结构、栈面试题、栈的操作、栈结构实现、进制的转换）
qq_52301431的博客
08-22 675
因为我们使用的是数组来作为栈的底层实现的, 所以直接获取数组的长度即可.(也可以使用链表作为栈的顶层实现)- 向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；- `peek()`：返回栈顶的元素，不对栈做任何修改（这个方法不会移除栈顶的元素，仅仅返回它）。- 注意: 我们的实现是将最新的元素放在了数组的末尾, 那么数组末尾的元素就是我们的栈顶元素。- 从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。
数据结构经典面试之列表——C#和C++篇
qq_35320456的博客
06-22 1332
在编程中，列表是一种非常常见的数据结构，它用于存储一系列元素，这些元素可以是数字、字符、字符串等。本文将详细介绍C#和C++中的列表数据结构，并通过示例来说明如何使用它们。
数据结构经典面试之数组——C#和C++篇
qq_35320456的博客
06-20 1218
数组是一种基础且重要的数据结构，在C#和C++这两种编程语言中都有广泛的应用。通过本文的介绍，希望你对数组的概念、特点以及在C#和C++中的使用方法有了更深入的了解。在实际编程过程中，熟练掌握数组的使用对于提高代码效率和性能具有重要意义。在编程中，我们应该根据具体需求选择合适的数据结构。数组适合于处理固定数量和类型的元素，但如果元素数量或类型需要动态变化，可能需要考虑使用其他数据结构，如列表、字典等。此外，随着编程技能的提高，了解和掌握更高级的数据结构将有助于我们编写更高效、更灵活的代码。
【数据结构-栈】对栈的理解逻辑都在这了(图文版)
qq_58803118的博客
10-13 1500
1.栈（堆栈）简介 2.栈包含的特性以及基本运算 3.基于数组的栈逻辑运算 4.基于链表的栈逻辑运算 1.1栈（堆栈）简介 栈（stack）也被称为堆栈，是一种受限运算的线性表，是一组相同数据类型的组合。它添加和删除元素都被限制在表的一端进行（栈顶端），而另外一端则被称为栈底。 栈中的元素以后进先出（Last In First Out, LIFO）的方式进出栈，它按照先进后出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）
C_栈..
PepDokHa的博客
01-20 785
C语言—数据结构 实现栈
3.1 栈
m0_46640227的博客
03-03 263
文章目录1.基本概念1.1 定义及基本操作1.2 栈的基本操作2.顺序存输2.1 顺序栈的定义2.2 进栈操作3.链式存储 1.基本概念 1.1 定义及基本操作 数据结构三要素：逻辑结构、数据的运算、存储结构 栈(Stack)是只允许在一端进行插入或删除操作的线性表 逻辑结构：与普通线性表相同 数据的运算：插入、删除操作有区别 重要术语：栈顶、栈底、空栈 1.2 栈的基本操作 2.顺序存输 2.1 顺序栈的定义 #define Maxsize 10 //定义栈中元素的最大个数 typed
栈——栈的基本概念和基本操作
qq_45965736的博客
09-20 938
对栈的基本学习，以及栈的基本操作的学习，卡特兰数的出栈元素的不同排列个数。
栈的基本操作
weixin_64084604的博客
11-24 5491
define MaxSize 10 //定义栈中元素的最大个数{//静态数组存放栈中元素int top;//栈顶指针，名叫指针，实则只是一个int型整数来反映栈顶元素的数组下标}SqStack;//后续声明一个顺序栈(分配空间)就 SqStack S;补充解释：（1）顺序存储：给各个数据元素分配连续的存储空间，大小为MaxSize*sizeof(ElemType);（2）结构中定义的int top名为栈顶指针，这里的“指针”和我们所说的数据类型指针实际上不是一回事。
任务的三要素是任务主体函数，任务栈和任务控制块
诗筱涵的博客
08-12 990
任务的三要素是任务主体函数，任务栈和任务控制块 由xTaskCreateStatic()函数来把三者联合起立。 下面拍自野火的《FreeRTOS内核实现与应用开发实战指南》
数据结构之栈的基本概念
calm_encode的博客
07-25 848
一 栈的定义 栈是允许在一端进行插入或者删除操作的线性表。它是一种线性表，但是限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Botton）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 二 栈结构的解析 假设某个栈S={a1,a2,a3,a4,a5}，如图，a1为栈底元素，a5为栈顶元素。由于栈只能从栈顶进行插入和删除操作，进栈次序依次为a1,a2,a3,a4,a5。而出栈的次序为a5,a4,a3,a2,a1。由此可
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值