棧的順序存儲結構

1. 棧的順序存儲和鏈表存儲的差異

順序存儲： 線性表的順序表：指的是用一組地址連續的存儲單元，依次存儲線性表的數據元素。
線性表的順序存儲結構具備如下兩個基本特徵： 1、線性表中的所有元素所佔的存儲空間是連續的（即要求內存中可用存儲單元的地址必須是連續的）。 2、線性表中各數據元素在存儲空間中是按邏輯順序依次存放的。 即：線性表邏輯上相鄰、物理也相鄰（邏輯與物理統一：相鄰數據元素的存放地址也相鄰），則已知第一個元素首地址和每個元素所佔位元組數，則可求出任一個元素首地址。 優點： 1、
無須為表示結點間的邏輯關系而增加額外的存儲空間。
2、
可以方便的隨機存取表中的任一結點。
3、
存儲密度大（＝1），存儲空間利用率高。 缺點： 1、
插入和刪除運算不方便，需移動大量元素。 2、
由於要求佔用連續的存儲空間，存儲分配只能按最大存儲空間預先進行，致使存儲空間不能得到充分利用。
3、
表的容量難以擴充。 鏈表存儲： 線性表的鏈式存儲：指用一組任意的存儲單元存儲線性表中的數據元素。
線性表的鏈式存儲結構具備的基本特徵： 鏈式存儲時，相鄰數據元素可隨意存放，但所佔存儲空間分兩部分，一部分存放結點值，另一部分存放表示結點間關系的指針。 優點： 1、
插入、刪除操作很方便，可通過修改結點的指針實現，無須移動元素。
2、
方便擴充存儲空間。
缺點： 1、
不能隨機存取元素。
2、
存儲密度小（<1），存儲空間利用率低。 總結： 1、
順序表適宜於做查找這樣的靜態操作；
鏈表宜於做插入、刪除這樣的動態操作。 2、若線性表的長度變化不大，且其主要操作是查找，則採用順序表； 若線性表的長度變化較大，且其主要操作是插入、刪除操作，則採用鏈表。

2. 棧的入棧順序和出棧順序的各種可能

棧中的數據只有一種方式出棧，即先進後出，所以出棧的可能數目跟入棧的可能排列數目是一致的。a的出入有2中可能，b的出入有2種可能，c的出入有2種可能，d只需要關系入，只有一種可能。所以可能的出棧方式數為2*2*2*1=8種

入棧順序：a、b、c、d。出棧順序可以是：d、c、b、a；a、b、c、d;b、a、c、d很多，但要把棧想像成一個沒蓋子的紙箱，取出東西時只能從最上層取，放進東西也只能放在最上層，所以棧是一個「後進先出」或「先進後出」的順序存儲結構。

(2)棧的順序存儲結構擴展閱讀：

棧的順序存儲結構是利用內存中的一片起始位置確定的連續存儲區域來存放棧中的所有元素，另外為了指示棧頂的准確位置，還需要引入一個棧頂指示變數top，採用順序存儲結構的棧稱為順序棧（sequence stack)。設數組data[MAXSIZE]為棧的存儲空間，其中MAX-SIZE是一個預先設定的常數，為允許進棧結點的最大可能數目，即棧的容量。

初始時棧空，top等於0。當top不等於0時，data[0]為棧底元素，即為當前停留在棧中時間最長的元素；而data[top-1]為最後入棧的元素，即為棧頂元素。

3. 棧的存儲結構

棧同順序表和鏈表一樣，棧也是用來存儲邏輯關系為 "一對一" 數據的線性存儲結構。

棧的具體實現
棧是一種 "特殊" 的線性存儲結構，因此棧的具體實現有以下兩種方式：
順序棧：採用順序存儲結構可以模擬棧存儲數據的特點，從而實現棧存儲結構；
鏈棧：採用鏈式存儲結構實現棧結構；

