3-栈的操作

1.栈的链式存储

1.1企业级单项链表

1. 基本概念：企业级单项链表就是节点本身并不单独存储，而是作为用户数据的一部分，即其数据域是用户的数据，指针域指向下一个用户数据的地址。
2. 实现方法：
   （1）构建一个节点结构体只含有指针域；
   （2）构建一个链表结构体，包含头节点和链表的大小；
   （3）用户使用时需要预留出指针域的内存空间。

/*节点结构体*/
typedef struct LinkNode 
{
	struct LinkNode* next;
}LinkNode;

/*链表结构体*/
typedef struct listStack 
{
	LinkNode pHeader;
	int m_size;
}listStack;

3. 为了避免用户通过链表地址而对链表进行操作，需要封装创建的链表数据类型。
   （1）void*类型是万能类型，可以将任何类型转为void*，需要使用时可将void*类型转回为已知类型。

typedef void* Lstack;

1.2 初始化栈

1. 申请栈空间；
2. 初始化栈中的头节点和栈大小；
3. 将类型封装后的申请的栈地址返回。

/*初始化栈*/
Lstack init_listStack()
{
	listStack* stack = malloc(sizeof(listStack));
	stack->m_size = 0;
	stack->pHeader.next = NULL;
	return stack;
}

1.3 入栈

入栈的本质就是头插或者尾插节点。

1. 将封装的栈地址的类型转为原类型；
2. 取出用户数据中的前四字节的指针域；
3. 判断当前的栈是否已满：
   （1）若已满则返回；
   （2）若未满则头插；
4. 更新栈的大小

/*入栈:头插*/
void push_listStack(Lstack pStack, void* pData)
{
	if (pStack == NULL)
	{
		return;
	}
	if (pData == NULL)
	{
		return;
	}
	listStack* stack = pStack;
	LinkNode* data = pData;
	//1.判断栈是否已满
	if (stack->m_size == Max)
	{
		return;
	}
	//2.入栈
	data->next = stack->pHeader.next;
	stack->pHeader.next = data;
	stack->m_size++;
}

1.4 出栈

出栈的本质就是头删或者尾删节点。

1. 将封装的栈地址的类型转为原类型；
2. 取出用户数据中的前四字节的指针域；
3. 判断当前的栈是否为空：
   （1）若已空则返回；
   （2）若未空则头删；
4. 更新栈的大小

/*出栈:头删*/
void pop_listStack(Lstack pStack)
{
	if (pStack == NULL)
	{
		return;
	}
	listStack* stack = pStack;
	if (stack->m_size == 0)
	{
		return;
	}
	LinkNode* pCurrent = stack->pHeader.next;
	stack->pHeader.next = pCurrent->next;
	stack->m_size--;
}

1.5 获取栈顶元素

1. 将封装的栈地址的类型转为原类型；
2. 取出用户数据中的前四字节的指针域；
3. 判断当前的栈是否为空：
   （1）若已空则返回；
   （2）若未空则返回第一个节点的地址；
4. 用户将返回的指针转为自己的数据类型指针。

void* top__listStack(Lstack pStack)
{
	if (pStack == NULL)
	{
		return NULL;
	}
	listStack* stack = pStack;
	LinkNode* pCurrent = stack->pHeader.next;
	if (stack->m_size == 0)
	{
		return NULL;
	}
	return pCurrent;
}

1.6 判断栈是否为空

1. 直接判断链表结构体中的链表大小是否是0；

/*判断是否为空*/
int Empty__listStack(Lstack pStack)
{
	if (pStack == NULL)
	{
		return -1;
	}
	listStack* stack = pStack;
	if (stack->m_size == 0)
	{
		return 1;
	}
	return 0;
}
/*返回栈大小*/
int ret__listStack(Lstack pStack)
{
	if (pStack == NULL)
	{
		return 0;
	}
	listStack* stack = pStack;
	return stack->m_size;
}

1.7 返回栈的大小

1. 释放栈的空间
2. 注意不能释放节点空间，因为节点中的数据域是用户的数据。

/*销毁栈*/
void destory_listStack(Lstack pStack)
{
	if (pStack == NULL)
	{
		return 0;
	}
	free(pStack);
	pStack = NULL;
}

2.栈的顺序存储

1.1 实现方式

1. 定义数组的结构体，包含数组的属性
   （1）数组的首地址
   （2）数组的容量
   （3）数组的大小

/*顺序栈结构体*/
typedef struct arrayStack 
{
	void** array;
	int m_size;
	int m_capacity;
}arrayStack;

2. 封装数据类型

typedef void* arrStack;

1.2 栈的初始化

1. 申请栈的空间；
2. 初始化栈的成员；
   （1）申请并初始化数组；
   （2）数组的大小；
   （3）数组的容量；
3. 返回被封装的栈的地址。

/*初始化栈*/
arrStack init_arrayStack(int capacity)
{
	if (capacity < 0)
	{
		return NULL;
	}
	//1.初始化栈
		//1.1申请空间
	arrayStack* stack = malloc(sizeof(arrayStack));
		//1.2初始化成员
	stack->array = malloc(sizeof(void*) * capacity);
	stack->m_capacity = capacity;
	stack->m_size = 0;
	
	return stack;
}

1.3 入栈

入栈的本质就是进行尾插

/*入栈*/
void push_arrayStack(arrStack pStack, void* data)
{
	if (pStack == NULL)
	{
		return;
	}
	arrayStack* stack = pStack;
	//1.若栈已满，返回
	if (stack->m_capacity == stack->m_size)
	{
		return;
	}
	/*2.入栈：尾插*/
	stack->array[stack->m_size] = data;
	stack->m_size++;
}

1.4 出栈

其本质就是尾删

void pop_arrayStack(arrStack pStack)
{
	if (pStack == NULL)
	{
		return;
	}
	arrayStack* stack = pStack;
	//1.若栈已空，返回
	if (stack->m_size == 0)
	{
		return;
	}
	//2.出栈：尾删
	stack->array[stack->m_size-1] == NULL;
	stack->m_size--;
}

1.5 获取栈顶元素

void* ret_arrayStack(arrStack pStack)
{
	if (pStack == NULL)
	{
		return NULL;
	}
	arrayStack* stack = pStack;
	//1.若栈已空，返回
	if (stack->m_size == 0)
	{
		printf("栈溢出!\n");
		return NULL;
	}
	return stack->array[stack->m_size-1];
}

1.6 判断栈是否空

int empty_arrayStack(arrStack pStack)
{
	if (pStack == NULL)
	{
		return -1;
	}
	arrayStack* stack = pStack;
	//1.若栈已空，返回
	if (stack->m_size == 0)
	{
		return 1;
	}
	return 0;
}

1.7 获取栈大小

int size_arrayStack(arrStack pStack)
{
	if (pStack == NULL)
	{
		return 0;
	}
	arrayStack* stack = pStack;
	return stack->m_size;
}

1.8 销毁栈

void destory_arrayStack(arrStack pStack)
{
	if (pStack == NULL)
	{
		return;
	}
	arrayStack* stack = pStack;
	if (stack->array != NULL)
	{
		free(stack->array);
	}
	free(pStack);
	pStack = NULL;
}