一、栈
栈:只允许在固定的一端进行插入和删除元素操作。进入和删除操作的一端称为栈顶,另一端为栈底。
栈特性:后进先出
栈功能:将数据从一个序列改变到另一种序列
我们用顺序表来实现一个栈~
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int Datatype;
#define MAX_SIZE (100)
typedef struct stack_{
Datatype arry[MAX_SIZE];
int top;
}Stack;
//初始化
void stackInit(Stack *pS)
{
assert(pS);
pS->top = 0;
}
//入栈
void stackPush(Stack *pS, Datatype data)
{
assert(pS);
assert(pS->top< MAX_SIZE);
pS->arry[pS->top++] = data;
}
//出栈
void stackPop(Stack *pS)
{
assert(pS);
assert(pS->top>0);
pS->top--;
}
//看一下栈顶
Datatype stackTop(Stack *pS)
{
assert(pS);
return pS->arry[pS->top-1];
}
// 判断为空, 1 表示空,0 表示非空
Datatype stackIsempty(Stack *pS)
{
return pS->top == 0 ? 1 : 0;
}
//个数
Datatype stackSize(Stack *pS)
{
return pS->top;
}
//拷贝
//void stackCpy(Stack *pDest, Stack *pSrc)
//{
// pDest->top = pSrc->top;
// memcpy(pDest->arry, pSrc->arry, sizeof(Datatype)*pDest->top);
//}
void Print(Stack *pS)
{
assert(pS);
int i;
for (i = 0; i < pS->top; i++)
{
printf("%d ", pS->arry[i]);
}
printf("\n");
}
void TestStack()
{
Stack stack;
stackInit(&stack);
//stackPush(&stack, 1);
//stackPush(&stack, 2);
//stackPush(&stack, 3);
//stackPush(&stack, 4);
//stackPush(&stack, 4);
//stackPush(&stack, 4);
//stackPush(&stack, 4);
//Print(&stack);
//
//stackPop(&stack);
//Print(&stack);
//
//int a=stackTop(&stack);
//printf("top=%d\n", a);
//stackIsempty(&stack);
//int b=stackSize(&stack);
//printf("size=%d\n", b);
Stack stack1;
stackCpy(&stack,&stack1);
//
//Print(&stack);
}
二、队列
1.只允许在一端进行插入数据,在另一端删除数据
2.进行插入操作的一端称为队尾(入队列)
3.进行删除操作的一端称为队头(出队列)
4.队列具有先进先出的特性
一个小小的面试题:
循环队列如何判断队列空和满呢?
1.少用一个存储单元
2.设置一个标记
3.设置一个计数器
链式队列:
特殊的单链表,只在单链表上进行头删尾插的操作
单链表实现代码如下~
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<string.h>
typedef int Qdatatype;
//链表结构体
typedef struct QNode{
Qdatatype data;
struct Node *pNext;
}QNode;
//首尾结点结构体
typedef struct Queue{
QNode *pFront;
QNode *pRear;
int size;
}Queue;
//初始化
void QueueInit(Queue *PQ)
{
assert(PQ);
PQ->pFront = PQ->pRear = NULL;
PQ->size = 0;
}
//入队列
void QueuePush(Queue *PQ,Qdatatype data)
{
assert(PQ);
PQ->size++;
QNode *pNewNode = (QNode *)malloc(sizeof(QNode));
assert(pNewNode);
pNewNode->data = data;
pNewNode->pNext = NULL;
//特殊情况
if (PQ->pRear== NULL)
{
PQ->pFront = PQ->pRear = pNewNode;
return;
}
//一般情况
PQ->pRear->pNext= pNewNode;
PQ->pRear = pNewNode;
}
//出队列
void QueuePop(Queue *PQ)
{
assert(PQ);
assert(PQ->size > 0);
PQ->size--;
//一般情况
QNode *OldFront = PQ->pFront;
PQ->pFront = PQ->pFront->pNext;
free(OldFront);
//
if (PQ->pFront==NULL)
{
PQ->pRear = NULL;
}
}
int QueueTop(Queue *PQ)
{
assert(PQ);
assert(PQ->size > 0);
return PQ->pFront->data;
}
// 1 空 0 不空
int QueueIsEmpty(Queue *pQ)
{
pQ->size == 0 ? 1 : 0;
}
//个数
int QueueSize(Queue *pQ)
{
return pQ->size;
}
//打印
void Print(QNode *PQ)
{
assert(PQ);
for (PQ = 0; PQ!= NULL; PQ = PQ->pNext)
{
printf("%d\n ", PQ->data);
}
printf("\n");
}
void TestQueue()
{
Queue queue;
QueueInit(&queue);//初始化
QueuePush(&queue, 1);//进队列
QueuePush(&queue, 2);
QueuePush(&queue, 3);
//Print(&queue);
QueuePop(&queue);//出队列
int a=QueueTop(&queue);//队列最上面的
printf("top=%d\n", a);
QueueIsEmpty(&queue);
int b = QueueSize(&queue);
printf("size=%d\n", a);
}