数据结构 栈的概念的基本操作

---------------start reading---------------

前言

栈是一种特殊的结构，遵循先进后出的原则，若我们输入12345，则会输出54321

栈的示意图

如何实现栈的功能呢？
栈的基本操作只有出栈入栈两种操作，没有像链表一样的有头插，尾插的操作。
所以栈只要理解原理，基本的操作都比较简单。

下面用链式结构和顺序结构来实现栈的基本操作。一点要理解 top指针的移动方法。

头文件

链栈

#pragma once
//链式队列

typedef struct LNode
{
	int data;
	struct LNode *next;
}LNode,*PLNode;//数据的存放

typedef struct headstack
{
	LNode *top;
}headstack,*LStack;//定义栈，保存top头指针

void InitStack(LStack ps);


//入栈
bool Push(LStack ps,int val);

//获取栈顶元素的值，但不删除栈顶元素
bool GetTop(LStack ps,int *rtval);

//获取栈顶元素的值，且删除栈顶元素
bool Pop(LStack ps,int *rtval);

bool IsEmpty(LStack ps);

void Destroy(LStack ps);

顺序栈

#pragma once
//顺序栈

#define INITSIZE 10

typedef struct SeqStack
{
	int *elem;
	int top;//栈顶指针,类似顺序表中的有效数据个数
	int stacksize;//栈容量
}SeqStack,*PSeqStack;

void InitStack(PSeqStack ps);

//入栈
bool Push(PSeqStack ps,int val);

//获取栈顶元素的值，但不删除栈顶元素
bool GetTop(PSeqStack ps,int *rtval);

//获取栈顶元素的值，且删除栈顶元素
bool Pop(PSeqStack ps,int *rtval);

bool IsEmpty(PSeqStack ps);

void Destroy(PSeqStack ps);

具体操作如(源文件)
链栈

#include <stdio.h>
#include<assert.h>
#include<stdlib.h>
#include"lstack.h"


void InitStack(LStack ps)
{
	assert(ps!=NULL);

	ps->top=NULL;
}

//入栈
bool Push(LStack ps,int val)
{
	assert(ps!=NULL);

    LNode *p = (LNode *)malloc(sizeof(LNode));//分配新结点空间

	p->data = val;//存放数据
	p->next = ps->top;//top与p结点相连
	ps->top = p;//top指针后移
}

//获取栈顶元素的值，但不删除栈顶元素
bool GetTop(LStack ps,int *rtval)
{
	assert(ps!=NULL);
	if(IsEmpty(ps));
	{
		return false;
	}
	*rtval=ps->top->data;
	return true;
}

//获取栈顶元素的值，且删除栈顶元素
bool Pop(LStack ps,int *rtval)
{
	assert(ps!=NULL);
	GetTop(ps,rtval);
	LNode*p=ps->top;//保存尾结点
	ps->top=p->next;
    free(p);
}

bool IsEmpty(LStack ps)
{
	if(ps->top==NULL)
	{
		return true;
	}
	else
	{
		return false;
	}
}

void Destroy(LStack ps)
{
	while (ps->top!=NULL)
	{
		LNode*p=ps->top;
		ps->top=p->next;
		free(p);
	}
}

顺序栈

#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include "stack.h"

void InitStack(PSeqStack ps)
{
	assert(ps != NULL);
	ps->elem = (int *)malloc(sizeof(int)*INITSIZE);
	ps->top = 0;
	ps->stacksize = INITSIZE;
}

static bool IsFull(PSeqStack ps)
{
	return ps->top == ps->stacksize;
}

//入栈
bool Push(PSeqStack ps,int val)//O(1)
{
	if(IsFull(ps))//扩容
	{
		ps->elem = (int *)realloc(ps->elem,ps->stacksize*2*sizeof(int));
		ps->stacksize *= 2;
	}

	ps->elem[ps->top++] = val;
	//ps->top++;
	return true;
}

//获取栈顶元素的值，但不删除栈顶元素
bool GetTop(PSeqStack ps,int *rtval)
{
	if(IsEmpty(ps))
	{
		return false;
	}

	*rtval = ps->elem[ps->top-1];

	return true;
}

//获取栈顶元素的值，且删除栈顶元素
bool Pop(PSeqStack ps,int *rtval)//O(1)
{
	if(IsEmpty(ps))
	{
		return false;
	}

	*rtval = ps->elem[--ps->top];
	//ps->top--;
	return true;
}

bool IsEmpty(PSeqStack ps)
{
	return ps->top == 0;
}

void Destroy(PSeqStack ps)
{
	free(ps->elem);
	ps->elem = NULL;
	ps->top = 0;
	ps->stacksize = 0;
}

------------------end-------------------------