数据结构学习之栈

栈

数据结构定义

表尾进行 插入 和 删除 操作的线性表

栈_顺序存储

#define StackSize 20//顺序栈的初始分配空间
typedef string ElemType;//控制栈中存的数据类型

typedef struct SqStack{
	ElemType data[MaxSize];//存放栈元素的数组
	int top;//栈顶指针
}SqStack;

创建空栈(初始化栈)

//创建空栈(初始化栈)
void Create(SeqStack &S){
	S.top = -1;
}

1.判空

//判空
int IsEmpty(SeqStack S){
	if (S.top == -1) return 1;
	else return 0;
}

2.判满

//判满
int IsFull(SeqStack S){
	if (S.top >= MaxSize - 1) return 1;
	else return 0;
}

3.入栈

//入栈
void Push(SeqStack &S, int x){
	if (IsFull(S)){return -1;}
	S.data[++S.top] = x;//x入栈
}

4.出栈

//出栈
void Pop(SeqStack &S, int &x){
	if (IsEmpty(S)){return -1;}
	x = S.data[S.top--];//栈顶元素值赋给x后出栈
}

5.输出顺序栈

//输出顺序栈
void Display(SeqStack S)
{if (IsEmpty(S)){return -1;}
	int i = S.top;//定义循环控制变量i,让i取栈顶位置
	while (i >= 0){
		 S.data[i--]};//输出栈中元素
}

主函数

//主函数
void main()
{
	SeqStack S;//定义栈
	Create(S);//创建空栈
	Push(S, 1);//入栈
	Push(S, 2);//入栈
	Display(S);
	int x;
	Pop(S, x);//出栈
	Display(S);
	Push(S, 3);//入栈
	Display(S);
}

栈_顺序存储（共享栈）

栈空：
两个栈的栈顶指针都指向栈顶元素，top0=-1时0号栈为空，top1=MaxSize时1号栈为空；

栈满：
仅当两个栈顶指针(top1-top0=1)时，判断为栈满。

进栈：
当0号栈进栈时，top0先加1，再赋值；1号栈进栈时，top1先减1，再赋值。

出栈：
当0号栈出栈时，先赋值，top0再减1；1号栈出栈时，先赋值，top1再加1。

#define MaxSize 20//顺序栈的初始分配空间
typedef string ElemType;//控制栈中存的数据类型

struct Two_way_Stack{/*双向堆栈*/ 
	ElemType data[MaxSize];
	int top0;
	int top1;
};

栈_链式存储 单向链

typedef string ElemType;//控制栈中存的数据类型

typedef struct StackNode{
	ElemType data;	//结点的数据元素
	struct StackNode *next;	//结点的指针域
}StackNode,*LinkStack;

//StackNode* （指针类型）为指向栈中某结点的指针，用该指针代表此结点
//LinkStack （指针类型）为指向栈中头结点的指针(即为头指针)

using namespace std;

//结点定义bn
struct StackNode{
	ElemType data;//数据域
	StackNode *next;//指针域
};

//链栈定义
struct LinkStack{
	Node *top;
};

创建空链栈

//创建空链栈
void Create(LinkStack &S){
	S.top = NULL;
}

1.判空

//判空
int IsEmpty(LinkStack S){
	if (S.top == NULL) return 1;
	else return 0;
}

3.判满

链表栈，没有满的情况

3.入栈

//入栈
void Push(LinkStack &S, int x){
	Node *NewNode;//新结点
	NewNode = new Node;//新结点申请内存
	NewNode->data = x;//新结点数据域赋值
	NewNode->next = NULL;//新结点指针域赋值
	if (IsEmpty(S))//如果链栈为空
		S.top = NewNode;//链栈顶指针指向新结点
	else//如果链栈非空
	{
		NewNode->next = S.top;//新结点前插入链栈
		S.top = NewNode;//更新栈顶指针
	}
}

4.出栈

//出栈
void Pop(LinkStack &S, int &x){
	if (IsEmpty(S)){
		return; //什么都不做
	}
	Node *p = S.top;//定义探测指针p并指向栈顶结点
	if (p->next == NULL)//如果链栈仅含一个结点
	{
		x = p->data;//获取栈顶结点值
		S.top = NULL;//置链栈为空
		delete p;//删除原栈顶结点
	}
	else//如果链栈中至少含有两个结点
	{
		x = p->data;//获取栈顶结点值
		S.top = S.top->next;//栈顶指针后移
		delete p;//删除原栈顶结点
	}
}

5.输出链栈

//输出链栈
void Display(LinkStack S){
	//如果链栈为空
	if (IsEmpty(S)){
		return;//什么都不做
	}
	Node *p = S.top;//定义探测指针p并指向栈顶结点
	while (p != NULL){
		p = p->next;//p后移
	}
}

main

//主程序
void main()
{
	LinkStack S;//定义栈
	Create(S);//创建空栈
	Push(S, 1);//入栈
	Push(S, 2);//入栈
	Display(S);
	int x;
	Pop(S, x);//出栈
	Display(S);
	Push(S, 3); //入栈
	Display(S);
}

栈_链式存储 双向链（共享栈）

typedef int STDataType;//数据类型

//定义各个节点
typedef struct StackNode {
    struct Stack* next;
    struct Stack* prev;
    STDataType data;
}STNode;

//定义一个栈
typedef struct Stack {
    STNode* top;
    int size;
}Stack;