数据结构栈

栈是一种先进后出的结构,只允许在一端进行插入和删除元素

数据结构_栈

头文件

#define _CRT_SECURE_NO_WARNINGS 1
#include<malloc.h>
#include<stdio.h>
#define MAXSIZE 100
typedef int STypeElem;

栈的存储结构

/*栈(stack)*/
typedef struct
{
	STypeElem data[MAXSIZE];
	int top;   //栈顶指针

}SqStack;

初始化栈

/*初始化栈*/
void InitStack(SqStack * q)
{
	//q = (SqStack *)malloc(sizeof(SqStack));
	q->top = -1;
}

销毁栈

/*销毁栈*/
void DestroyStack(SqStack * q)
{
	free(q);
	q = NULL;
}

压栈

/*压栈*/
void Push(SqStack * q)
{
	if (q->top == MAXSIZE - 1)
	{
		printf("栈满了\n");
		return;
	}
	printf("请输入: \n");
	scanf("%d", &q->data[++q->top]);

}

弹栈

/*弹栈*/
void Pop(SqStack * q)
{
	if (q->top == -1)
	{
		printf("栈为空\n");
		return;
	}
	printf("要弹栈的元素为: %d\n", q->data[q->top--]);
}

栈是否为空

/*判断栈是否为空 空 true 不空 false*/
bool StackEmpty(SqStack q)
{
	return q.top == -1 ? true : false;
}

栈的长度

/*栈的长度*/
int StackLength(SqStack q)
{
	return q.top + 1;
}

栈顶元素

/*栈顶元素*/
 STypeElem StackTop(SqStack q)
{
	return q.data[q.top];
}

栈的遍历

/*栈的遍历*/
void StackPrint(SqStack q)
{
	while (!StackEmpty(q))
	{
		printf("%d ", q.data[q.top--]);
	}
}

测试

//test stack
	SqStack s;
	InitStack(&s);
	for (int i = 0; i < 5; i++)
	{
		Push(&s);
	}
	StackPrint(s);
	printf("栈顶元素: %d\n", StackTop(s));
	printf("栈长: %d\n", StackLength(s));

	Pop(&s);
	StackPrint(s);
	printf("栈顶元素: %d\n", StackTop(s));
	printf("栈长: %d\n", StackLength(s));

共享栈

头文件

#define _CRT_SECURE_NO_WARNINGS 1
#include<malloc.h>
#include<stdio.h>
#define MAXSIZE 100
typedef int SElemType;

共享栈的结构

/*共享栈结构*/
typedef struct
{
	SElemType data[MAXSIZE];
	int top1;   //栈1的栈顶指针
	int top2;   //栈2的栈顶指针

}SqDoubleStack;

共享站的初始化

/*初始化栈*/
void InitDoubleStack(SqDoubleStack * s)
{
	s->top1 = -1;
	s->top2 = MAXSIZE;
}

共享栈的压栈

/*压栈*/
void Push(SqDoubleStack * s, int stackNumber)
{
	if (s->top1 + 1 == s->top2)
	{
		printf("栈满\n");
		return;
	}
	printf("请输入: \n");
	if (stackNumber == 1)
	{
		scanf("%d", &s->data[++s->top1]);
	}
	else
	{
		scanf("%d", &s->data[--s->top2]);
	}
}

共享栈的弹栈

/*弹栈*/
void Pop(SqDoubleStack * s, int stackNumber)
{
	if (stackNumber == 1)
	{
		if (s->top1 == -1)
		{
			printf("栈为空\n");
			return;
		}
		printf("要弹栈的元素为: %d\n", s->data[s->top1--]);
	}
	else
	{
		if (s->top2 == MAXSIZE)
		{
			printf("栈为空\n");
			return;
		}
		printf("要弹栈的元素为: %d\n", s->data[s->top2++]);

	}
}

共享栈的遍历

/*共享栈的遍历*/
void DoubleStackPrint(SqDoubleStack s, int stackNumber)
{
	if (stackNumber == 1)
	{
		printf("栈1的遍历\n");
		while (s.top1 != -1)
		{
			printf("%d ", s.data[s.top1--]);
		}
		printf("\n");
	}
	else
	{
		printf("栈2的遍历\n");
		while (s.top2 != MAXSIZE)
		{
			printf("%d ", s.data[s.top2++]);
		}
		printf("\n");
	}
}

链栈

头文件

#define _CRT_SECURE_NO_WARNINGS 1
#include<malloc.h>
#include<stdio.h>
#define MAXSIZE 100
typedef int SElemType;

链栈的结构

/*链栈*/
typedef struct StackNode
{
	SElemType data;
	struct StackNode * next;
}StackNode, *LinkStackPtr;

链栈的初始化

/*初始化栈*/
void InitLinkStack(LinkStack * L)
{
	L->top = (LinkStackPtr)malloc(sizeof(StackNode));
	L->count = 0;
	L->top = NULL;//栈为空
}

链栈的压栈

/*压栈*/
void Push(LinkStack * L)
{
	LinkStackPtr s = (LinkStackPtr)malloc(sizeof(StackNode));
	printf("请输入: \n");
	scanf("%d", &s->data);
	
	s->next = L->top;
	L->top = s;

	L->count++;
}

链栈干的出栈

/*弹栈*/
void Pop(LinkStack * L)
{
	if (StackEmpty(*L))
	{
		printf("栈为空\n");
		return;
	}
	printf("出栈的元素为: %d\n", L->top->data);

	LinkStackPtr p = L->top;
	L->top = L->top->next;

	free(p);
	L->count--;

}

链栈是否为空

/*判断栈是否为空*/
bool StackEmpty(LinkStack L)
{
	return L.top == NULL ? true : false;
}

链栈的遍历

/*遍历栈*/
void LinkStackPrint(LinkStack  L)
{
	LinkStackPtr p = L.top;
	while (p)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}