数据结构——堆栈和队列

女爷i 2022-07-26 00:06 328阅读 0赞

堆栈和队列都是特殊的线性表,线性表、堆栈和队列三者的数据元素以及数据元素之间的逻辑关系完全相同。
差别:线性表的插入和删除操作不受任何限制,而堆栈只能在栈顶插入和删除,队列只能在队尾插入,在对头删除。


1.堆栈(先进后出,或后进先出线性表)

  • 几个专业术语解释:
    栈顶:堆栈中允许进行插入和删除数据元素操作的一端称为栈顶
    栈底:栈顶的另外一端
    栈顶指示器(或栈顶指针):栈顶的当前位置是动态的,用于标记栈顶当前位置的变量称为指示器;
  • 堆栈的抽象数据类型:
    1.数据集合:
    堆栈的数据集合表示为a0,a1,a2……,每个数据类型为DataType.
    2.操作集合:

    (顺序堆栈的存储结构)
    顺序堆栈和顺序表的数据成员是相同的,不同之处是,顺序堆栈的入栈和出栈操作只能对当前栈顶元素进行。
    定义结构体:

    1. typedef struct
    2. {
    3. DataType stack[MaxStackSize];
    4. int top; //top表示顺序堆栈数组stack的当前栈顶位置
    5. }SeqStack;

    与顺序表相比较可知,顺序堆栈和顺序表两者除数据域名和结构体名不同外,其他结构完全相同。
    (1.)初始化StackInitiate(*S)

    1. void StaticInitiate(*S)
    2. {
    3. S->top=0; //初始化栈顶下标值
    4. }

    (2.)非空否StackNotEmpty(S)

    1. int StackNotEmpty(S) //判断顺序堆栈S是否为空,非空返回1,否则返回0
    2. {
    3. if(S.top<=0)return 0;
    4. else return 1;
    5. }

    (3.)入栈StackPush(SeqStack *S,DataType x)

    1. int StackPush(SeqStack *S,DataType x)//把数据元素x存入顺序堆栈S中,入栈成功返回1,否则返回0
    2. {
    3. if(S->top>=MaxStackSize)
    4. {
    5. printf("堆栈已满,无法插入!\n")
    6. return 0;
    7. }
    8. else
    9. {
    10. S->Stack[S->top]=x; S->top++; return 1; } }

    (4.)出栈StackPop(SeqStack *S,DataType *d)

    1. int StackPop(SeqStack *S,DataType) //取出顺序堆栈S的栈顶元素值由参数d带回,出栈成功则返回1,否则返回0
    2. {
    3. if(S->top<=0)
    4. {
    5. printf("堆栈已空无数据元素出栈!\n");
    6. return 0;
    7. }
    8. else
    9. {
    10. S->top--; //得注意top--,--top的差别
    11. *d=S->stack[S->top]; return 1; } }

    (5.)取栈顶数据元素StackTop(SeqStack S,DataType *d) 与出栈相比较,不需要top–

    1. int StackTop(SeqStack S,DataType *d) //取栈顶数据元素值由参数d带回,成功返回1,不成功返回0
    2. {
    3. if(S.top<=0)
    4. {
    5. printf("堆栈已空!\n");
    6. return 0;
    7. }
    8. else
    9. {
    10. *d=S.stack[S.top-1];
    11. return 1;
    12. }
    13. }

    以上实现顺序堆栈操作的所有函数中,都没有循环语句,所以顺序堆栈所有操作时间复杂度均为O(1)

顺序表的链式表示
堆栈有两端,插入元素和删除元素的一端为栈顶,另一端为栈底。对于链式堆栈来说,显然,吧靠近头指针的一端定义为栈顶,则插入元素和删除元素时不需要遍历整个链,其时间复杂度为O(1);否则,若把远离头指针的一端定义为栈顶,则每次插入元素和删除元素都需要遍历整条链,其时间复杂度为O(n).
因此,链式堆栈一般设计把靠近头指针的一端为栈顶
虽然链式堆栈的插入和删除都是在链表的表头进行的,但是若把链式堆栈设计成带头结点的结构,,则插入和删除改变的只是头指针所指向结点的Next域的值(即head->next值),而不是头指针的值,因此可以把链式堆栈设计成带头结点的结构

