408 数据结构栈算法

第二章 栈

2.1顺序栈

顺序栈的基本操作

#define MAXSIZE 128
typedef int ElemType;
typedef struct {
	ElemType data[MAXSIZE];		//用数组实现对栈中元素的存取
	int top;					//栈顶指针
	int length;					//栈的长度
}SqStack;

//初始化栈
void initStack(SqStack& S);

//判断栈是否x为空，为空返回true，否则返回false
bool isEmpty(SqStack S);

//如果栈S没有满，将x入栈
bool push(SqStack& S, ElemType x);

//如果栈不为空，则将栈顶元素出栈，并返回
ElemType pop(SqStack& S);

//如果栈顶不为空，返回栈顶元素
ElemType peek(SqStack S);

//销毁栈，释放栈所占的存储空间
void destroy(SqStack& S);

顺序栈的代码实现

#define MAXSIZE 128
typedef int ElemType;
typedef struct {
	ElemType data[MAXSIZE];		//用数组实现对栈中元素的存取
	int top;					//栈顶指针
	int length;					//栈的长度
}SqStack;
//初始化栈
void initStack(SqStack& S) {
	//对申请的数组空间依次进行初始化防止不当操作出现脏数据
	for (int i = 0; i < MAXSIZE; i++) {
		S.data[i] = 0;
	}
	
	S.top = 0;	//默认栈顶指向0下标
	S.length = 0;//初始化长度为0
}

//判断栈是否x为空，为空返回true，否则返回false
bool isEmpty(SqStack S) {
	return S.length == 0;
}

//如果栈S没有满，将x入栈
bool push(SqStack& S, ElemType x) {
	//栈已满
	if (S.top >= MAXSIZE) {
		return false;
	}
	S.data[S.top++] = x;	//先赋值后移动top索引
	S.length++;				//栈长+1
}

//如果栈不为空，则将栈顶元素出栈，并由x返回
ElemType pop(SqStack& S) {
	if (isEmpty(S)) {		//规定-999为空，如果栈空返回空
		return -999;
	}
	S.length--;		//表长-1
	return S.data[--S.top];	//删除栈顶时，先将栈顶指针下移
}

