目录
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)
1800
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
