栈与队列

定义:栈是限定仅在表尾进行插入和删除操作的线性表。
我们把允许插入和删除的一端称为栈顶(top),另一端称为栈底(bottom),不含任何数据元素的栈称为空栈。栈又称为先进后出(Last In First Out)的线性表,简称LIFO结构。
首先他是一个线性表,栈元素具有线性关系,即前驱后继关系。是一种特殊的线性表,定义中说的线性表的表尾进行插入和删除操作,表尾是指栈顶,而不是栈底。特殊之处在于限制了这个线性表的插入和删除位置,始终只在栈顶进行。这使得栈底是固定的,最先进栈的只能是在栈底。

栈的插入操作,叫做进栈,也称压栈、入栈。类似子弹入弹夹。
栈的删除操作,叫做出栈,也称出栈。如同弹夹中的子弹出来。

栈的抽象数据类型

ADT 栈(stack)
Data
同线性表。元素具有相同的类型,相邻元素具有前驱和后继关系。
Operation
InitStack ():初始化操作,建立一个空栈S。
DestroyStack(*S):若栈存在,则销毁它。
ClearStack(*S):将栈清空。
Push(*S,e):若栈s存在,插入新元素e到栈s中并成为栈顶新元素。

endADT

栈的结构与实现
//栈的顺序存储结构定义
typedef struct {
    int data[MAXSIZE];
    int top;    //用于栈顶指针
}stack;

//入栈
int push(stack *s, int e){
    if (s->top == MAXSIZE-1)    //栈满
        return 0;
    s->top++;
    s->data[s->top]=e;
    return 1;
}
//出栈,若不为空用e返回其值
int pop(stack *s, int *e){
    if (s->top == -1)       //栈空
        return 0;
    *e=s->data[s->top];
    s->top--;
    return 1;
}


//链栈代码结构
typedef struct stack_node{
    int data;
    struct stack_node *next;
}stack_node, *link_stack_ptr;
typedef struct link_stack{
    link_stack_ptr top;
    int count;
}link_stack;
//判断是否为空
int stack_empty(link_stack s){
    if (s.top == NULL)
        return 1;
    else
        return 0;
}
//入栈
int push(link_stack *S, int e){
    link_stack_ptr s=(link_stack_ptr)malloc(sizeof(stack_node));
    s->data=e;
    s->next=S->top;     //新结点指向栈顶元素,使之相连
    S->top=s;           //将栈顶指针指向新元素,作为新的栈顶
    S->count++;
    return 1;
}
//出栈,用e返回其值,假设用变量p存储要删除的栈顶结点
int pop(link_stack *s, int *e){
    link_stack_ptr p;
    if (stack_empty(*s))
        return 0;
    *e=s->top->data;        //返回删除元素
    p=s->top;               //p指向要出栈的顶点元素
    s->top=s->top->next;    //栈顶指针下移一位
    free(p);
    s->count--;
    return 1;
}
两栈共享空间

两个栈底分别在数组的两端,向中间靠拢,当top+1 == top2为栈满。

//两栈共享空间结构
typedef struct {
    int data[MAXSIZE];
    int top1;       //栈1栈顶指针
    int top2;       //栈2栈顶指针
}double_stack;

//入栈时需要有个判断是栈1还是栈2的参数
int ds_push(double_stack *s, int e, int stack_number){
    if (s->top1+1 == s->top2)       //栈满
        return 0;
    if (stack_number == 1)
        s->data[++s->top1] = e;     //先top1+1再入栈
    if (stack_number == 2)
        s->data[++s->top2] = e;
    return 1;
}
//出栈
int ds_pop(double_stack *s, int *e, int stack_number){
    if (stack_number == 1){
        if (s->top1 == -1)
            return 0;
        *e = s->data[s->top1--];
    }
    else if (stack_number == 2){
        if (s->top2 == MAXSIZE)
            return 0;
        *e = s->data[s->top2++];
    }
    return 1;
}
栈的应用

递归,例如斐波那契数列

int fbi(int i){
    if (i<2)
        return i == 0 ?  0 : 1;
    return fbi(i-1) + fbi(i-2);
}

四则运算表达式求值

队列

定义:队列是之允许在一端进行插入操作,而在另一端进行删除操作的线性表。
队列是一种先进先出(First In First Out)的线性表,简称FIFO允许插入的一端称为队尾,允许删除的一端称为队头。

队列的抽象数据类型

