栈

  • 1. 栈的概念及结构
  • 1.1 栈的概念
  • 1.2 栈的结构
  • 2. 栈的实现
  • 2.1 初始化和销毁
  • 2.1.1 初始化
  • 2.1.2 销毁
  • 2.2 获取栈中有效元素个数、判断栈空
  • 2.2.1 获取栈中有效元素个数
  • 2.2.2 判断栈空
  • 2.3 压栈、出栈
  • 2.3.1 压栈
  • 2.3.2 出栈
  • 2.4 取栈顶元素
  • 附
  • `Stack.h`
  • `Stack.c`
  • `test.c`

栈和队列的基本操作过后，依旧会更新一波题解，希望假期能把数据结构更完。

正文开始@边通书

1. 栈的概念及结构

1.1 栈的概念

栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。说白了，就是吃多了吐😓.

压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。

出栈：栈的删除操作叫做出栈/弹栈，出数据也在栈顶。


【DS】栈@栈和队列_散列表

1.2 栈的结构

栈的实现一般可以使用数组（数组栈）或者链表（链表栈）实现。理论上两者都可以，但相对而言数组栈实现更优一些。因为数组栈尾插尾删效率更高，且缓存利用率高。

单链表，更适合头插头删，如果用头作栈顶，就可以设计成单链表，可以但是不是有点怪。用尾作栈底，要设计成双向链表，否则增删数据效率低。

现在我们来实现动态数组栈。

typedef struct Stack
{
	STDataType* a;
	int top;//栈顶位置
	int capacity;
}ST;

2. 栈的实现

依旧是头文件文末贴出来，大家自己写嗷，顺序表写过了，这就很简单！在测试文件处有两处小注意，附在后边了。

2.1 初始化和销毁

2.1.1 初始化

  • 初始化top给的是0，top指向栈顶数据的下一个

【DS】栈@栈和队列_初始化_02

  • 初始化top给的是-1，top指向栈顶数据

我们采取第一种初始化方式，这是有理由的。

void StackInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->top = 0;
	//初始化时，top给-1，意味着top指向栈顶数据：先+1，再放数据
	//初始化时，top给0，意味着top指向栈顶数据的下一个：先放数据，再++
	ps->capacity = 0;
}

2.1.2 销毁

void StackDestroy(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;//有必要，不然就是野指针了
	ps->top = 0;
	ps->capacity = 0;
}

2.2 获取栈中有效元素个数、判断栈空

2.2.1 获取栈中有效元素个数

  • ps->top恰好就是栈中元素个数。
int StackSize(ST* ps)
{
	assert(ps);
	return ps->top;
}

2.2.2 判断栈空

  • 逻辑真，即为空栈。
bool StackEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}

2.3 压栈、出栈

2.3.1 压栈

【DS】栈@栈和队列_初始化_03

当ps->top == ps->capacity时，就申请空间。

void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
		int newcapacity = (ps->capacity == 0) ? 4 : 2 * ps->capacity;
		STDataType* ptr = (STDataType*)realloc(ps->a, newcapacity *sizeof(STDataType));
		if (ptr == NULL)
		{
			printf("realloc failed\n");
			exit(-1);
		}
		ps->a = ptr;
		ps->capacity = newcapacity;
	}
	ps->a[ps->top] = x;
	ps->top++;
}

2.3.2 出栈

void StackPop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));//断言，栈不为空--这样调用函数不会受到你实现方式的影响
	ps->top--;
}

2.4 取栈顶元素


STDataType StackTop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	return ps->a[ps->top - 1]; // 注意是top-1
}

附

Stack.h 

#pragma once

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;//栈顶位置
	int capacity;
}ST;

void StackInit(ST* ps);
void StackDestroy(ST* ps);

//压栈
void StackPush(ST* ps, STDataType x);
//出栈
void StackPop(ST* ps);
//取栈顶数据
STDataType StackTop(ST* ps);
//栈中数据多少？
int StackSize(ST* ps);
//判断栈是否为空
bool StackEmpty(ST* ps);

Stack.c 

#define _CRT_SECURE_NO_WARNINGS 1

#include"Stack.h"

void StackInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->top = 0;
	//初始化时,top给-1,意味着top指向栈顶数据：先+1,再放数据
	//初始化时，top给0，意味着top指向栈顶数据的下一个：先放数据，再++
	ps->capacity = 0;
}

void StackDestroy(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;//有必要，不然就是野指针了
	ps->top = 0;
	ps->capacity = 0;
}

void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
		int newcapacity = (ps->capacity == 0) ? 4 : 2 * ps->capacity;
		STDataType* ptr = (STDataType*)realloc(ps->a, newcapacity *sizeof(STDataType));
		if (ptr == NULL)
		{
			printf("realloc failed\n");
			exit(-1);
		}
		ps->a = ptr;
		ps->capacity = newcapacity;
	}
	ps->a[ps->top] = x;
	ps->top++;
}

void StackPop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));//断言，栈不为空--这样调用函数不会受到你实现方式的影响
	ps->top--;
}

int StackSize(ST* ps)
{
	assert(ps);
	return ps->top;
}

bool StackEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}

STDataType StackTop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	return ps->a[ps->top - 1]; // 注意是top - 1
}

test.c

注意：



#define _CRT_SECURE_NO_WARNINGS 1

#include"Stack.h"

//测试压栈，出栈
void testStack1()
{
	ST st;
	StackInit(&st);
	StackPush(&st, 1);
	StackPush(&st, 2);
	StackPush(&st, 3);
	StackPush(&st, 4);
	StackPush(&st, 5);

	StackPop(&st);
	/*StackPop(&st);
	StackPop(&st);
	StackPop(&st);
	StackPop(&st);
	StackPop(&st);*/

	StackDestroy(&st);
}

void testStack2()
{
	ST st;
	StackInit(&st);
	StackPush(&st, 1);
	StackPush(&st, 2);
	StackPush(&st, 3);
	StackPush(&st, 4);
	StackPush(&st, 5);
	StackPush(&st, 6);
	StackPush(&st, 7);

	printf("top:%d\n", StackTop(&st));
	StackPop(&st);

	printf("top:%d\n", StackTop(&st));
	StackPop(&st);

	printf("size:%d\n", StackSize(&st));

	//由于栈的性质，遍历栈--只能取完栈顶数据才能取下一个
	while (!StackEmpty(&st))
	{
		printf("%d ", StackTop(&st));
		StackPop(&st);
	}
	StackDestroy(&st);
}

int main()
{
	//testStack1();
	testStack2();
	return 0;
}