⑴ 數據結構中什麼叫做順序棧
順序棧
棧的順序存儲結構簡稱為順序棧,它是運算受限的順序表。
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┐的向量空間比較，前者發生上溢的概率比後者要小得多。
⑵ 棧的入棧順序和出棧順序的各種可能
棧中的數據只有一種方式出棧，即先進後出，所以出棧的可能數目跟入棧的可能排列數目是一致的。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]為最後入棧的元素，即為棧頂元素。
⑶ 棧的順序存儲空間s(1:m)是什麼意思
根據題意，棧空間如圖所示：
也就是說，棧是向上增長的，每次壓入一個元素，棧的TOP指針向上移動一位。
當壓入第一個元素時，TOP指針指向m+1-1 = m
當壓入第二個元素時，TOP指針指向m+1-2 = m-1
......
以此類推，
當壓入第N個元素時，TOP指針指向m+1-N = 20
則N = m+1-20 = m-19
選C。
⑷ 棧只能順序存儲，這句話對嗎，為什麼
棧只能順序存儲，這句話不對。棧作為一種數據結構，是一種只能在一端進行插入和刪除操作的特殊線性表。允許進行插入和刪除操作的一端稱為棧頂(top)，另一端為棧底(bottom)。
一個新元素只能從棧頂一端進入，刪除時，只能刪除棧頂的元素，即剛剛被插入的元素。所以棧也稱為後進先出表。線性表可以順序存儲，也可以鏈式存儲，因此棧也可以採用鏈式存儲結構。
(4)棧中順序存儲擴展閱讀：
棧是允許在同一端進行插入和刪除操作的特殊線性表。允許進行插入和刪除操作的一端稱為棧頂(top)，另一端為棧底(bottom)；棧底固定，而棧頂浮動；棧中元素個數為零時稱為空棧。插入一般稱為進棧（PUSH），刪除則稱為退棧（POP）。棧也稱為後進先出表。
在計算機系統中，棧則是一個具有以上屬性的動態內存區域。程序可以將數據壓入棧中，也可以將數據從棧頂彈出。在i386機器中，棧頂由稱為esp的寄存器進行定位。壓棧的操作使得棧頂的地址減小，彈出的操作使得棧頂的地址增大。
棧在程序的運行中有著舉足輕重的作用。最重要的是棧保存了一個函數調用時所需要的維護信息，這常常稱之為堆棧幀或者活動記錄。堆棧幀一般包含如下幾方面的信息：
1、函數的返回地址和參數。
2、臨時變數：包括函數的非靜態局部變數以及編譯器自動生成的其他臨時變數。
鏈式存儲結構的特點：
1、比順序存儲結構的存儲密度小(鏈式存儲結構中每個結點都由數據域與指針域兩部分組成，相比順序存儲結構增加了存儲空間)。
2、邏輯上相鄰的節點物理上不必相鄰。
3、插入、刪除靈活 (不必移動節點，只要改變節點中的指針)。
4、查找節點時鏈式存儲要比順序存儲慢。
5、每個節點是由數據域和指針域組成。
6、由於簇是隨機分配的，這也使數據刪除後覆蓋幾率降低，恢復可能提高。
順序存儲結構的主要優點是節省存儲空間，因為分配給數據的存儲單元全用存放結點的數據（不考慮c/c++語言中數組需指定大小的情況），結點之間的邏輯關系沒有佔用額外的存儲空間。
採用這種方法時，可實現對結點的隨機存取，即每一個結點對應一個序號，由該序號可以直接計算出來結點的存儲地址。但順序存儲方法的主要缺點是不便於修改，對結點的插入、刪除運算時，可能要移動一系列的結點。
參考資料：網路-棧
參考資料：網路-鏈式存儲結構
參考資料：網路-順序存儲結構
⑸ 用棧的順序存儲結構實現棧的各種基本操作
一、順序棧
棧的順序存儲結構簡稱為順序棧，它是運算受限的順序表。因此，可用數組來實現順序棧。
因為棧底位置是固定不變的，所以可以將棧底位置設置在數組的兩端的任何一個端點；
棧頂位置是隨著進棧和退棧操作而變化的.
棧的順序存儲表示 — 順序棧
#include <assert.h>
template <class Type> class Stack {
private:
int top; //棧頂數組指針
Type *elements; //棧數組
int maxSize; //棧最大容量
public:
Stack ( int=10 ); //構造函數
~Stack ( ) {
delete[ ] elements;
}//析構函數
void Push ( const Type & item ); //入棧
Type Pop ( ); //出棧
Type GetTop ( ); //取棧頂元素
void MakeEmpty ( ) { top=-1; } //置空棧
int IsEmpty ( ) const {
return top == -1;
}
int IsFull ( ) const{
return top == maxSize-1;
}
}
void Push ( const Type & item ); //入棧
Type Pop ( ); //出棧
Type GetTop ( ); //取棧頂元素
void MakeEmpty ( ) { top=-1; } //置空棧
int IsEmpty ( ) const {
return top == -1;
}
int IsFull ( ) const {
return top == maxSize-1;
}
}
構造函數
template <class Type> Stack<Type>::
Stack ( int s ) : top (-1), maxSize (s) {
elements = new Type[maxSize];
}
template <class Type> void Stack<Type>::
Push ( const Type & item ) {
assert ( !IsFull ( ) );或//先決條件斷言
if(top != maxSize-1 )
elements[++top] = item; //加入新元素
}
template <class Type> Type Stack<Type>:: Pop ( ) {
assert ( !IsEmpty ( ) ); //先決條件斷言
return elements[top--]; //退出棧頂元素
}
template <class Type> Type stack<Type>::
GetTop ( ) {
assert ( !IsEmpty ( ) ); //先決條件斷言
return elements[top]; //取出棧頂元素
}
⑹ 棧的順序存儲結構
這是結果，需要的話給我個郵箱
/*
在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
------------------------------
*/
⑺ 棧的順序存儲和鏈表存儲的差異
順序存儲： 線性表的順序表：指的是用一組地址連續的存儲單元，依次存儲線性表的數據元素。
線性表的順序存儲結構具備如下兩個基本特徵： 1、線性表中的所有元素所佔的存儲空間是連續的（即要求內存中可用存儲單元的地址必須是連續的）。 2、線性表中各數據元素在存儲空間中是按邏輯順序依次存放的。 即：線性表邏輯上相鄰、物理也相鄰（邏輯與物理統一：相鄰數據元素的存放地址也相鄰），則已知第一個元素首地址和每個元素所佔位元組數，則可求出任一個元素首地址。 優點： 1、
無須為表示結點間的邏輯關系而增加額外的存儲空間。
2、
可以方便的隨機存取表中的任一結點。
3、
存儲密度大（＝1），存儲空間利用率高。 缺點： 1、
插入和刪除運算不方便，需移動大量元素。 2、
由於要求佔用連續的存儲空間，存儲分配只能按最大存儲空間預先進行，致使存儲空間不能得到充分利用。
3、
表的容量難以擴充。 鏈表存儲： 線性表的鏈式存儲：指用一組任意的存儲單元存儲線性表中的數據元素。
線性表的鏈式存儲結構具備的基本特徵： 鏈式存儲時，相鄰數據元素可隨意存放，但所佔存儲空間分兩部分，一部分存放結點值，另一部分存放表示結點間關系的指針。 優點： 1、
插入、刪除操作很方便，可通過修改結點的指針實現，無須移動元素。
2、
方便擴充存儲空間。
缺點： 1、
不能隨機存取元素。
2、
存儲密度小（<1），存儲空間利用率低。 總結： 1、
順序表適宜於做查找這樣的靜態操作；
鏈表宜於做插入、刪除這樣的動態操作。 2、若線性表的長度變化不大，且其主要操作是查找，則採用順序表； 若線性表的長度變化較大，且其主要操作是插入、刪除操作，則採用鏈表。
⑻ 棧的存儲結構
棧同順序表和鏈表一樣，棧也是用來存儲邏輯關系為 "一對一" 數據的線性存儲結構。
棧的具體實現
棧是一種 "特殊" 的線性存儲結構，因此棧的具體實現有以下兩種方式：
順序棧：採用順序存儲結構可以模擬棧存儲數據的特點，從而實現棧存儲結構；
鏈棧：採用鏈式存儲結構實現棧結構；
棧存儲結構與之前所學的線性存儲結構有所差異，這緣於棧對數據 "存" 和 "取" 的過程有特殊的要求：
棧只能從表的一端存取數據，另一端是封閉的；
在棧中，無論是存數據還是取數據，都必須遵循"先進後出"的原則，即最先進棧的元素最後出棧。
通常，棧的開口端被稱為棧頂；相應地，封口端被稱為棧底。因此，棧頂元素指的就是距離棧頂最近的元素。
⑼ 定義棧的順序存儲結構表達式求值
include
#include
#include //判斷是否為字元的函數的頭文件
#define maxsize 100
typedef int elemtype;
typedef struct sqstack sqstack;//由於sqstack不是一個類型 而struct sqstack才是
char ch[7]=;//把符號轉換成一個字元數組
int f1[7]=;//棧內元素優先順序
int f2[7]=;//棧外的元素優先順序
struct sqstack
{
elemtype stack[maxsize];
int top;
};
void Initstack(sqstack *s)
{
s->top=0;
}
void Push(sqstack *s,elemtype x)
{
if(s->top==maxsize-1)
printf("Overflow\n");
else
{
s->top++;
s->stack[s->top]=x;
}
}
void Pop(sqstack *s,elemtype *x)
{
if(s->top==0)
printf("underflow\n");
else
{
*x=s->stack[s->top];
s->top--;
}
}
elemtype Gettop(sqstack s)
{
if(s.top==0)
{
printf("underflow\n");
return 0;
}
else
return s.stack[s.top];
}
elemtype f(char c)
{
switch(c)
{
case '+':
return 0;
case '-':
return 1;
case '*':
return 2;
case '/':
return 3;
case '(':
return 4;
case ')':
return 5;
default:
return 6;
}
}
char precede(char c1,char c2)
{
int i1=f(c1);
int i2=f(c2);//把字元變成數字
if(f1[i1]>f2[i2])//通過原來設定找到優先順序
return '>';
else if(f1[i1]<f2[i2])
return '<';
else
return '=';
}
int Operate(elemtype a,elemtype theta,elemtype b)
{
int sum;
switch(theta)
{
case 0:
sum=a+b;
break;
case 1:
sum=a-b;
break;
case 2:
sum=a*b;
break;
default:
sum=a/b;
}
return sum;
}
EvaluateExpression()
{
char c;
int i=0,sum=0;
int k=1,j=1;//設置了開關變數
elemtype x,theta,a,b;
sqstack OPTR,OPND;
Initstack(&OPTR);
Push(&OPTR,f('#'));//0壓入棧
Initstack(&OPND);
c=getchar();
if(c==ch[2]||c==ch[3]||c==ch[5]||c==ch[6])//先對＋和-的情況忽略和左括弧的情況
{
printf("錯誤1 \n");
k=0;
return 0;
}
if(c==ch[0])
c=getchar();//如果是＋，把它覆蓋
if(c==ch[1])
{
j=0;
c=getchar();//也把－號覆蓋
}
while(c!='#'||ch[Gettop(OPTR)]!='#')
{
if(isdigit(c))
{
sum=0;
while(isdigit(c))
{
if(!j)
{
sum=sum*10-(c-'0');//實現了數字串前面有負號（之前是：sum=-(sum*10)-(c-'0')結果是－12＋13＝21）
}
else
sum=sum*10+(c-'0');
c=getchar();
}
Push(&OPND,sum);//如果還是數字先不壓棧，把數字串轉化成十進制數字再壓棧
j=1;
}
else
if(k)
{
switch(precede(ch[Gettop(OPTR)],c))
{
case'<': Push(&OPTR,f(c));//把它們整型化
c=getchar();
if(c==ch[0]||c==ch[1]||c==ch[2]||c==ch[3]||c==ch[5]||c=='\n')//要除去下個是『（』的情況 也把以運算符歸到這里來
{
printf("出錯2\n");
k=0;
return 0;//加了開關變數和返回0的值使程序更以操作
}
break;
case'=': Pop(&OPTR,&x);
c=getchar();
if(c==ch[0]||c==ch[1]||c==ch[2]||c==ch[3]||c==ch[5]||c=='\n')//把ch[6]的情況也忽略了但此時並沒有注意到右括弧後面右運算符的情況
{
printf("出錯2\n");
k=0;
return 0;
}
break;
case'>': Pop(&OPTR,&theta);
Pop(&OPND,&b);
Pop(&OPND,&a);//注意這里是誰先出棧
Push(&OPND,Operate(a,theta,b));
break;
}
}
}//在這里判斷是否以運算符結束是不對的
return(Gettop(OPND));
}
main()
{
int result;
printf("輸入你的算術表達式：\n");
result=EvaluateExpression();
printf("結果是 :%d\n",result);
return 0;
}
:
本計算器利用堆棧來實現。
1、定義後綴式計算器的堆棧結構
因為需要存儲的單元不多，這里使用順序棧，即用一維數組來模擬堆棧：
#define MAX 100
int stack[MAX];
int top=0;
因此程序中定義了長度為MAX的一維數組，這里MAX用宏定義為常數100，我們可以修改宏定義而重新定義堆棧的大小。
整型數據top為棧頂指示，由於程序開始時堆棧中並無任何數據元素，因此top被初始化為0。
2、存儲後綴式計算器的運算數
我們定義了堆棧stack[MAX]後，就可以利用入棧操作存儲先後輸入的兩個運算數。
下面看一下是如何實現的：
int push(int i) /*存儲運算數，入棧操作*/
{
if(top<MAX)
{
stack[++top]=i; /*堆棧仍有空間，棧頂指示上移一個位置*/
return 0;
}
else /*堆棧已滿，給出錯誤信息，返回出錯指示*/
{
printf("The stack is full");
return ERR;
}
}
我們在調用函數push時，如果它的返回值為0，說明入棧操作成功；否則，若返回值為ERR(在程序中說明為-1)，說明入棧操作失敗。
3、從堆棧中取出運算數
當程序中讀完了四則運算符後，我們就可以從堆棧中取出已經存入的兩個運算數，構成表達式，計算出結果。取出運算數的函數採用的正是出棧演算法。在本例中，實現該演算法的函數 為pop():
int pop(); /*取出運算數，出棧操作*/
{
int var; /*定義待返回的棧頂元素*/
if(top!=NULL) /*堆棧中仍有數據元素*/
{
var=stack[top--]; /*堆棧指示下移一個位置*/
return var;
}
else /*堆棧為空，給出錯誤信息，並返回出錯返回值*/
printf("The stack is cmpty!\n");
return ERR;
}
同樣，如果堆棧不為空，pop()函數返回堆棧頂端的數據元素，否則，給出棧空提示，並返回錯誤返回值ERR。
4、設計完整的後綴式計算器
有了堆棧存儲運算數，後綴式計算器的設計就很簡單了。程序首先提示用戶輸入第一個運算數，調用push()函數存入堆棧中；而後提示用戶輸入第二個運算數，同樣調用push()函數存入堆棧中。接下來，程序提示用戶輸入+,-,*,/四種運算符的一種，程序通過switch_case結構判斷輸入運算符的種類，轉而執行不同的處理代碼。以除法為例，說明程序的執行流程：
case '/':
b=pop();
a=pop();
c=a/b;
printf("\n\nThe result is %d\n",c);
printf("\n");
break;
程序判斷用戶輸入的是除號後，就執行上述代碼。首先接連兩次調用pop()函數從堆棧中讀出先前輸入的運算數，存入整型數a和b中；然後執行除法運算，結果存入單元c中。這時需要考慮究竟誰是被除數，誰是除數。由於開始我們先將被除數入棧，根據堆棧「先進後出」的原則，被除數應該是第二次調用pop()函數得到的返回值。而除數則是第一次調用pop()函數得到的返回值。
最後程序列印出運算結果，並示提示用戶是否繼續運行程序：
printf("\t Continue?(y/n):");
l=getche();
if(l=='n')
exit(0);
如果用戶回答是"n"，那麼結束程序，否則繼續循環。
完整的程序代碼如下：
#include
#include
#include
#define ERR -1
#define MAX 100 /*定義堆棧的大小*/
int stack[MAX]; /*用一維數組定義堆棧*/
int top=0; /*定義堆棧指示*/
int push(int i) /*存儲運算數,入棧操作*/
{
if(top<MAX)
{
stack[++top]=i; /*堆棧仍有空間，棧頂指示上移一個位置*/
return 0;
}
else
{
printf("The stack is full");
return ERR;
}
}
int pop() /*取出運算數，出棧操作*/
{
int var; /*定義待返回的棧頂元素*/
if(top!=NULL) /*堆棧中仍有元素*/
{
var=stack[top--]; /*堆棧指示下移一個位置*/
return var; /*返回棧頂元素*/
}
else
printf("The stack is empty!\n");
return ERR;
}
void main()
{
int m,n;
char l;
int a,b,c;
int k;
do{
printf("\tAriothmatic Operate simulator\n"); /*給出提示信息*/
printf("\n\tPlease input first number:"); /*輸入第一個運算數*/
scanf("%d",&m);
push(m); /*第一個運算數入棧*/
printf("\n\tPlease input second number:"); /*輸入第二個運算數*/
scanf("%d",&n);
push(n); /*第二個運算數入棧*/
printf("\n\tChoose operator(+/-/*//):");
l=getche(); /*輸入運算符*/
switch(l) /*判斷運算符，轉而執行相應代碼*/
{
case '+':
b=pop();
a=pop();
c=a+b;
printf("\n\n\tThe result is %d\n",c);
printf("\n");
break;
case '-':
b=pop();
a=pop();
c=a-b;
printf("\n\n\tThe result is %d\n",c);
printf("\n");
break;
case '*':
b=pop();
a=pop();
c=a*b;
printf("\n\n\tThe result is %d\n",c);
printf("\n");
break;
case '/':
b=pop();
a=pop();
c=a/b;
printf("\n\n\tThe result is %d\n",c);
printf("\n");
break;
}
printf("\tContinue?(y/n):"); /*提示用戶是否結束程序*/
l=getche();
if(l=='n')
exit(0);
}while(1);
}
:
#include
#include
#include
#include
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
typedef int Status;
#define STACK_INIT_SIZE 100 //初始分配量
#define STACKINCREMENT 10 //存儲空間的分配增量
typedef char ElemType;
typedef ElemType OperandType; //操作數
typedef char OperatorType;
typedef struct
{
ElemType *base;
ElemType *top;
int stacksize;
}SqStack;
Status InitStack(SqStack &S)
{
//構造一個空棧S
S.base = (ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType));
if(!S.base) exit (OVERFLOW);
S.top = S.base;
S.stacksize = STACK_INIT_SIZE;
return OK;
}
Status GetTop(SqStack S){
ElemType e;
if (S.top == S.base) return ERROR;
e = *(S.top-1);
return e;
}
Status Push (SqStack &S,ElemType e)
{
//插入元素e為新的棧頂元素
if (S.top - S.base >= S.stacksize){
S.base = (ElemType *) realloc ( S.base,
(S.stacksize + STACKINCREMENT) * sizeof(ElemType));
if(!S.base) exit (OVERFLOW);
S.top = S.base + S.stacksize;
S.stacksize += STACKINCREMENT;
}
*S.top++ = e;
return OK;
}
Status Pop (SqStack &S,ElemType &e){
//若棧不空，則刪除S的棧頂元素，用e返回其值，並返回OK；否則返回ERROR
if(S.top == S.base) return ERROR;
e = * --S.top;
return OK;
}
char In(char c,char OP[])
{
if(c>=35 && c<=47)
return 1;
else return 0;
}
char OP[8]=;
int m[7][7]={1,1,2,2,2,1,1,
1,1,2,2,2,1,1,
1,1,1,1,2,1,1,
1,1,1,1,2,1,1,
2,2,2,2,2,0,-1,
1,1,1,1,-1,1,1,
2,2,2,2,2,-1,0};//1 > 2 < 0 = -1 不存在
char Precede(char i,char j)
{
int a,b; char *p;
for(p=OP,a=0;*p!='\0';p++,a++)
if(*p==i) break;
for(p=OP,b=0;*p!='\0';p++,b++)
if(*p==j) break;
if(m[a][b]==1) return '>';
else if(m[a][b]==2) return '<';
else if(m[a][b]==0) return '=';
else return 'O';
}
char Operate(char a,char theta,char b)
{
if(a>47) a=atoi(&a);
if(b>47) b=atoi(&b);
switch(theta)
{
case '+': return a+b;
break;
case '-': return a-b;
break;
case '*': return a*b;
break;
case '/': return a/b;
break;
}
}
OperandType EvaluateExpression()
{
SqStack OPTR,OPND;
OperandType a,b,c; OperatorType theta;
InitStack(OPTR); Push(OPTR,'#');
InitStack(OPND); c=getchar();
while (c!='#' || GetTop(OPTR)!='#')
{
if (!In(c,OP))
else
switch(Precede(GetTop(OPTR),c))
{
case '<' :
Push(OPTR,c); c = getchar();
break;
case '=' :
Pop(OPTR,c); c = getchar();
break;
case '>' :
Pop(OPTR,theta);
Pop(OPND,b); Pop(OPND,a);
Push(OPND,Operate(a,theta,b));
break;
}
}
return GetTop(OPND);
}
void main()
{
printf("(以#為結束符)\n");
printf("請輸入：\n");
int a;
a=(int)EvaluateExpression();
printf("%d",a);
getch();
}
:
ls都正確
:
C++ In Action這本書裡面有表達式求值的詳細項目分析.
:
數據結構的書裡面都有的,仔細看一下
:
studyall123的只能對0到9的數字運算才有效,對於10以上的數字就不行!不知道有沒有更好的方法!
:
現在的人，連google一下都懶啊
:
實際上是按照逆波蘭式的順序讓輸入的表達式入棧，再根據運算符優先順序來計算。
:
lenrning!
⑽ 棧是不是順序存儲的線性結構啊
不一定。
棧分順序棧和鏈式棧。順序棧為棧的順序實現，順序棧為利用順序存儲結構實現的棧。
採用地址連續的存儲空間（數組)依次存儲棧中數據元素，由於人棧和出棧運算都是在棧頂進行，而棧底位置是固定不變的，可以將棧底位置設置在數組空間的起始處；棧頂位置為隨入棧和出棧操作而變化的，故需用一個整型變數top來記錄當前棧頂元素在數組中的位置。
鏈式棧為一種數據存儲結構，可以通過單鏈表的方式來實現，使用鏈式棧的優點在於它能夠克服用數組實現的順序棧空間利用率不高的特點，但是需要為每個棧元素分配額外的指針空間用來存放指針域。
(10)棧中順序存儲擴展閱讀
棧作為一種數據結構，為一種只能在一端進行插入和刪除操作的特殊線性表。它按照先進後出的原則存儲數據，先進入的數據被壓入棧底，最後的數據在棧頂，需要讀數據的時候從棧頂開始彈出數據（最後一個數據被第一個讀出來）。棧具有記憶作用，對棧的插入與刪除操作中，不需要改變棧底指針。
在計算機系統中，棧為一個具有以上屬性的動態內存區域。程序可以將數據壓入棧中，也可以將數據從棧頂彈出。在i386機器中，棧頂由稱為esp的寄存器進行定位。壓棧的操作使得棧頂的地址減小，彈出的操作使得棧頂的地址增大。