链式堆栈结点的结构体定义:

  1. typedef struct snode
  2. {
  3. DataType data;
  4. struct snode *next;
  5. }LSNode;

(1.)初始化StackInitiate(LSNode **head)

  1. void SatckInitiate(LSNode **head) //初始化带头结点的链式堆栈
  2. {
  3. *head=(LSNode *)malloc(sizeof(LSNode));
  4. (*head)->next=NULL;
  5. }

(2.)非空否StackNotEmpty(LSNode *head)

  1. int StackNotEmtpty(LSNode *head) //判断堆栈是否为空,如果为空,返回1,否则返回0
  2. {
  3. if(head->next==NULL)return 0;
  4. else return 1;
  5. }

(3.)入栈StackPush(LSNode *head,DataType x)

  1. void StackPush(LSNode *head,DataType x) //把数据元素x插入链式堆栈head的栈顶作为新的栈顶
  2. {
  3. LSNode *p;
  4. p=(LSNode*)malloc(sizeof(LSNode));
  5. p->data=x;
  6. p->next=head->next; //新结点链入栈顶
  7. head->next=p; //新节点称为新的栈顶
  8. }

(4.)出栈StackPop(LSNode *head,DataType *d)

  1. int StackPop(LSNode *head,DataType *d) //出栈并把栈顶元素由参数d带回,出栈成功返回1,否则返回0
  2. {
  3. LSNode *p=head->next;
  4. if(p==NULL)
  5. {
  6. printf("堆栈已空出错!");
  7. return 0;
  8. }
  9. head->next=p->next; //删除原栈顶结点
  10. *d=p->data; //原栈顶结点元素赋予d
  11. free(p); //释放原栈顶结点内存空间
  12. return 1;
  13. }

(5.)取栈顶数据元素StackTop(LSNode *head,DataType *d)

  1. int StackTop(LSNode *head,DataType *d) //取栈顶元素并把栈顶元素由参数d带回
  2. {
  3. LSNode *p=head->next;
  4. if(p==NULL)
  5. {
  6. printf("堆栈已空出错!");
  7. return 0;
  8. }
  9. *d=p->data;
  10. return 1;
  11. }

(6.)撤销动态申请空间Destory(SLNode *head)

  1. void Destory(SLNode *head)
  2. {
  3. LSNode *p,*p1;
  4. p=head;
  5. while(p!=NULL)
  6. {
  7. p1=p;
  8. p=p->next;
  9. free(p);
  10. }
  11. }

上述实现链式堆栈的所有函数中,没有循环语句,所以链式堆栈所有操作的时间复杂度均为O(1)
上述链式堆栈结点的结构体定义和操作的实现函数都写在头文件LinStack.h中

发表评论

表情:
评论列表 (有 0 条评论,328人围观)

还没有评论,来说两句吧...

相关阅读

    相关 Java数据结构--------堆栈队列

    本章相关介绍: 堆栈和队列都是特殊的线性表。线性表、堆栈和队列三者的数据元素以及数据元素间的逻辑关系完全相同,差别是线性表的插入和删除操作不受限制,而堆栈只能在栈顶插入和删除

    相关 数据结构堆栈队列

    堆栈与队列是两种重要的基础数据结构,一个是先入后出,一个是先入先出,有着广泛的应用,本文分别使用数组与链表实现堆栈与队列 顺序存储方式实现堆栈 define

    相关 数据结构——堆栈队列

    堆栈和队列都是特殊的线性表,线性表、堆栈和队列三者的数据元素以及数据元素之间的逻辑关系完全相同。 差别:线性表的插入和删除操作不受任何限制,而堆栈只能在栈顶插入和删除,队列