栈和队列概念及实现

目录

1.栈

1.1栈的概念及结构

 1.2栈的实现

2.队列

2.1队列的概念及结构

2.2队列的实现

 3.栈和队列的基础选择题

---

1.栈

1.1栈的概念及结构

栈：一种特殊的线性表，其中允许在固定的一段进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的元素遵守后进先出LIFO（Last In First Out)的原则。

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

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

 1.2栈的实现

栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些，因为数组在尾上插入数据的代价比较小。

 

 

 

 Stack.h

#pragma once

typedef int DataType;
//定义栈结构
typedef struct Stack
{
	DataType *array;
	int capacity;
	int size;
}Stack;


//初始化
void StackInit(Stack* ps);

//入栈
void StackPush(Stack* ps, DataType data);

//出栈
void StackPop(Stack* ps);

//获取栈顶元素
DataType StackTop(Stack* ps);

//获取栈中有效元素个数
int StackSize(Stack* ps);

//检测栈是否为空
int StackEmpty(Stack* ps);

//栈的销毁

void StackDestroy(Stack* ps);

void StackPrint(Stack* ps);
void TestStack();

Stack.c 

#include "Stack.h"
#include <stdio.h>
#include <assert.h>
//初始化
void StackInit(Stack* ps)
{
	assert(ps);
	ps->array = malloc(sizeof(DataType)* 3);
	if (NULL == ps->array)
	{
		assert(0);
		printf("malloc申请空间失败！");
		return;
	}
	ps->capacity = 3;
	ps->size = 0;
}

void StackCheckCapacity(Stack* ps)
{
	assert(ps);
	if (ps->capacity == ps->size)
	{
		/*int newCapacity = ps->capacity * 2;
		DataType* temp = (DataType*)realloc(ps->array,sizeof(DataType)*newCapacity);
		if (NULL == temp)
		{
			printf("扩容失败！");
			exit(0);
		}
		ps->array = temp;
		ps->capacity = newCapacity;*/
		int newCapacity = ps->capacity * 2;
		DataType *temp = malloc(sizeof(DataType)*newCapacity);
		if (NULL == temp)
		{
			assert(0);
			printf("malloc失败");
			return;
		}
		memcpy(temp, ps->array, sizeof(DataType)*ps->size);
		free(ps->array);
		ps->array = temp;
		ps->capacity = newCapacity;
	}
}
//入栈
void StackPush(Stack* ps, DataType data)
{
	StackCheckCapacity(ps);
	ps->array[ps->size] = data;
	ps->size++;
}


//出栈
void StackPop(Stack* ps)
{
	assert(ps);
	if (StackEmpty(ps))
		return;
	ps->size--;
}

//获取栈顶元素
DataType StackTop(Stack* ps)
{
	assert(ps);
	if (!StackEmpty(ps))
		return ps->array[ps->size - 1];
	return NULL;
}

//获取栈中有效元素个数
int StackSize(Stack* ps)
{
	assert(ps);
	return ps->size;
}

//检测栈是否为空
int StackEmpty(Stack* ps)
{
	assert(ps);
	return 0 == ps->size;
}

//栈的销毁

void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->array);
	ps->array = NULL;
	ps->capacity = 0;
	ps->size = 0;
}
void StackPrint(Stack* ps)
{
	assert(ps);
	for (int i = 0; i < ps->size; ++i)
	{
		printf("%d ", ps->array[i]);
	}
	printf("\n");
}

void TestStack()
{
	Stack s;
	StackInit(&s);
	StackPush(&s, 1);
	StackPush(&s, 2);
	StackPush(&s, 3);
	StackPush(&s, 4);
	StackPush(&s, 5);
	printf("size=%d\n", StackSize(&s));
	printf("top=%d\n", StackTop(&s));
	StackPrint(&s);
	StackPop(&s);
	StackPop(&s);
	StackPop(&s);
	printf("size=%d\n", StackSize(&s));
	printf("top=%d\n", StackTop(&s));
	StackPrint(&s);
	StackDestroy(&s);
}

2.队列

2.1队列的概念及结构

 队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFOFirst In First Out)的特点。入队列：进行插入操作的一端称为队尾；出队列：进行数据删除的一端称为队头。

 

2.2队列的实现

队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组，出队列在数组头上出数据，效率会比较低。

 

queue.h

#pragma once

typedef int DataType;

// 队列中底层链表的节点的结构
typedef struct QNode
{
	struct QNode* next;
	DataType data;
}QNode;

//队列的结构
typedef struct Queue
{
	QNode* front;  //指向队头
	QNode* back;   //指向队尾
}Queue;

