其他分享
首页 > 其他分享> > 数据结构之栈

数据结构之栈

作者:互联网

一、栈的特点

(1)栈是一种线性结构,栈中的元素遵循先入后出的原则,最先进入的元素所在位置叫做栈底,最后放入的元素所在位置叫做栈顶。

这种结构类似于盛放羽毛球的圆筒,一端封闭,另一端开口,先放入的羽毛球位于筒的底部(即栈底),后放入的羽毛球位于筒的入口(即栈顶)。

(2)栈也是一种抽象的逻辑结构,依赖于物理结构(如数组、链表)而存在。既可以使用数组实现,也可以使用链表实现。

(3)出栈、入栈的时间复杂都是O(1)。

 

 

二、 栈的基本操作

栈的基本操作主要是出栈、入栈、获取栈顶元素等。

(1)入栈

栈的入栈操作只允许从栈顶一侧放入新元素,放入的新元素成为新的栈顶。

(2) 出栈

栈的出栈操作只允许从栈顶弹出,出栈元素的前一个元素变成了新的栈顶。

 

三、基于数组实现栈

 

  1 #include <iostream>
  2 #include <assert.h>
  3 
  4 // 基于数组实现的栈(模板类)
  5 template <class T>
  6 class ArrayStack
  7 {
  8 public :
  9     ArrayStack(int nCapcity = 8);
 10     ~ArrayStack();
 11 
 12     bool Push(const T& ele);
 13     T    Pop();
 14     T&   GetPop();
 15     int  GetNum();
 16 
 17 private:
 18     void Resize();
 19 private:
 20     T*   m_pElement;
 21     int  m_nCapicity;
 22     int  m_nNum;
 23 };
 24 
 25 template<class T>
 26 ArrayStack<T>::ArrayStack(int nCapcity)
 27     :m_nCapicity(nCapcity)
 28     ,m_pElement(new T[nCapcity])
 29     ,m_nNum(0)
 30 {
 31 
 32 }
 33 
 34 template<class T>
 35 ArrayStack<T>::~ArrayStack()
 36 {
 37     delete[] m_pElement;
 38 }
 39 
 40 template<class T>
 41 bool ArrayStack<T>::Push(const T& ele)
 42 {
 43     if(m_pElement == NULL)
 44     {
 45         printf(" m_pElement == NUL \n");
 46         assert(false && "m_pElement == NUL");
 47         return false;
 48     }
 49     if(m_nNum >= m_nCapicity)
 50     {
 51         Resize();
 52     }
 53 
 54     m_pElement[m_nNum] = ele;
 55     m_nNum++;
 56     return true;
 57 }
 58 
 59 template<class T>
 60 T ArrayStack<T>::Pop()
 61 {
 62     if(m_nNum <= 0)
 63     {
 64         return NULL;
 65     }
 66 
 67     m_nNum--;
 68     return m_pElement[m_nNum];
 69 }
 70 
 71 template<class T>
 72 T& ArrayStack<T>::GetPop()
 73 {
 74     if(m_nNum <= 0)
 75     {
 76         return NULL;
 77     }
 78 
 79     return m_pElement[m_nNum - 1];
 80 }
 81 
 82 template<class T>
 83 int ArrayStack<T>::GetNum()
 84 {
 85     return m_nNum;
 86 }
 87 
 88 template<class T>
 89 void ArrayStack<T>::Resize()
 90 {
 91     if(NULL == m_pElement)
 92     {
 93         if(m_nCapicity == 0)
 94         {
 95             m_nCapicity = 8;
 96         }
 97         m_pElement = new T[m_nCapicity];
 98         return;
 99     }
100 
101     T* pNewEle = new T[m_nCapicity * 2];
102     for(int i = 0;i < m_nNum;i++)
103     {
104         pNewEle[i] = m_pElement[i];
105     }
106 
107     delete[] m_pElement;
108     m_pElement = pNewEle;
109     m_nCapicity = m_nCapicity * 2;
110 }
111 
112 int main()
113 {
114     printf("Welcome to stack! \n");
115 
116     ArrayStack<int> stackVal1(4);
117     stackVal1.Push(1);
118     stackVal1.Push(10);
119     stackVal1.Push(20);
120     stackVal1.Push(40);
121     stackVal1.Push(60);
122 
123     int nNum = stackVal1.GetNum();
124     printf("------num:%d \n",nNum);
125    
126     for(int i = 0;i < nNum;i++)
127     {
128         int val1 = stackVal1.Pop();
129         printf("%d  ",val1);
130     }
131     printf("\n");
132 
133     nNum = stackVal1.GetNum();
134     printf("------num:%d \n",nNum);
135     return 0;
136 }

 