//如果栈顶不为空，返回栈顶元素
ElemType peek(SqStack S) {
	if (!isEmpty(S)) {
		return S.data[S.top - 1];	//如果栈不为空，返回栈顶元素。栈顶下标-1为第一个栈顶元素
	}
	return -999;
ee
//销毁栈，释放栈所占的存储空间
void destroy(SqStack& S) {
	//销毁栈手动将数据置为0。栈顶指针指向0，表长设为0
	for (int i = 0; i < S.length; i++) {
		S.data[i] = 0;
	}
	S.top = 0;
	S.length = 0;
}

void printStack(SqStack S) {
	while (S.top > 0) {
		printf("%d ", S.data[--S.top]);
	}
	printf("\n");
}

2.2链栈

typedef int ElemType;
typedef struct LNode{
	ElemType data;
	LNode* next;
}LNode,*LinkedStack;

//初始化链栈
void initLinkedStack(LinkedStack& L) {
	L = (LNode*)malloc(sizeof(LNode));	//建立头结点
	L->next = NULL;		//头结点的next指空
	L->data = 0;		//头结点的data保存栈长度
} 

//判断栈空
bool isEmpty(LinkedStack L) {
	return L->next == NULL;		//或return L->data == 0
}

//进栈（入栈）
void push(LinkedStack& L, ElemType x) {
	LNode* node = (LNode*)malloc(sizeof(LNode));	//创建新结点
	node->data = x;	//为新结点赋值
	node->next = L->next;	//头插法插入新结点
	L->next = node;
	L->data++;	//栈长+1
}

//出栈（弹栈）
ElemType pop(LinkedStack& L) {
	if (L->next == NULL) {
		return -999;	//规定-999为空，若栈空返回空
	}
	LNode* removed = L->next;		//记录待删除元素，以便释放空间
	L->next = removed->next;	//跳过被删除元素结点，头结点直接指向被删除元素的后继
	ElemType x = removed->data;	//x接收被删除元素的值以便返回
	free(removed);		//释放被删除节点空间
	L->data--;			//表长-1
	return x;
}	

//取栈顶
ElemType peek(LinkedStack L) {
	return L->next == NULL ? -999 : L->next->data;	//如果表为空返回-999,否则返回首节点的元素值
}

//销毁栈
void destroy(LinkedStack& L) {
	LNode* p = L->next;
	LNode* tail;
	while (p) {		//依次释放栈除头结点外其他元素结点的空间
		tail = p->next;
		free(p);
		p = tail;
	}
	L->data = 0;		//栈空置为0
}

//求栈长
int length(LinkedStack L) {
	return L->data;
}

//打印栈元素
void printStack(LinkedStack L) {
	if (L == NULL||L->next == NULL) {
		return;
	}
	LNode* p = L->next;
	while (p){
 		printf("%d->", p->data);
		p = p->next;
	}
	printf("\n");
}

2.3共享栈

#define MAXSIZE 16
typedef int ElemType;
typedef struct {
	int data[MAXSIZE];	//共享栈的数据
	int size;			//共享栈的总大小
	int top1;			//第一个栈的栈顶
	int top2;			//第二个栈的栈顶
}SharedStack;

//初始化共享栈
void initStack(SharedStack& S) {
	for (int i = 0; i < MAXSIZE; i++) {
		S.data[i] = 0;
	}
	S.size = 0;		//初始化栈的总大小为0
	S.top1 = 0;		//第一个栈的栈顶指针初始化指向0
	S.top2 = MAXSIZE - 1;//第一个栈的栈顶指针初始化指向MAXSIZE-1
}
//判断第一个栈是否已满
bool isFull1(SharedStack S) {
	return S.top1 > S.top2;	//当第一个栈的栈顶超过了第二个栈的栈顶证明栈已满
}
//判断第二个栈是否已满
bool isFull2(SharedStack S) {
	return S.top2 < S.top1; //当第二个栈的栈顶小于了第一个栈的栈顶证明栈已满
}

//判断第一个栈是否为空
bool isEmpty1(SharedStack S) {
	return S.top1 == 0;
}

//判断第二个栈是否为空
bool isEmpty2(SharedStack S) {
	return S.top2 == MAXSIZE - 1;
}

// 在第一个栈中入栈元素e
void push1(SharedStack& S, ElemType e) {
	//如果栈1不满在执行添加操作，添加时先添加元素后移动栈顶指针，别忘了维持共享栈的总大小
	if (!isFull1(S)) {
		S.data[S.top1++] = e;
		S.size++;
	}
}

// 在第二个栈中入栈元素e
void push2(SharedStack& S, ElemType e) {
	if (!isFull2(S)) {
		S.data[S.top2--] = e;
		S.size++;
	}
}

// 在第一个栈中出栈
ElemType pop1(SharedStack& S) {
	//如果栈不空才执行删除操作，删除时栈顶指针先减在移除
	if (!isEmpty1(S)) {
		S.size--;
		ElemType x = S.data[--S.top1];
		S.data[S.top1] = 0;	//删除完给他置为0
		return x;
	}
	return -999;//代表空栈返回空
}

// 在第二个栈中出栈
ElemType pop2(SharedStack& S) {
	if (!isEmpty2(S)) {
		S.size--;
		ElemType x = S.data[++S.top2];
		S.data[S.top2] = 0;
		return x;
	}
	return -999;
}

// 查看第一个栈栈顶元素
ElemType peek1(SharedStack S) {
	if (!isEmpty1(S)) {
		return S.data[--S.top1];
	}
	return -999;//代表空栈返回空
}

// 查看第二个栈栈顶
ElemType peek2(SharedStack S) {
	if (!isEmpty2(S)) {
		return S.data[++S.top2];
	}
	return -999;
}

//获取第一个栈的长度
int getLength1(SharedStack S) {
	return S.top1;
}

//获取第二个栈的长度
int getLength2(SharedStack S) {
	return MAXSIZE - 1 - S.top2;
}
//打印第一个栈中的元素值
void printStack1(SharedStack S) {
	for (int i = S.top1 - 1; i >= 0; i--) {
		printf("%d ", S.data[i]);
	}
	printf("\n");
}

//打印第二个栈中的元素值
void printStack2(SharedStack S) {
	for (int i = S.top2 + 1; i < MAXSIZE; i++) {
		printf("%d ", S.data[i]);
	}
	printf("\n");
}
//打印共享栈中所有的元素值
void printStack(SharedStack S) {
	for (int i = 0; i < MAXSIZE; i++) {
		printf("%d ", S.data[i]);
	}
	printf("\n");
}