栈的链式存储基本操作
❶ 栈的链式存储结构--出栈操作
#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链栈的存储示意