棧的鏈式存儲基本操作
❶ 棧的鏈式存儲結構--出棧操作
#include
#include
#define
elemtype
int
#define
maxsize
100
typedef
struct
stack{
elemtype
elem;
struct
stack
*next;
}stack;
//鏈式存儲的棧結構，及其相應演算法
void
initstack(stack
*top)
{//初始化空棧
top->next=null;
}
void
destroystack(stack
*top)
{//銷毀棧，將棧所佔內存空間釋放
stack
*p;
p=top->next;
while(p!=null){
top->next=p->next;
free(p);
p=top->next;
}
}
int
emptystack(stack
*top)
{//判斷是否棧空，為空則返回1，否則返回0
if(top->next==null){
return
1;
}
else{
return
0;
}
}
int
push(stack
*top,
elemtype
x)
{//元素x進棧操作，成功返回1，否則返回0
stack
*p;
p=(stack
*)malloc(sizeof(stack));
p->elem=x;
p->next=top->next;
top->next=p;
return
1;
}
elemtype
pop(stack
*top)
{//出棧操作，返回出棧元素
if(emptystack(top)){
printf("棧為空");
return
0;
}
else{
elemtype
x;
stack
*p;
p=top->next;
x=p->elem;
top->next=p->next;
free(p);
p=top->next;
return
x;
}
}
void
print(stack
*top)
{//依次輸出棧頂到棧底的所有元素
stack
*h;
h=top->next;
while(h!=null){
printf("%4d",h->elem);
h=h->next;
}
}
int
main(void)
{
stack
*top=null;
top=(stack
*)malloc(sizeof(stack));
initstack(top);
push(top,1);
push(top,2);
push(top,4);
print(top);
push(top,5);
print(top);
pop(top);
print(top);
destroystack(top);
}
❷ 實現鏈式棧的基本操作：入棧、出棧、取棧頂元素、判定棧空、棧滿。
#include<stdio.h>
#include<malloc.h>
structstack
{
intnumber;
structstack*next;
};
structstack*top;//指向棧頂
structstack*p;//臨時指針
//創建鏈棧
voidcreate(intfirst_value)
{
p=(structstack*)malloc(sizeof(structstack));//申請內存空間
p->number=first_value;//給棧底賦值
p->next=NULL;//棧底的指針為空
top=p;//棧頂指向棧底
}
//進棧
voidinput(intvalue)
{
p=(structstack*)malloc(sizeof(structstack));//申請內存空間
p->number=value;//賦值
p->next=top;//指向原來的棧頂
top=p;//棧頂往上移動一位
}
//出棧
voidoutput()
{
p=top;//p=棧頂
top=top->next;//棧頂往下移動一位
free(p);//釋放p
}
//清空棧
voidclear()
{
while(top->next!=NULL)//如果不是棧底
output();//出棧
free(top);//釋放棧頂
}
//取棧頂元素
inttopElement()
{
returntop->number;
}
intmain()
{
inti;
create(0);
for(i=1;i<=10;i++)
input(i);
//clear();
printf(" 棧的內容： ");
for(p=top;;p=p->next)
{
printf("%d ",p->number);
if(p->next==NULL)
break;
}
printf("棧頂元素=%d ",topElement());
}
❸ 棧的鏈式存儲怎麼編程啊
#include<iostream.h>
template<class T>
class link
{
public:
T date;
link<T> *next;
link(const T info, link<T> *nextvalue=NULL)
{
date=info;
next=nextvalue;
}
link(link<T> *nextvalue)
{
next=nextvalue;
}
};
template<class T>
class inkstack
{
private:
link<T> *top;
int size;
public:
inkstack();
~inkstack();
void clear();
bool push(const T item);
bool pop(T & item);
bool toop(T & item);
};
template<class T>
inkstack<T>::inkstack()
{
top=NULL;
size=0;
}
template<class T>
inkstack<T>::~inkstack()
{
clear();
}
template<class T>
void inkstack<T>::clear()
{
while(top!=NULL)
{
link<T> *tmp=top;
top=top->next;
delete top;
}
size=0;
}
template<class T>
bool inkstack<T>::push(const T item)
{
link<T> *tmp=new link<T>(item,top);
top=tmp;
size++;
return true;
}
template<class T>
bool inkstack<T>::pop(T & item)
{
link<T> *tmp;
if(size==0)
{
cout<<"棧為空，不能執行出棧操作"<<endl;
return false;
}
item=top->date;
tmp=top->next;
delete top;
top=tmp;
size--;
return true;
}
template<class T>
bool inkstack<T>::toop(T & item)
{
if(size==0)
{
cout<<"棧為空，不能執行出棧操作"<<endl;
return false;
}
item=top->date;
return true;
}
void main()
{
inkstack<int> b;
int i,a[10],c,d;
for(i=0;i<5;i++)
{
cin>>a[i];
b.push(a[i]);
}
for(i=0;i<5;i++)
{
b.pop(c);
cout<<c<<endl;
}
b.toop(c);
}
❹ 分別就棧的順序存儲結構和鏈式存儲結構實現棧的各種基本操作。
順序存儲結構
#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;
}
❺ .寫出鏈式存儲的常用操作（函數）程序
摘要 t © 1999-2020, CSDN.NET, All Rights Reserved
❻ 棧的存儲結構
棧同順序表和鏈表一樣，棧也是用來存儲邏輯關系為 "一對一" 數據的線性存儲結構。
棧的具體實現
棧是一種 "特殊" 的線性存儲結構，因此棧的具體實現有以下兩種方式：
順序棧：採用順序存儲結構可以模擬棧存儲數據的特點，從而實現棧存儲結構；
鏈棧：採用鏈式存儲結構實現棧結構；
棧存儲結構與之前所學的線性存儲結構有所差異，這緣於棧對數據 "存" 和 "取" 的過程有特殊的要求：
棧只能從表的一端存取數據，另一端是封閉的；
在棧中，無論是存數據還是取數據，都必須遵循"先進後出"的原則，即最先進棧的元素最後出棧。
通常，棧的開口端被稱為棧頂；相應地，封口端被稱為棧底。因此，棧頂元素指的就是距離棧頂最近的元素。
❼ 鏈棧如何構造，鏈棧新結點如何進棧
鏈式棧就是用鏈式存儲結構表示一個棧，也就是指針域。
根據棧的性質，知道棧是先進後出，所以只需要設置一個棧頂指針，還是說點C++吧
先構造一個結構模板
template<class
ElemType>
typedef
struct
Node
//建立
{
ElemType
data;//數據成員，用於存儲
struct
Node*next;//指針成員，用於連接邏輯結構
}LNode;
1.構造一個空棧，只需要：
LNode*head;//定義棧頂指針
head=(LNode*)malloc(sizeof(LNode));//分配空間
head->next=NULL;//下一個為空
2.新節點：比如新節點數據位1
入棧操作：
LNode*p;
p->data=1;
p->next=head;
head=p;
總之有點類似C語言里的鏈表
還有什麼不清楚的可以追問
希望對你有所幫助！！！
❽ 棧的鏈式存儲結構是什麼
若是棧中元素的數目變化范圍較大或不清楚棧元素的數目，就應該考慮使用鏈式存儲結構。人們將用鏈式存儲結構表示的棧稱作「鏈棧」。鏈棧通常用一個無頭結點的單鏈表表示。由於棧的插入、刪除操作只能在一端進行，而對於單鏈表來說，在首端插入、刪除結點要比在尾端進行相對容易一些，所以將單鏈表的首端作為棧的頂端，即將單鏈表的頭指針作為棧頂指針。鏈棧如圖1所示。
圖1鏈棧的存儲示意