棧存儲結構與之前所學的線性存儲結構有所差異，這緣於棧對數據 "存" 和 "取" 的過程有特殊的要求：
棧只能從表的一端存取數據，另一端是封閉的；
在棧中，無論是存數據還是取數據，都必須遵循"先進後出"的原則，即最先進棧的元素最後出棧。

通常，棧的開口端被稱為棧頂；相應地，封口端被稱為棧底。因此，棧頂元素指的就是距離棧頂最近的元素。

4. 棧是不是順序存儲的線性結構啊

不一定。

棧分順序棧和鏈式棧。順序棧為棧的順序實現，順序棧為利用順序存儲結構實現的棧。

採用地址連續的存儲空間（數組)依次存儲棧中數據元素，由於人棧和出棧運算都是在棧頂進行，而棧底位置是固定不變的，可以將棧底位置設置在數組空間的起始處；棧頂位置為隨入棧和出棧操作而變化的，故需用一個整型變數top來記錄當前棧頂元素在數組中的位置。

鏈式棧為一種數據存儲結構，可以通過單鏈表的方式來實現，使用鏈式棧的優點在於它能夠克服用數組實現的順序棧空間利用率不高的特點，但是需要為每個棧元素分配額外的指針空間用來存放指針域。

(4)棧的順序存儲結構擴展閱讀

棧作為一種數據結構，為一種只能在一端進行插入和刪除操作的特殊線性表。它按照先進後出的原則存儲數據，先進入的數據被壓入棧底，最後的數據在棧頂，需要讀數據的時候從棧頂開始彈出數據（最後一個數據被第一個讀出來）。棧具有記憶作用，對棧的插入與刪除操作中，不需要改變棧底指針。

在計算機系統中，棧為一個具有以上屬性的動態內存區域。程序可以將數據壓入棧中，也可以將數據從棧頂彈出。在i386機器中，棧頂由稱為esp的寄存器進行定位。壓棧的操作使得棧頂的地址減小，彈出的操作使得棧頂的地址增大。

5. 棧的順序存儲結構

這是結果，需要的話給我個郵箱
/*
在vc++6.0中的輸出結果：
------------------------
初始化棧.....
創建一個包含5個不大於100的正整數值的棧（5個值由計算機隨機產生）...
棧中的元素從棧底到棧頂為：41 67 34 0 69
請輸入要插在棧頂的元素e = 100
棧中的元素從棧底到棧頂為：41 67 34 0 69 100
彈出的棧頂元素 e = 100
棧中的元素從棧底到棧頂為：41 67 34 0 69
棧中元素個數是5
輸出從棧頂到棧底的所有元素：69 0 34 67 41
Press any key to continue
------------------------------
*/

6. 分別就棧的順序存儲結構和鏈式存儲結構實現棧的各種基本操作。

順序存儲結構

#include<iostream>
typedef char ElemType;
#define MaxSize 100
using namespace std;
typedef struct
{
ElemType data[MaxSize];
int top;
}sqStack;
void InitStack(sqStack *&s);//初始化棧
void ClearStack(sqStack *&s);//摧毀棧
int StackLength(sqStack *s);//返回棧的長度
bool StackEmpty(sqStack *s);//判斷棧是否為空
int Push(sqStack *&s,ElemType e);//進棧
int Pop(sqStack *&s,ElemType &e);//出棧
int GetTop(sqStack *s,ElemType &e);//取棧頂元素
void DispStack(sqStack *s);//顯示棧中元素值
int main()
{

return 0;
}

void InitStack(sqStack *&s)//初始化棧
{
s=new sqStack;
s->top=-1;
}
void ClearStack(sqStack *&s)//摧毀棧
{
delete s;
}

int StackLength(sqStack *s)//返回棧的長度
{
return (s->top+1);
}

bool StackEmpty(sqStack *s)//判斷棧是否為空
{
return (s->top==-1);
}

int Push(sqStack *&s,ElemType e)//進棧
{
if(s->top==MaxSize-1)
return 0;
s->top++;
s->data[s->top]=e;
return 1;
}

