数据结构 - 栈和队列 知识点

数据结构 - 栈和队列

1. 线性表
   • 操作受限
     • 栈: 顺序栈，链栈，共享栈
     • 队列: 循环队列，链式队列，双端队列
   • 推广
     • 数组: 一维数组 ，多维数组 ，压缩存储，稀疏矩阵

1. 栈

1. 栈是只允许在一端进行插入和删除的线性表；首先栈是一种线性表，后进先出(LIFO)
2. 数学性质: n个不同元素进栈，出栈元素不同排列个数为(1/n+1)*C(n,2n) 又称卡特兰数

1.1 顺序栈

1. 采用顺序存储的栈成为顺序栈，利用一组地址连续的存储单元存放自栈底到栈顶的数据元素，并附设栈顶指针(top)指示当时栈顶元素的位置

#define MaxSize 50
typedef struct{
    Elemtype data[MaxSize];
    int top;
}SqStack;
栈顶指针: S.top ,初始 S.top=-1，栈顶元素 S.data[S.top]
栈空 S.top =-1  栈满 S.top = MaxSize-1 栈长 S.top+1

//初始化
void InitStack(SqStack &S){
    S.top = -1;
}
// 判栈空
bool StackEmpty(SqStack S){
    if(S.top == -1) return true;
    else return false;
}
//进栈
bool Push(SqStack &S,Elemtype value){
    if(S.top!=MaxSize-1){
        S.top++;
        S.data[S.top] = value;
        return true;
    }
    else return false;
}
//出栈
bool Pop(SqStack &S,Elemtype &value){
    if(S.top != -1){
        value = S.data[S.top];
        S.top--;
        return true; 
    }
    else return false;
}
//获取栈顶元素
bool GetTop(SqStack S,Elemtype &value){
    if(S.top != -1){
        value=S.data[S.top];
        return true;
    }
    return false;
}

2. 队列

1. 只允许在一端进行插入，另一端进行删除，简称 入队，和 出队 先进先出(FIFO)
2. 队头: Front 允许删除 ; 队尾: Rear 允许插入
3. 队列顺序存储是分配一块连续的存储单元存放队列元素，并附设 队头和队尾指针

#define MaxSize 50
typedef struct{
    ElemType data[MaxSize];
    int front,rear;
}SqQueue;

初始(队空): Q.front = Q.rear = 0;

2.1 循环队列

1. 将顺序队列想象成一个环状空间，即把队列元素从逻辑上视为一个环，成为 循环队列

   初始: Q.front = Q.rear = 0;
   队首指针进1: Q.front = (Q.front+1)%MaxSize;
   队尾指针进1: Q.rear = (Q.rear+1)%MaxSize;
   队列长度: (Q.rear+MaxSize-Q.front)%MaxSize;
   出队入队时，指针 按顺时针方向进1
   队满: (Q.rear+1)%MaxSize = Q.front;
   队空: Q.front = Q.rear;

2. 循环队列操作

// initation
void InitQueue(SqQueue &Q){
    Q.front = Q.rear = 0;
}

//empty
bool empty(SqQueue &Q){
    if((Q.rear+1)%MaxSize == Q.front) return true;
    return false;
}
// enQueue
bool enQueue(SqQueue &Q, ElemType k){
    if((Q.rear+1)%MaxSize == Q.front) return false;
    Q.data[Q.rear]= k;
    Q.rear = (Q.rear+1)%MaxSize;
    return true;
}
//deQueue
bool deQueue(SqQueue &Q, ElemType &k){
    if(Q.front == Q.rear) return false;
    k = Q.data[Q.front];
    Q.front = (Q.front+1)%MaxSize;
    return true;
}

2.2 链式队列

1. 队列的链式表示为链队列，实际上是一个同时有队头指针和队尾指针的单链表
   

typedef struct{
    ElemType data;
    struct LinkNode *next;
}LinkNode;
typedef struct{
    LinkNode *front,*rear;
}LinkQueue;

//init
void InitQueue(LinkQueue &Q){
    Q.front = Q.rear = (LinkNode*)malloc(sizeof(LinkNode));
    Q.front->next = NULL;
}
//isempty
bool isEmpty(LinkQueue  &Q){
    if(Q.front == Q.rear) return true;
    return false;
}
//enQueue
void enQueue(LinkQueue &Q,ElemType k){
    LinkNode *s = (LinkNode*)malloc(sizeof(LinkNode));
    s->data = k;
    s->next = NULL
    Q.rear->next = s;
    Q.rear = s;
    
}
//deQueue
bool deQueue(LinkQueue &Q,ElemType &k){
    if(Q.front == Q.rear) return false;
    LinkNode *p = Q.front->next;
    k = p->data;
    Q.front->next = p->next;
    if(Q.rear == p) Q.front = Q.rear;   //若原队列只有一个节点，出队以后变空
    free(p);
    return true;
}