//队列的初始化
void QueueInit(Queue* q);
//入队列,尾插
void QueuePush(Queue* q, DataType data);
//出队列
void QueuePop(Queue* q);
//获取队列中有效元素的个数
int QueueSize(Queue* q);
//队列是否为空
int QueueEmpty(Queue* q);
//获取队尾元素
DataType QueueBack(Queue* q);
//获取队头元素
DataType QueueFront(Queue* q);
//队列的销毁
void QueueDestroy(Queue* q);


void TestQueue();

queue.c

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


//队列的初始化
void QueueInit(Queue* q)
{
	assert(q);
	q->front = NULL;
	q->back = NULL;
}
QNode* BuyQNode(DataType data)
{
	QNode* newNode = (QNode*)malloc(sizeof(QNode));
	if (NULL == newNode)
	{
		assert(0);
		return NULL;
	}
	newNode->data = data;
	newNode->next = NULL;
	return newNode;
}
//入队列，尾插
void QueuePush(Queue* q, DataType data)
{
	assert(q);
	//创建一个新节点进行尾插
	QNode* newNode = BuyQNode(data);

	//1.队列为空
	if (QueueEmpty(q))
	{
		q->front = newNode;
		q->back = newNode;
	}
	else
	{
		//2.队列不为空，往back后尾插
		q->back->next = newNode;
		q->back = newNode;
	}
}
//出队列
void QueuePop(Queue* q)
{
	assert(q);
	//1.队列为空
	if (QueueEmpty(q))
	{
		return;
	}
	else if(q->front==q->back)
	{
		 //2.队列中只有一个节点
		free(q->front);
		q->front = NULL;
		q->back = NULL;
	}
	else
	{
		//3.d队列中有多个节点
		QNode* delNode = q->front;
		q->front = delNode->next;
		free(delNode);
	}
}
//获取队列中有效元素的个数
int QueueSize(Queue* q)
{
	assert(q);
	QNode* cur = q->front;
	int count=0;
	while (cur)
	{
		++count;
		cur = cur->next;
	}
	return count;
}
//队列是否为空
int QueueEmpty(Queue* q)
{
	assert(q);
	return NULL == q->front;
}
//获取队尾元素
DataType QueueBack(Queue* q)
{
	assert(q);
	return q->back->data;
}
//获取队头元素
DataType QueueFront(Queue* q)
{
	assert(q);
	return q->front->data;
}
//队列的销毁
void QueueDestroy(Queue* q)
{
	QNode* cur = q->front;
	while (cur)
	{
		q->front = cur->next;
		free(cur);
		cur = q->front;
	}
	q->front = NULL;
	q->back = NULL;
}


void TestQueue()
{
	Queue q;
	QueueInit(&q);

	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	QueuePush(&q, 4);
	QueuePush(&q, 5);
	QueuePush(&q, 6);

	printf("size = %d\n", QueueSize(&q));//6
	printf("front = %d\n", QueueFront(&q));//1
	printf("back = %d\n", QueueBack(&q));//6


	QueuePop(&q);
	QueuePop(&q);
	printf("size = %d\n", QueueSize(&q));//4
	printf("front = %d\n", QueueFront(&q));//3
	printf("back = %d\n", QueueBack(&q));//6

	QueuePop(&q);
	QueuePop(&q);
	QueuePop(&q);
	printf("size = %d\n", QueueSize(&q));//1
	printf("front = %d\n", QueueFront(&q));//6
	printf("back = %d\n", QueueBack(&q));//6

	QueuePop(&q);
	printf("size = %d\n", QueueSize(&q));//0
	if (QueueEmpty(&q))
	{
		printf("空队列\n");
	}
	else
	{
		printf("非空队列");
	}

	QueueDestroy(&q);
}

 3.栈和队列的基础选择题

1.一个栈的初始状态为空。现将元素1、2、3、4、5、A、B、C、D、E依次入栈，然后再依次出栈，则元素出 栈的顺序是（ B）。

A 12345ABCDE            B EDCBA54321

C ABCDE12345            D 54321EDCBA

2.若进栈序列为 1,2,3,4 ，进栈过程中可以出栈，则下列不可能的一个出栈序列是（C）

A 1,4,3,2     B 2,3,4,1     C 3,1,4,2     D 3,4,2,1

3.循环队列的存储空间为 Q(1:100) ，初始状态为 front=rear=100 。经过一系列正常的入队与退队操作 后， front=rear=99 ，则循环队列中的元素个数为（D）

A 1             B 2              C 99             D 0或者100

4.以下( )不是队列的基本运算？(B)

A 从队尾插入一个新元素

B 从队列中删除第i个元素

C 判断一个队列是否为空

D 读取队头元素的值

5.现有一循环队列，其队头指针为front，队尾指针为rear；循环队列长度为N。其队内有效长度为？(假设 队头不存放数据)    (B)

A (rear - front + N) % N + 1   B (rear - front + N) % N

C ear - front) % (N + 1)         D (rear - front + N) % (N - 1)