数据结构栈与队列的c语言实现

1.什么是栈，栈有什么特性？
栈：一种特殊的线性表，其中只允许在固定的一端进行插入和删除元素操作，进行数据插入和删除
操作的一端称为栈顶，另一端称为栈顶。栈中的数据元素遵守后进后出的原则（LIFO）；
压栈：栈的插入操作叫作进栈，压栈，入栈，进入到数据在栈顶
出栈：栈的删除操作叫作出栈，出数据也从栈顶

2.请用C语言实现一个动态栈

#pragma once

typedef int SDataType;
typedef struct Stack
{
	int* _array;
	int _capacity;
	int _size;
}Stack;

void StackInit(Stack* ps);
void StackPush(Stack* ps, SDataType data);
void StackPop(Stack* ps);
SDataType StackTop(Stack* ps);
int StackSize(Stack* ps);
int StackEmpty(Stack* ps);
void StackDestroy(Stack* ps);

#include 
#include 
#include "0514.h"
#include 

void StackInit(Stack* ps)
{
	ps->_capacity = 4;
	ps->_size = 0;
	int *_arr = (int *)malloc(sizeof(int) * (ps->_capacity));
	if (_arr == NULL)
	{
		assert(0);
	}
	ps->_array = _arr;
}
void StackPush(Stack* ps, SDataType data)
{
	assert(ps);
	if (ps->_size == ps->_capacity)
	{
		ps->_capacity = ps->_capacity * 2;
		int * new_arr = (int *)malloc(sizeof(int) * (ps->_capacity));
		if (new_arr == NULL)
		{
			assert(0);
		}
		for (int i = 0; i < ps->_size; ++i)
		{
			new_arr[i] = ps->_array[i];
		}
		ps->_array = new_arr;
	}
	ps->_array[ps->_size] = data;
	ps->_size++;
}
void StackPop(Stack* ps)
{
	assert(ps);
	if (ps->_size == 0)
	{
		return 0;
	}
	ps->_size--;
}
SDataType StackTop(Stack* ps)
{
	assert(ps);
	if (ps->_size == NULL)
	{
		return -1;
	}
	else
	{
		return ps->_array[ps->_size - 1];
	}
}
int StackSize(Stack* ps)
{
	assert(ps);
	return ps->_size;
}
int StackEmpty(Stack* ps)
{
	assert(ps);
	if (ps->_size == 0)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}
void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->_array);
	ps->_array = NULL;
}
int main()
{
	Stack ps;
	StackInit(&ps);
	StackPush(&ps, 1);
	StackPush(&ps, 2);
	StackPush(&ps, 3);
	StackPush(&ps, 4);
	StackPush(&ps, 5);
	StackPush(&ps, 6);
	StackPop(&ps);
	StackPop(&ps);
	int tmp = StackTop(&ps);
	printf("%d\n", tmp);
	int size = StackSize(&ps);
	printf("%d\n", size);
	StackDestroy(&ps);
	system("pause");
	return 0;
}

3.栈和程序运行时的栈区有什么区别？
栈区是一块内存空间，而栈是后进先出的一种数据结构
栈区是使用栈的结构思想创建的内存

4.为什么将递归程序转化成循环时需要用到栈？
递归程序的思想与栈相同，先进入递归的函数后退出。

5.什么是队列，队列有什么特性？栈和队列有什么区别？
队列：只允许在一段进行数据插入操作，在另一端进行删除数据操作的特殊线性表，
队列具有先入先出的特性
入队列：进行插入操作的一端称为队尾
出队列：进行删除操作的一端成为队头

6.请用C语言实现一个队列

#pragma once
typedef int QDataType;
typedef struct QNode
{
	struct QNode* _pNext;
	QDataType _data;
}QNode;

typedef struct Queue
{
	QNode* head;
	QNode* tail;
}Queue;
void QueueInit(Queue* q);
void QueuePush(Queue* q, QDataType data);
void QueuePop(Queue* q);
QDataType QueueFront(Queue* q);
QDataType QueueBack(Queue* q);
int QueueSize(Queue* q);
int QueueEmpty(Queue* q);
void QueueDestroy(Queue* q);

#include 
#include 
#include 
#include "0515.h"

void QueueInit(Queue* q)
{
	if (q == NULL)
	{
		return 0;
	}
	q->head = NULL;
	q->tail = NULL;
}
QNode* BuyNewNode(QDataType data)
{
	QNode* newNode = (QNode*)malloc(sizeof(QNode));
	if (newNode == NULL)
	{
		assert(0);
	}
	newNode->_data = data;
	newNode->_pNext = NULL;
	return newNode;
}
void QueuePush(Queue* q, QDataType data)
{
	assert(q);
	QNode* curNode = NULL;
	if (QueueEmpty(q))
	{
		q->head = BuyNewNode(data);
		q->tail = q->head;
	}
	else
	{
		q->tail->_pNext = BuyNewNode(data);
		q->tail = q->tail->_pNext;
	}
}
void QueuePop(Queue* q)
{
	assert(q);
	if (QueueEmpty(q))
	{
		return 0;
	}
	else
	{
		QNode* delNode = q->head;
		q->head = q->head->_pNext;
		free(delNode);
		delNode = NULL;
	}
}
QDataType QueueFront(Queue* q)
{
	assert(q);
	if (QueueEmpty(q))
	{
		return 0;
	}
	return q->head->_data;
}
QDataType QueueBack(Queue* q)
{
	assert(q);
	if (QueueEmpty(q))
	{
		return 0;
	}
	return q->tail->_data;
}
int QueueSize(Queue* q)
{
	assert(q);
	QNode* curNode = q->head;
	int count = 0;
	while (curNode)
	{
		curNode = curNode->_pNext;
		++count;
	}
	return count;
}
int QueueEmpty(Queue* q)
{
	assert(q);
	if (q->head == NULL)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}
void QueueDestroy(Queue* q)
{
	assert(q);
	while (!QueueEmpty(q))
	{
		QueuePop(q);
	}
}
int main()
{
	Queue q;
	int front = 0,size = 0;
	int back = 0;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	QueuePush(&q, 4);
	front = QueueFront(&q);
	back = QueueBack(&q);
	printf("front=%d tail=%d\n",front,back);
	size = QueueSize(&q);
	printf("size=%d\n", size);
	QueuePop(&q);
	front = QueueFront(&q);
	printf("front=%d\n", front);
	size = QueueSize(&q);
	printf("size=%d\n", size);
	QueueDestroy(&q);
	system("pause");
	return 0;
}