基础数据结构---栈

栈

stack头文件

#pragma once
//栈:后进先出,后来反而需要先服务  (访问受限的线性表)
//栈分为顺序栈,链式栈
//本文件为不定长顺序栈,能自动扩容
//栈只能在一端进行插入和删除,插入和删除的这一端称为栈顶,另一端称为栈底
//顺序栈的栈顶在尾部,因为入栈和出栈的时间复杂度都为O(1)

#define INIT_SIZE 10

typedef struct Stack
{
	int* base;//指向动态内存  
	int stackSize;//栈的总大小(总格子数)
	int top;//栈顶指针 ,实际为下标(注意书上为指针,顺序表下标更好),当前可以存放数据的下标
}Stack, * PStack;

//初始化  (C++构造函数)
void InitStack(PStack ps);

//往栈中入数据(入栈操作)
bool Push(PStack ps, int val);

//获取栈顶元素的值,但不删除
//int GetTop(PStack ps);//设计有问题
//rtval:输出参数
bool GetTop(PStack ps, int* rtval);

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

//判断栈是否为空
bool IsEmpty(PStack ps);

//获取栈有效数据的个数
int GetLength(PStack ps);


//清空所有的数据
void Clear(PStack ps);

//销毁
void Destroy(PStack ps);

stack.cpp文件

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

//初始化  (C++构造函数)
void InitStack(PStack ps)
{
	assert(ps != NULL);
	if (ps == NULL)
		return;
	ps->base = (int*)malloc(INIT_SIZE * sizeof(int));
	assert(ps->base != NULL);

	ps->top = 0;
	ps->stackSize = INIT_SIZE;
}

//判满
bool IsFull(PStack ps)
{
	return ps->top == ps->stackSize;
}

//栈扩容函数,扩容2倍
void Inc(PStack ps)
{
	ps->stackSize *= 2;//扩容2倍,有的系统扩容1.5倍
	ps->base = (int*)realloc(ps->base, ps->stackSize * sizeof(int));
	assert(ps->base != NULL);
	//ps->top;//不处理
}

//往栈中入数据(入栈操作) O(1)
bool Push(PStack ps, int val)
{
	if (IsFull(ps))
	{
		Inc(ps);
	}

	ps->base[ps->top++] = val; //O(1)
	//ps->top++;

	return true;
}

//获取栈顶元素的值,但不删除
//int GetTop(PStack ps)//出错时的返回值一定和某个正常值冲突,所有函数设计有问题
//rtval:输出参数
bool GetTop(PStack ps, int* rtval)
{
	if (IsEmpty(ps))
		//return 0;//'\0'(字符串的结尾,也只有字符串在意它)
		return false;
	*rtval = ps->base[ps->top - 1];

	return true;
}

//获取栈顶元素的值,且删除
bool  Pop(PStack ps, int* rtval)
{
	if (IsEmpty(ps))
		return false;
	//*rtval = ps->base[ps->top-1];
	//ps->top--;
	*rtval = ps->base[--ps->top];
	return true;
}

//判断栈是否为空
bool IsEmpty(PStack ps)
{
	return ps->top == 0;
}

//获取栈有效数据的个数
int GetLength(PStack ps)
{
	return ps->top;
}

//清空所有的数据
void Clear(PStack ps)
{
	ps->top = 0;
}

//销毁
void Destroy(PStack ps)
{
	free(ps->base);
	ps->base = NULL;
	ps->top = 0;
	ps->stackSize = 0;
}

链式栈

lstack头文件

#pragma once
//链式栈,利用带头结点的单链表实现
//栈顶:入栈和出栈, 栈顶在表头(入栈和出栈的时间复杂度为O(1),O(1))

typedef struct LSNode
{
	int data;
	struct LSNode* next;
}LSNode, * PLStack;//链栈的节点  ,由于栈顶在第一个数据节点,所有不需要top指针

//初始化  
void InitStack(PLStack ps);

//往栈中入数据(入栈操作)
bool Push(PLStack ps, int val);

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

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

//判断栈是否为空
bool IsEmpty(PLStack ps);

//获取栈有效数据的个数
int GetLength(PLStack ps);


//清空所有的数据
void Clear(PLStack ps);

//销毁
void Destroy(PLStack ps);

lstack.cpp文件

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

//初始化  
void InitStack(PLStack ps)
{
	assert(ps != NULL);
	if (ps == NULL)
		return;

	ps->next = NULL;
}

//往栈中入数据(入栈操作)
bool Push(PLStack ps, int val)
{
	
	LSNode* p = (LSNode*)malloc(sizeof(LSNode));
	assert(p != NULL);
	p->data = val;
	p->next = ps->next;
	ps->next = p;

	return true;
}

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

//获取栈顶元素的值,且删除
bool  Pop(PLStack ps, int* rtval)
{
	if (IsEmpty(ps))
		return false;
	GetTop(ps, rtval);
	LSNode* p = ps->next;
	ps->next = p->next;
	free(p);
	p = NULL;
	return true;
}

//判断栈是否为空
bool IsEmpty(PLStack ps)
{
	return ps->next == NULL;
}

//获取栈有效数据的个数
int GetLength(PLStack ps)
{
	
	/*int count = 0;
	for(LSNode* p = ps->next; p != NULL; p = p->next)
	{
		count++;
	}
	return count;*/
	int count = 0;
	LSNode* p = ps->next;
	for (; p != NULL; p = p->next)
	{
		count++;
	}
	return count;
}

//清空所有的数据
void Clear(PLStack ps)
{
	Destroy(ps);
}

//销毁
void Destroy(PLStack ps)
{
	LSNode* p;
	while (ps->next !=NULL )
	{
		p = ps->next;
		ps->next = p->next;
		free(p);
	}
	
}