同样是线性表,队列也有类似线性表的各种操作,不同的是插入数据只能在队尾进行,删除数据只能在队头进行。
ADT 队列(Queue)
Data
同线性表。元素具有相同的类型,相邻元素具有前驱和后继关系。
Operation
InitQueue(*Q):初始化操作,建立一个空队列Q.
DestroyQueue(*Q):若队列Q存在,则销毁它.
ClearQueue(*Q):将队列Q清空.
GetHead(Q,*e):若队列Q存在且非空,用e返回队列Q的队头元素.

endADT

循环队列

顺序存储的局限性很大,使用循环队列实现队列的顺序存储。
避免当只有一个元素时,队头和对尾重合使处理变得麻烦,引用两个指针,front指针指向队头元素,rear指针指向对尾元素的下一个位置。当队列为空时,条件就是front = rear,当队列满时,我们修改条件,保留一个元素空间。也就是说,队列满时,数组中还有一个空闲单元,但我们认为已经满了。
由于rear可能比front大,也有可能比它小,所以它们可能差整整一圈。若队列的最大尺寸为QueueSize,那么队列满的条件是(rear+1)%QueueSize,队列的长度分别为两段,一段是QueueSize-front,另一段是0+rear,因此通用的计算队列长度公式为(rear-front+QueueSize)%QueueSize。现在循环队列的代码就不难了。

//循环队列的顺序存储结构
typedef struct {
    int data[MAXSIZE];
    int front;      //头指针
    int rear;       //尾指针,若队列不为空,指向队列尾元素的下一个位置
}queue;

//初始化
int init_queue(queue *q){
    q->front=0;
    q->rear=0;
    return 1;
}

//队列当前的长度
int queue_length(queue q){
    return (q.rear-q.front+MAXSIZE)%MAXSIZE;
}

//入队列
int en_queue(queue *q, int e){
    if ((q->rear+1)%MAXSIZE == q->front)    //队列满的判断
        return 0;
    q->data[q->rear]=e;             //对尾加入元素e
    q->rear=(q->rear+1)%MAXSIZE;    //rear尾指针向后移动一位,若到最后转到数组头部
    return 1;
}

//出队列
int de_queue(queue *q, int *e){
    if (q->front == q->rear)
        return 0;
    *e=q->data[q->front];
    q->front=(q->front+1)%MAXSIZE;
    return 1;
}

单是顺序存储有着时间性能,数组溢出等问题,所以还需要研究不需要担心队列长度的链式存储结构。

队列的链式存储结构
//链队列的结构
typedef struct q_node{      //结点结构
    int data;
    struct q_node *next;
}q_node,*queue_ptr;
typedef struct {            //队列的链表结构
    queue_ptr front,rear;
}link_queue;

//入队操作,就是在链表的尾部插入结点
int en_queue(link_queue *q, int e){
    queue_ptr s=(queue_ptr)malloc(sizeof(q_node));
    if (!s)
        exit(0);
    s->data=e;
    s->next=NULL;
    q->rear->next=s;        //把新结点作为原对尾的后继
    q->rear=s;              //把对尾指针设置为s
    return 1;
}

//出队操作,若队不为空,删除队头元素,用e返回其值
int de_queue(link_queue *q, int *e){
    queue_ptr p;
    if (q->rear == q->front)
        return 0;
    p=q->front->next;
    *e=p->data;
    q->front->next=p->next;
    if (q->rear == p)       //若只有一个元素,删除后需要将尾指针rear指向头结点
        q->rear=q->front;
    free(p);
    return 1;
}

简单总结
栈和队列都是特殊的线性表,只不过是对插入和删除操作做了限制。
栈(stack)是限定仅在表尾进行插入和删除操作的线性表。
队列(queue)是只允许在一端进行插入操作,而在另一端进行删除操作的线性表。

它们都可以用线性表的顺序存储结构来实现,但存在一定的弊端,因此有各自的技巧来解决这个问题。
对于栈来说,如果是两个相同数据类型的栈,则可以用数组的两端作为栈底的方法来让两个栈共享数据,最大化利用数组空间。
对于队列来说,为了避免数组插入和删除时需要移动数据,于是引入了循环队列,使得队头和队尾可以在数组中循环变化,解决了移动数据的时间损耗,使得本来插入和删除是O(n)的时间复杂度变成了O(1)。

当然,都可以使用链式存储结构来实现,原则与线性表相同。

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值