int Pop(sqStack *&s,ElemType &e)//出棧
{
if(s->top==-1)
return 0;
e=s->data[s->top];
s->top--;
return 1;

}

int GetTop(sqStack *s,ElemType &e)//取棧頂元素
{
if(s->top==-1)
return 0;
e=s->data[s->top];
return 1;
}

void DispStack(sqStack *s)//顯示棧中元素值
{
for(int i=s->top;i>=0;i--)
cout<<s->data[i]<<" ";
cout<<endl;
}

鏈式存儲結構

typedef char ElemType;

typedef struct linknode
{
ElemType data;
struct linknode *next;
}LiStack;
void InitStack(LiStack *&s);//初始化棧
void ClearStack(LiStack *&s);//摧毀棧
int StackLength(LiStack *s);//返回棧的長度
bool StackEmpty(LiStack *s);//判斷棧是否為空
void Push(LiStack *&s,ElemType e);//進棧
int Pop(LiStack *&s,ElemType &e);//出棧
int GetTop(LiStack *s,ElemType &e);//取棧頂元素
void DispStack(LiStack *s);//顯示棧中元素值

int main()
{
return 0;
}

void InitStack(LiStack *&s)//初始化棧
{
s=new LiStack;
s->next=NULL;
}

void ClearStack(LiStack *&s)//摧毀棧
{
for(LiStack *p=s->next;p;p=p->next)
{
delete s;
s=p;
p=p->next;
}
delete s;
}

int StackLength(LiStack *s)//返回棧的長度
{
int i=0;
for(LiStack *p=s->next;p;p=p->next)
i++;
return i;
}

bool StackEmpty(LiStack *s)//判斷棧是否為空
{
return (s->next==NULL);
}

void Push(LiStack *&s,ElemType e)//進棧
{
LiStack *p=new LiStack;
p->data=e;
p->next=s->next;
s->next=p;
}

int Pop(LiStack *&s,ElemType &e)//出棧
{
LiStack *p;
if(s->next==NULL)
return 0;
p=s->next;
e=p->data;
s->next=p->next;
delete p;
return 1;

}
int GetTop(LiStack *s,ElemType &e)//取棧頂元素
{
if(s->next==NULL)
return 0;
e=s->next->data;
return 1;
}
void DispStack(LiStack *s)//顯示棧中元素值
{
LiStack *p=s->next;
for(;p;p=p->next)
cout<<p->data<<" ";
cout<<endl;

}

7. 簡述棧和隊列的順序存儲結構和鏈式存儲結構的優缺點

順序存儲結構是在內存中開辟一個連續的空間用來存儲數據,因此對於內存的需求和苛刻,必須是連續的空間.在數據查找(特別是不按照規律排列的數據),時間復雜度教少.效率高.
鏈式存儲結構是採取連表指針來指示數據的存儲位置,這就可以是在內存中隨意的存儲,沒有必須連續儲存空間的要求,對於內存的要求相對教容易.但是要是是從小到大順序排列的數據,鏈式存儲結構的時間復雜度教小,效率高.但是要是不規則排布的數據一般時間復雜度較高,效率更低

8. 棧的入棧和出棧的順序規律是什麼

入棧的順序規律是排在前面的先進，排在後面的後進。

棧中的數據只有一種方式出棧，即先進後出，所以出棧的可能數目跟入棧的可能排列數目是一致的。a的出入有2中可能，b的出入有2種可能，c的出入有2種可能，d只需要關系入，只有一種可能。所以可能的出棧方式數為2*2*2*1=8種。

入棧順序：a、b、c、d。出棧順序可以是：d、c、b、a；a、b、c、d;b、a、c、d很多，但要把棧想像成一個沒蓋子的紙箱，取出東西時只能從最上層取，放進東西也只能放在最上層，所以棧是一個「後進先出」或「先進後出」的順序存儲結構。

