数据结构与算法第三章栈与队列 数据结构栈和队列笔记

• 栈的基本概念：

• 栈的定义：一种只能在一端进行插入或者删除的线性表，这一端称为栈顶
• 栈的特点：先进后出
• 栈的存储结构：顺序栈和链式栈

 

• 队列的基本概念：

• 队列的定义：允许在表的一端（队尾）进行插入，在另一端（队头）进行删除的线性表
• 队列的特点：先进先出
• 队列的存储结构：顺序队和链队

 

• 栈和队列的存储结构、算法：

• 顺序栈的定义：

typedef struct
{
    int data[maxSize];  //存放栈中的元素
    int top;        //栈顶指针
}SqStack;

• 链栈结点定义：

typedef struct LNode
{
    int data;       //数据域
    int LNode *next;//指针域
}LNode;

• 顺序队列定义：

typedef struct 
{
    int data[maxSize];       
    int front;//队首指针
    int rear; //队尾指针
}SqQueue;

• 链队定义：

• 队结点类型定义：

typedef struct QNode
{
    int data;       
    struct QNode *next; //指针域
}QNode;

• 链队类型定义：

typedef struct 
{
    QNode *front;
    QNode *rear;
}LiQueue;

 

• 顺序栈的基本算法操作：

• 顺序栈st的要素

• 两个状态：

• 栈空状态：st.top==-1
• 栈满状态：st.top==maxSize-1;

• 两个操作：

• 元素x进栈操作 ++（st.top);   st.data[st.top]=x;
• 元素x出栈操作 x=st.data[st.top];  --(st.top);

• 非法状态，上溢和下溢

 

• 初始化栈的算法：

void initStack(Sqstack &st) //初始化栈
{
    st.top = -1;   //将栈顶设置为-1
}

• 判断栈空的算法：

int isEmpty(Sqstack st) 
{
   if(st.top==-1)
        return 1;
   else
        return 0;
}

• 进栈算法：

int Push(SqStack &st, int x)
{
    if(st.top == maxSize-1)
        return 0;
    ++(st.top);                        //先移动指针再进栈
    st.data[st.top]=x;
        return 1;
}

• 出栈算法：

int Pop(SqStack &st, int &x)
{
    if(st.top == -1)
        return 0;
    x = st.data[st.top];   //先取出元素，再进行指针的移动
    --(st.top);
        return 1;
}

 

• 考题中实用的栈操作写法：

• 声明一个栈并且初始化：      int stack[maxSize];  int top=-1;    //声明加初始化都有了
• 元素x进栈：                          stack[++top]=x;
• 元素x出栈：                           x=stack[top--];
• //++top 与top++的区别 ：a=++top 是 top 先自增1，再将top值给a； 而b=top++ 是top先给b，再进行top自增1

 

• 链栈的基本算法操作：

• 链栈的要素：

• 状态：

• 栈空状态：1st ->next = null;

• 两个操作：

• 元素进栈：   

p->next = 1st->next;
1st->next = p;    //头插法建立链表的插入操作

• 出栈操作：

p = 1st->next;
x = p->data;
1st->next = p->next;
free(p);   //单链表删除操作

• 链栈的初始化算法：

void InitStack(LNode *&1st)
{
    1st = (LNode*) malloc(sizeof(LNode));  //制造一个头结点
    1st->next = NULL;
}

• 判断栈空的算法：

int isEmpty(LNode *1st)
{
    if(1st->next = NULL)
        return 1;
    else 
        return 0;
}

• 进栈算法：

void push(LNode *1st,int x)
{
    LNode *p;
    p = (LNode*)malloc(sizeof(LNode));
    p->next = NULL;
    
    
    P->data = x;
    p->next = 1st->next;
    1st->next = p;
}

• 出栈算法：

void Pop(LNode *1st,int &x)
{
    LNode *p;
    if(1st->next==NULL)
        return 0;
    
//单链表删除操作
    p = 1st->next;
    x = p->data;
    1st->next = p->next;
    free(p);
    return 1;
}

 

• 顺序队的算法操作：

• 要素：

• 两个状态：

• 队空状态：　　qu.rear = qu.front;
• 队满状态： 　  (qu.rear+1)%maxSize == qu.front;

• 两个操作：

• 元素x进队：qu.rear = (qu.rear + 1) % maxSize;   qu. data [qu.rear] = x;
• 元素x出队：qu.front = (qu.front + 1) % maxSize;   x = qu.data[qu.front];

• 初始化队列：

void InitQueue(SqQueue &qu)
{
    qu.front = qu.rear = 0;
}

• 判断队空：

int QueueEmpty(sqQueue qu)
{
    if(qu.front = qu.rear)
        return 1;
    else
    return 0;
}

• 元素进队：

int enQueue(sqQueue &qu,int x)
{
    if((qu.rear+1)%maxSize == qu.rear)
        return 0;
    qu.rear = (qu.rear+1)%maxSize;
    qu.data[qu.rear] = x;
    return 1;
}

• 元素出队：

int deQueue(sqQueue &qu, int &x)
{
    if(qu.front ==qu.rear)
        return 0;
    qu.front = (qu.front+1)% maxSize;
    x = qu.data[qu.front];
    return 1;
}

 

• 链队算法操作；

• 链队的要素：

• 状态：

• 队空状态：lqu->rear  ==  NULL或者lqu->front == NULL;

• 两个操作：

• 元素进队操作:     lqu->rear->next = p;  lqu ->rear = p;
• 元素出队操作：  p = lqu ->front ; lqu->front = p->next; x=p->data;free(p);

• 初始化链队的算法:

void Initqueue(Liqueue *&lqu)
{
    lqu=(LiQueue *)malloc(sizeof(LiQueue));
    lqu->front = lqu->rear = NULL;
}

• 判断队空的算法：

int QueueEmpty(LiQueue *lqu)
{
    if(lqu->rear==NULL ||lqu->front==NULL)
        return 1;
    else 
        return 0;
}

• 入队的算法：

void enQueue(LiQueue *lqu, int x)
{
    QNode *p;
    p = (QNode*)malloc(sizeof(QNode));
    p->data = x;
    p->next = NULL;
    if(lqu->rear==NULL)
        lqu->front=lqu->rear=p;
    else
    {
        lqu->rear->next=p;
        lqu->rear=p;
    }
}

• 出队算法：

int dequeue(LiQueue *lqu, int &x)
{
    QNode *p;
    if(lqu->rear=front)
        return 0;
    else
        p = lqu->front;
    if(lqu->front = lqu->rear)
        lqu->front = lqu->rear =NULL;
    else
        lqu->front = lqu->front->next;
    x = p->data;
    free(p);
    return 1;
}