四、基于链表实现栈

  1 #include <iostream>
  2 #include <assert.h>
  3 
  4 template<class T>
  5 class Node
  6 {
  7 public:
  8     Node():m_pNext(NULL){}
  9     Node(T& data):m_Data(data),m_pNext(NULL){}
 10     Node(T& data,Node<T>* pNext):m_Data(data),m_pNext(pNext){}
 11 public:
 12     T        m_Data;
 13     Node<T>* m_pNext;
 14 };
 15 
 16 //单链表
 17 template<class T>
 18 class SingleList
 19 {
 20 public:
 21     SingleList():m_pHead(NULL),m_pCurrent(NULL),m_nSize(0){}
 22     ~SingleList()
 23     {
 24         Clear();
 25     }
 26 
 27     //获取链表元素个数
 28     int GetNum()
 29     {
 30         return m_nSize;
 31     }
 32 
 33     //尾部插入新节点
 34     bool InsertNode(const T& data)
 35     {
 36         Node<T>* pNew = new Node<T>();
 37         pNew->m_Data = data;
 38         pNew->m_pNext = NULL;
 39         if(m_pHead == NULL)
 40         {
 41             m_pHead = pNew;
 42             m_pCurrent = pNew;
 43         }
 44         else
 45         {
 46             m_pCurrent->m_pNext = pNew;
 47             m_pCurrent = pNew;
 48         }
 49         m_nSize++;
 50         return true;
 51     }
 52 
 53     //删除节点
 54     int DeleteNode()
 55     {
 56         if(m_nSize == 0 || m_pHead == NULL|| NULL == m_pCurrent)
 57         {
 58             return -1;
 59         }
 60 
 61         if(m_pHead == m_pCurrent)
 62         {
 63             m_pHead = m_pCurrent->m_pNext;
 64             delete m_pCurrent;
 65             m_pCurrent = m_pHead;
 66         }
 67         else
 68         {
 69             Node<T>* pCurrent = m_pHead;
 70             while(pCurrent)
 71             {
 72                 if(pCurrent->m_pNext == m_pCurrent)
 73                 {
 74                     pCurrent->m_pNext = m_pCurrent->m_pNext;
 75                     delete m_pCurrent;
 76                     m_pCurrent = pCurrent;
 77                     break;
 78                 }
 79                 else
 80                 {
 81                     pCurrent = pCurrent->m_pNext;
 82                 }
 83             }
 84         }
 85        
 86         m_nSize--;
 87         return m_nSize;
 88     }
 89 
 90     //获取当前节点数据
 91     void GetCurrentNodeData(T& data)
 92     {
 93         if(m_pCurrent)
 94         {
 95            data = m_pCurrent->m_Data ;
 96         }
 97     }
 98 
 99     //设置当前节点数据
100     void SetCurrentNodeData(T& data)
101     {
102         if(m_pCurrent)
103         {
104             m_pCurrent->m_Data = data;
105         }
106     }
107 
108     //清空列表
109     void Clear()
110     {
111         if(m_nSize == 0 || m_pHead == NULL)
112         {
113             return;
114         }
115 
116         Node<T>* tepCurrent = m_pHead;
117         Node<T>* tepNext = m_pHead->m_pNext;
118         
119         while(tepCurrent)
120         {
121             delete tepCurrent;
122             tepCurrent = tepNext;
123             if(tepNext)
124             {
125                 tepNext = tepNext->m_pNext;
126             }
127         }
128         m_pHead = NULL;
129         m_pCurrent = NULL;
130         m_nSize = 0;
131     }
132 private:
133     Node<T>*        m_pHead;
134     Node<T>*        m_pCurrent;
135     int             m_nSize;
136 };
137 
138 template<class T>
139 class LinkStack
140 {
141 public:
142     LinkStack(){}
143     ~LinkStack(){}
144     //获取元素个数
145     int  GetNum()
146     {
147         return m_SingleList.GetNum();
148     }
149 
150     //添加新元素
151     bool Push(const T& data)
152     {
153         return m_SingleList.InsertNode(data);
154     }
155 
156     //移除栈顶元素
157     T    Pop()
158     {
159         T temp;
160         if(GetNum() <= 0)
161         {
162             return -1;
163         }
164         m_SingleList.GetCurrentNodeData(temp);
165         m_SingleList.DeleteNode();
166         return temp;
167     }
168 private:
169     SingleList<T> m_SingleList;
170 };
171 
172 int main()
173 {
174     printf("Welcome to link stack.\n");
175     LinkStack<int> stackVal2;
176     stackVal2.Push(100);
177     stackVal2.Push(200);
178     stackVal2.Push(300);
179     stackVal2.Push(500);
180 
181     int nNum = stackVal2.GetNum();
182     for(int i = 0;i < nNum;i++)
183     {
184         int val = stackVal2.Pop();
185         printf("Pop:%d  =================\n",val);
186     }
187     
188 
189     return 0;
190 }

 

 

 

标签:nNum,return,int,之栈,pCurrent,ArrayStack,数据结构,pNext
来源: https://www.cnblogs.com/calence/p/11524970.html