相關介紹：

棧又名堆棧，它是一種運算受限的線性表。限定僅在表尾進行插入和刪除操作的線性表。這一端被稱為棧頂，相對地，把另一端稱為棧底。

向一個棧插入新元素又稱作進棧、入棧或壓棧，它是把新元素放到棧頂元素的上面，使之成為新的棧頂元素；從一個棧刪除元素又稱作出棧或退棧，它是把棧頂元素刪除掉，使其相鄰的元素成為新的棧頂元素。

9. 數據結構中什麼叫做順序棧

順序棧

棧的順序存儲結構簡稱為順序棧,它是運算受限的順序表。
1、
順序棧的類型定義

#define
StackSize
100
//假定預分配的棧空間最多為100個元素

typedef
char
DataType;//假定棧元素的數據類型為字元

typedef
struct{

DataType
data[StackSize];

int
top;

}SeqStack;

注意：
①順序棧中元素用向量存放

②棧底位置是固定不變的，可設置在向量兩端的任意一個端點

③棧頂位置是隨著進棧和退棧操作而變化的，用一個整型量top（通常稱top為棧頂指針）來指示當前棧頂位置
2、
順序棧的基本操作

前提條件：

設S是SeqStack類型的指針變數。若棧底位置在向量的低端，即S-＞data[0]是棧底元素。
（1）
進棧操作

進棧時，需要將S-＞top加1

注意：

①S-＞top==StackSize-1表示棧滿
②"
上溢
"現象--當棧滿時，再做進棧運算產生空間溢出的現象。

上溢是一種出錯狀態，應設法避免。
（2）
退棧操作

退棧時，需將S-＞top減1

注意：
①S-＞top<0表示空棧

②"
下溢
"現象——當棧空時，做退棧運算產生的溢出現象。

下溢是正常現象，常用作程序控制轉移的條件。
順序棧在進棧和退棧操作時的具體變化情況【參見動畫演示】
3、順序棧的基本運算
（1）
置棧空

void
InitStack（SeqStack
*S）

{//將順序棧置空

S->top=-1;

}
（2）
判棧空

int
StackEmpty（SeqStack
*S）

{

return
S->top==-1;

}
（3）
判棧滿

int
StackFull（SeqStack
*SS）

{

return
S->top==StackSize-1;

}
（4）
進棧

void
Push（S，x）

{

if
(StackFull(S))

Error("Stack
overflow");
//上溢，退出運行

S->data[++S->top]=x;//棧頂指針加1後將x入棧

}
（5）
退棧

DataType
Pop（S）

{

if(StackEmpty(S))

Error("Stack
underflow");
//下溢，退出運行

return
S->data[S->top--];//棧頂元素返回後將棧頂指針減1

}
（6）
取棧頂元素

DataType
StackTop（S）

{

if(StackEmpty(S))

Error("Stack
is
empty");

return
S->data[S->top];

}
4、兩個棧共享同一存儲空間

當程序中同時使用兩個棧時，可以將兩個棧的棧底設在向量空間的兩端，讓兩個棧各自向中間延伸。當一個棧里的元素較多，超過向量空間的一半時，只要另一個棧的元素不多，那麼前者就可以佔用後者的部分存儲空間。

只有當整個向量空間被兩個棧占滿（即兩個棧頂相遇）時，才會發生上溢。因此，兩個棧共享一個長度為m的向量空間和兩個棧分別佔用兩個長度為 └ m/2┘和┌m/2┐的向量空間比較，前者發生上溢的概率比後者要小得多。

10. 什麼是順序棧

舉一個例子吧。入棧順序：a、b、c、d
出棧順序可以是：d、c、b、a;a、b、c、d;b、a、c、d很多啦，
但要把棧想像成一個沒蓋子的紙箱，取出東西時只能從最上層取，放進東西也只能放在最上層，所以棧是一個「後進先出」或「先進後出」的順序存儲結構。