精华内容
下载资源
问答
  • 3.1 栈和队列的定义和特点1 1、普通线性表的插入和删除操作 2、栈和队列的定义和特点 栈和队列是两种常用的、重要的数据结构。 栈和队列是限定插入和删除只能在表的“端点”进行的线性表。 栈和队列是...

    目录

    3.1 栈和队列的定义和特点1

    1、普通线性表的插入和删除操作

    2、栈和队列的定义和特点

    3、栈的例子

    4、栈的应用

    5、队列的例子

    6、队列的常见应用

    3.1 栈和队列的定义和特点2

    1、栈的定义和特点

    2、栈的相关概念

    3、栈的示意图

    (1)入栈的操作示图

    (2)出栈的操作示图

    (3)思考

    4、小结

    (1)定义

    (2)逻辑结构

    (3)存储结构

    (4)运算规则

    (5)实现方式

    5、栈和一般线性表有什么不同?

    3.1 栈和队列的定义和特点3

    1、队列的定义和特点

    2、队列的相关概念

    (1)定义

    (2)逻辑结构

    (3)存储结构

    (4)运算规则

    (5)实现方式


    3.1 栈和队列的定义和特点1

    1、普通线性表的插入和删除操作

    2、栈和队列的定义和特点

    栈和队列是两种常用的、重要的数据结构。

    栈和队列是限定插入和删除只能在表的“端点”进行的线性表。

    栈和队列是线性表的子集(是插入和删除位置受限的线性表)。

    线性表 队列

    Insert(L, i, x)

    1 <= i <= n + 1

    Insert(S, n + 1, x) Insert(Q, n + 1, x)

    Delete(L, i)

    1 <= i <= n

    Delete(S, n) Delete(Q, 1)

    3、栈的例子

    栈——后进先出。

    4、栈的应用

    由于栈的操作具有后进先出的固有特性,使得栈成为程序设计中的有用工具。另外,如果问题求解的过程具有“后进先出”的天然特性的话,则求解的算法中也必然需要利用“栈”。

    数制转换;表达式求值;括号匹配的检验;八皇后问题;行编辑程序;函数调用;迷宫求解;递归调用的实现。

    5、队列的例子

    队列——先进先出。

    6、队列的常见应用

    由于队列的操作具有先进先出的特性,使得队列成为程序设计中解决类似排队问题的有用工具。

    ①脱机打印输出:按申请的先后顺序依次输出。

    ②多用户系统中,多个用户排成队,分时地循环使用CPU和主存。

    ③按用户的优先级排成多个队,每个优先级一个队列。

    ④实时控制系统中,信号按接收的先后顺序依次处理。

    ⑤网络电文传输,按到达的时间先后顺序依次进行。

    3.1 栈和队列的定义和特点2

    1、栈的定义和特点

    栈(stack)是一个特殊的线性表,是限定仅在一端(通常是表尾)进行插入和删除操作的线性表。又称为后进先出(Last In

    First Out)的线性表,简称LIFO结构。

    2、栈的相关概念

    栈是仅在表尾进行插入、删除操作的线性表。表尾(即a_{n}端)称为栈顶Top;表头(即a_{1}端)称为栈底Base。

    例如:栈s=(a_{1},a_{2},a_{3},......,a_{n-1},a_{n})a_{1}称为栈底元素,a_{n}称为栈顶元素。

    插入元素到栈顶(即表尾)的操作,称为入栈;从栈顶(即表尾)删除最后一个元素的操作,称为出栈。

    “入”=压入=PUSH(x),“出”=弹出=POP(y)。

    3、栈的示意图

    (1)入栈的操作示图

    (2)出栈的操作示图

    (3)思考

    【思考】假设有3个元素a,b,c,入栈顺序是a,b,c,则它们的出栈顺序有几种可能?

    答:有5种可能。

    思考:出栈顺序有可能出现cab的情况吗?

    答:不可能。

    4、小结

    (1)定义

    限定只能在表的一端进行插入和删除运算的线性表(只能在栈顶操作)。

    (2)逻辑结构

    与同线性表相同,仍为一对一关系。

    (3)存储结构

    用顺序栈或链栈存储均可,但以顺序栈更常见。

    (4)运算规则

    只能在栈顶运算,且访问结点时依照后进先出(LIFO)的原则。

    (5)实现方式

    关键是编写入栈和出栈函数,具体实现依顺序栈或链栈的不同而不同。

    5、栈和一般线性表有什么不同?

    栈与一般线性表的区别:仅在于运算规则不同。

    一般线性表
    逻辑结构:一对一 逻辑结构:一对一
    存储结构:顺序表、链表 存储结构:顺序栈、链栈
    运算规则:随机存取 运算规则:后进先出(LIFO)

    3.1 栈和队列的定义和特点3

    1、队列的定义和特点

    队列(queue)是一种先进先出(First In First Out ----FIFO)的线性表。在表一端插入(表尾),在另一端(表头)删除。

    Q=(a_{1},a_{2},...,a_{n})

    2、队列的相关概念

    (1)定义

    只能在表的一端进行插入运算,在表的另一端进行删除运算的线性表(头删尾插)。

    (2)逻辑结构

    与同线性表相同,仍为一对一关系。

    (3)存储结构

    顺序队或链队,以循环顺序队列更常见。

    (4)运算规则

    只能在队首和队尾运算,且访问结点时依照先进先出(FIFO)的原则。

    (5)实现方式

    关键是掌握入队和出队操作,具体实现依顺序队或链队的不同而不同。

    展开全文
  • 栈和队列的定义

    2021-03-14 00:26:06
    (stack):限定仅在表尾进行插入删除操作线性表 允许插入删除一端叫做栈顶,另一端叫做底 表尾是指栈顶,而不是队列(queue):只允许一端进行插入操作,而另一端进行删除操作线性表 ...

    栈(stack):限定仅在表尾进行插入和删除操作的线性表

                             允许插入和删除的一端的叫做栈顶,另一端叫做栈底

                              表尾是指栈顶,而不是栈底

     

    队列(queue):只允许一端进行插入操作,而另一端进行删除操作的线性表

                             允许插入的一端叫做对尾,允许删除的一端叫做队头  

    展开全文
  • 一、栈和队列的定义、区别,存在的意义 1.栈的定义 (1)栈:栈实际上是一种线性表,它只允许在固定的一段进行插入或者删除元素,在进行数据插入或者删除的一段称之为栈顶,剩下的一端称之为栈顶。其遵循的原则是...

    栈和队列

    一、栈和队列的定义、区别,存在的意义

    1.栈的定义

    (1)栈:栈实际上是一种线性表,它只允许在固定的一段进行插入或者删除元素,在进行数据插入或者删除的一段称之为栈顶,剩下的一端称之为栈顶。其遵循的原则是后进先出。
    (2)栈的核心操作:三大核心操作,入栈,出栈,取栈顶元素
    (3)对于栈的形象理解:子弹的弹夹我们一定见过,子弹在被压入的时候就相当于是一个个元素,而弹夹就相当于是栈。先被压入的子弹是最后被打出的,先压入的元素是最后出来的,也就是后进先出。

    2.队列的定义

    (1)队列:首先队列也是一种特殊的线性表,它允许在一端进行插入数据,在另一端进行删除数据的。队列里边有队首,队尾,队首元素。其遵循的原则是先进先出。
    (2)队列的核心操作:三大核心操作分别是入队列,出队列,取队首元素。
    (3)对于队列的形象理解:火车穿越隧道,火车的头相当于是队列的首,火车的尾相当于是队列的尾部。火车在穿越隧道的时候,头部先进入隧道头部也先出隧道,尾部后进入尾部后出隧道。队列也就是先入的元素先出队列,后进入的元素后出队列。

    3.栈和队列的区别

    (1)栈和队列的出入方式不同:栈是后进先出、队列是先进先出。
    (2)栈和队列在具体实现的时候操作的位置不同:因为栈是后进先出,它在一段进行操作;而队列是先进先出,实现的时候在两端进行。在Java标准库中实现队列时是按照链表实现的。

    4.栈和队列存在的意义

    上边我们提到过:栈和队列都是一种典型的线性表,都是基于线性表(顺序表和链表)来实现的,那么我们研究栈和队列的目的何在?因为在栈和队列定义后,只有那三种操作,而那三种操作都是最常用的,它支持的操作越少,我们在使用的时候关心的点也就越少,用起来就越不容易出错。在计算机中“少即是多”,少意味着功能比较少、比较呆板。多意味着功能很多,用的时候要操的心就越多,就越容易出错。综上:栈和队列存在的意义就是减少线性表的基本操作,提取常用操作,让人们使用起来更方便,更不容易出错。

    二、栈的实现

    1.基于顺序表来实现栈

    栈的操作是在一端进行的,所以我们选择在顺序表的尾部进行操作:入栈用尾插来实现、出栈用尾删来实现、取栈顶元素就是取尾部元素。
    注意:我们在用顺序表来实现栈的时候选取的是在顺序表的尾部来进行的,但这并不是说在顺序表的头部就不能实现。只是在头部实现的时候,不管是头插还是头删都要进行元素的搬运,时间复杂度太高,所以不选取。

    下边是基于顺序表来实现的栈:

    public class MyStackForArrayList {
        // 用顺序表来实现栈
        // 栈的特点:后进先出,所以在顺序表中入栈用尾插,出栈用尾删,取栈顶元素用[]操作
        // 创建数组用来表示顺序表,栈的容量是100,要是不够后边可以进行扩容
        private int[] data = new int[100];
        // 记录顺序表的当前值
        private int size = 0;
    
        // 一,栈的实现:顺序表实现
        // 1.入栈,就是顺序表中的尾插,头插也能实现,但是要进行搬运,效率太低
        public void push(int val) {
            // 特殊情况的考虑,这里也可以进行扩容
            if (size >= data.length) {
                return;
            }
            // 一般情况的处理
            data[size] = val;
            size++;// 入栈要让size++
        }
        
        // 2.出栈,是有返回值的,用Integer来接收,它可以返回null。
        public Integer pop() {
            // 特殊情况
            if (size == 0) {
                return null;
            }
            // 一般情况
            int ret = data[size-1];// 保存那个出栈的元素,后边进行返回
            size--;// 出栈要让size--
            return ret;
        }
        
        // 3.取栈顶元素
        public Integer peek() {
            // 特殊情况
            if (size == 0) {
                return null;
            }
            return data[size - 1];
        }
    }
    
    

    2.基于链表来实现栈

    用链表来实现栈:在用链表实现栈的时候,我们操作的一段选取头端。用头插表示入栈,用头删来表示出栈,取栈顶元素就是取链表的head的值。
    注意:选取在链表的头部实现并不是说在链表的尾部不能进行,而是在尾部进行操作的时候,因为每一次那个tail都会进行更新,所以要用一个引用来记录tail的位置,这样就占据了一块内存空间,因此不选它。

    下边是基于链表实现的栈:

    class Node {
        int val;
        Node next;
        public Node(int val) {
            this.val = val;
        }
    }
    
    // 链表实现栈,头插表示入栈,头删表示出栈,取栈顶元素。链表头插,头删还是为了减少内存的开销
    public class MyStackForLinkedList {
        // 先搞一个链表
        private Node head = null;
        // 1.入栈,头插,不需要返回要插入的值
        public void push(int val) {
            // 将要插入的元素放在链表里边
            Node newNode = new Node(val);
            // 特殊情况的处理,空链表
            if (head == null) {// 链表本来是空的
                head = newNode;
                return;
            }
            // 处理一般情况
            newNode.next = head;
            head = head.next;
        }
    
        // 2.出栈,就是头删,出栈要返回一个值
        public Integer pop() {// 用Integer来为了可以返回那个null
            // 特殊情况处理,链表是空
            if (head == null) {
                return null;
            }
            // 链表之中只有一个元素,删除就没有元素了
            if (head.next == null) {
                int ret = head.val;
                head = null;
                return ret;
            }
            // 一般情况的处理
            int ret = head.val;
            head = head.next;
            return ret;
        }
    
        // 3.取栈顶元素
        public Integer peek() {
            // 特殊情况:要是链表是空的,没得取,返回null
            if (head == null) {
                return null;
            }
            return head.val;
        }
    }
    

    三、队列的实现

    1.基于链表来实现队列

    队列的操作在两端进行,所以我们选择在链表的尾部进行插入表示入队列,头删来表示出队列,用 head.val 操作来表示取队首元素。
    注意:这里的头删和尾插的顺序是可以进行交换的,头和尾只是选的两个引用罢了。咋样选取都是一样的。

    下边是基于链表来实现的队列:

    // 基于链表来实现队列
    // 因为队列是先进先出的,所以用尾插表示入队列。头删表示出队列,.操作表示取队列元素
    
    public class MyQueueForLinkedList {
        // 弄一个Node内部类,要带上static,为了和外部的实例无关
         static class  Node {
             int val;
             Node next;
    
            public Node(int val) {
                this.val = val;
            }
        }
        // 先创建一个链表,并记录其头节点和尾节点,方便后边的进行尾插
         Node newHead = null;
         Node newTail = null;
    
        // 1.入队列,就是尾插,为了和Java库中的队列保持一致,用boolean返回值
        public boolean offer(int val) {
            // 将要插入的值放在Node 节点里面
            Node newNode = new Node(val);
            // 情况特殊的处理
            if (newHead == null) {
                // 头节点和尾节点都是要插入的值
                newHead = newNode;
                newTail = newNode;
                return true;
            }
            // 一般情况的处理
            newTail.next = newNode;
            newTail = newTail.next;
            return true;
        }
    
        // 2.出队列,就是头删,注意头删也是要返回那个要删除的值
        public Integer poll() {
            // 特殊情况的处理,链表为空没得删
            if (newHead == null) {
                return null;
            }
            // 链表只要一个元素
            if (newHead.next == null) {
                int ret = newHead.val;
                // 新头节点就没有了,就是null
                newHead = null;
                return ret;
            }
            // 处理一般情况的处理
            int ret = newHead.val;
            newHead = newHead.next;
            return ret;
        }
        // 3.取队列首元素
       public Integer peek() {
            // 特殊情况的处理
           // 链表为空,没得取
           if (newHead == null) {
               return null;
           }
           // 一般情况的处理
           return newHead.val;
       }
    }
    

    2.基于顺序表实现队列

    (1)基本思想:创建两个引用head和tail表示队列的头部和尾部,开始的时候head和tail都表示null,此时head == tail表示的是队列是空的 。
    (2)出现的问题:每入一次队列给tail进行++,要是tail已经满了的时候就让tail == head,此时head和tail也是相等的,所以就不能区别队列到底是空的还是满的。
    (3)解决方法:
    方法1:是空上让出一个内存空间,不让tail和head重合。这种方法浪费了一块内存空间,直接让那个空间是空的,也就是用这种方法后:head == tail表示空, tail == head - 1表示队列是满的。看起来非常不好看。
    方法2:创建一个变量size,时刻记录队列里边元素的多少,没进行一次入队操作进行size++,每进行一次出队操作让size–,最后用size的值来区别队列是空的还是满的。

    下边是基于顺序表实现的队列:

    public class MyQueueForArrayList {
        // 用顺序表来实现队列
        // 基本思路:让head = 0,tail = 0;队列的长度是[head,tail),包含head不包含tail。
        // 入队:tail++,入完判断tail的值,要是 == data.length,让tail从0又开始
        // 出队列:让head++
        // 这样操作当head == tail时,有两种结果:1,是队列是空的时候    2,是队列是满的时候
        // 所以用size来记录一下顺序表的具体的大小,根据size来判断队列是否为满。
        // 创建数组
        public int[] data = new int[100];
        public int head = 0;
        private int tail = 0;
        // 这个用来判断队列到底是空的还是满的
        private int size = 0;
    
        // 1.入队操作,tail++,然后判断size的值
        public boolean offer(int val) {
            // 特殊情况的处理,先判断size的值的大小,每一次都是以size来判断队列是否是空的
            if (size == data.length) {// 队列已经满了
                return false;
            }
            // 一般情况的处理
            data[tail] = val;
            // 完成插入之后,判断一下tail的值的
            if (tail == data.length) {// 要是让tail从0开始
                tail = 0;
            }
            // 否则更新size的值
            size++;
            return true;
        }
    
        // 2.出队列,核心操作,头删,head--
        public Integer poll() {
            // 特殊情况的处理
            // 队列为空,没得取
            if (size == 0) {
                return null;
            }
            // 一般情况的处理
            int ret = data[head];
            head++;
            // 每一次要判断head的值是否到达了末尾
            // 要是到达了末尾,让head也是0
            if (head == data.length) {
                head = 0;
            }
            size--;
            return ret;
        }
    
        // 3.取队首元素
        public Integer peek() {
            // 特殊情况的处理
            if (size == 0) {// 为空,没得取
                return null;
            }
            return data[head];
        }
    }
    

    好了以上就是我学完栈和队列所了解到的内容,希望对大家有所帮助,要是有错误的地方还望大家海涵并指出。

    展开全文
  • 一、栈和队列的定义和特点 栈和队列是两种常用的、重要的数据结构 栈和队列是限定插入和删除只能在表的“端点”进行的线性表 栈和队列是线性表的子集(是插入和删除位置受限的线性表) 栈——先进后出、后进先...

    一、栈和队列的定义和特点

    • 栈和队列是两种常用的、重要的数据结构
    • 栈和队列是限定插入和删除只能在表的“端点”进行的线性表
      • 栈和队列是线性表的子集(是插入和删除位置受限的线性表)

    栈——先进后出、后进先出

    队列——先进先出

    二、栈的定义和特点

    • 栈(stack)是一个特殊的线性表,是限定仅在一端(通常是表尾)进行插入和删除操作的线性表
    • 又称为后进先出的线性表,简称LIFO结构
    • 表尾(即an端)称为栈顶Top;表头(即a1端)称为栈底Base
    • 插入元素到栈顶(即表尾)的操作,称为入栈
    • 栈顶(即表尾)删除最后一个元素的操作,称为出栈
    • “入”=PUSH(x) “出”=POP(y)

    三、队列的定义和特点

    • 队列(queue)是一种先进先出(FIFO)的线性表。在表一端插入(表尾),在另一端(表头)删除
    • 逻辑结构:与同线性表相同,仍为一对一关系
    • 存储结构:顺序队或链队,以循环顺序队列更常见

    四、栈的表示和操作的实现

    • 空栈:base==top 是栈空标志

    • 栈满:top-base==stacksize

    • 栈满时的处理方法

      • 报错,返回操作系统
      • 分配更大的空间,作为栈的存储空间,将原栈的内容移入新栈
    • 使用数组作为顺序栈存储方式的特点:

      • 简单,方便,单易产生溢出(数组大小固定)

        • 上溢(overflow):栈已经满,又要压入元素
        • 下溢(underflow):栈已经空,还要弹出元素

        注:上溢是一种错误,使问题的处理无法进行;而下溢一般认为是一种结束条件,即问题处理结束

    1、栈的初始化
    void InitStack(SeqStack *S)
    {
        S->top=-1;
    }
    
    2、判断栈空
    int IsEmpty(SeqStack S)
    {
        if(S.top==-1)
            return TRUE;
        else
            return FALSE;
    }
    
    3、判断栈满
    int IsFULL(SeqStack S)
    {
        if(S.top==StackSize-1)
            return TRUE;
        else
            return FALSE;
    }
    
    4、求顺序栈长度
    int StackLength(SeqStack S)
    {
        return S.top-S.base;
    }
    
    5、清空栈
    int ClearStack(SeqStack S)
    {
        if(S.base)
            S.top=S.base;
        return OK;
    }
    
    6、销毁栈
    int DestryStack(SeqStack &S)
    {
        if(S->base)
        {
            delete S.base;
            S.stacksize=0;
            S.base=S.top=NULL;
        }
        return OK;
    }
    
    7、入栈
    int Push(SeqStack *S,ElemType x)
    {
        if(S->top==Stack_Size-1)
            return FALSE;
        S->top++;
        S->elem[S->top]=x;
        return TRUE;
    }
    
    8、出栈
    int Pop(SeqStack *S,ElemType *x)
    {
        if(S->top==-1)
            return FALSE;
        *x=S->elem[S->top];
        S->top--;
        return TRUE;
    }
    
    9、取栈顶元素
    int GetTop(SeqStack *S,ElemType *x)
    {
        if(S->top==-1)
            return FALSE;
        *x=S->elem[S->top];
        return TRUE;
    }
    

    五、链栈的表示和实现

    • 链栈是运算受限的单链表,只能在链表头部进行操作
    typedef struct node
    {
        ElemType data;
        struct node *next;
    }LinkStackNode,*LinkStack;
    
    • 链表的头指针就是栈顶
    • 不需要头结点
    • 基本不存在栈满的情况
    • 空栈相当于头指针指向空
    • 插入和删除仅在栈顶处执行
    1、链栈的初始化
    void InitStack(LingkStack &S)
    {
        S=NULL;
    }
    
    2、判断栈空
    status StackEmpty(LinkStack S)
    {
        if(S==NULL)
            return TRUE;
        else
            return FALSE;
    }
    
    3、入栈
    int Push(LinkStack top,ElemType x)
    {
        LinkStackNode *temp;
        temp=(LinkStackNode *)malloc(sizeof(LinkStackNode));
        if(temp==NULL)
            return FALSE;
        temp->data=x;
        temp->next=top->next;
        top->next=temp;
        return TRUE;
    }
    
    4、出栈
    int Pop(LinkStack top,ElemType *x)
    {
         LinkStackNode *temp;
        temp=top->next;
        if(temp==NULL)
            return FALSE;
        top->next=temp->next;
        *x=temp->data;
        free(temp);
        return TRUE;
    }
    
    5、取栈顶元素
    int GetTop(LinkStack S)
    {
        if(S!=NULL)
            return S->data;
    }
    

    六、栈与递归

    • 递归的定义
      • 若一个对象部分地包含它自己,或用它自己给自己定义,则称这个对象是递归的
      • 若一个过程直接地或间接地调用自己,则称这个过程是递归的过程
    • 递归问题——分治法
      • 对于一个较为复杂的问题,能够分解成几个相对简单的且解法相同或类似的子问题来求解
    • 递归的优缺点
      • 优点:结构清晰,程序易读
      • 缺点:每次调用要生成工作记录,保存状态信息,入栈;返回时要出栈,恢复状态信息。时间开销大

    七、队列的表示和操作的实现

    • 顺序队列、链式队列
    • 队列的顺序表示——用一维数组base[MAXQSIZE]
    #define MAXQSIZE 100  //最大队列长度
    Typedef struct
    {
        QElemType *base;  //初始化的动态分配存储空间
        int front;  //头指针
        int rear;   //尾指针
    }sqQueue;
    
    • 设数组大小为MAXQSIZE rear=MAXQSIZE时,发生溢出
      • 若front=0 rear=MAXQSIZE时,再入队——真溢出
      • 若front≠0 rear=MAXQSIZE时,再入队——假溢出

    顺序队列

    1、队列的初始化
    Status InitQueue(SqQueue &Q)
    {
        Q.base=(QElemType*)malloc(MAXQSIZE*sizeof(QElemType));   //分配数组空间
        if(!Q.base)
            return(OVERFLOW);  //存储分配失败
        Q.front=Q.rear=0;    //头指针尾指针置为0,队列为空
        return OK;
    }
    
    2、求队列长度
    int QueueLength(SqQueue Q)
    {
        return((Q.rear-Q.front+MAXQSIZE)%MAXQSIZE);
    }
    
    3、循环队列入队
    status EnQueue(SqQueue &Q,QElemType e)
    {
        if((Q.rear+1)%MAXQSIZE==Q.front)
            return ERROR;     //队满
        Q.base[Q.rear]=e;     //新元素入队尾
        Q.rear=(Q.rear+1)%MAXQSIZE;  //队尾指针+1
        return OK;
    }
    
    4、循环队列出队
    status DeQueue(SqQueue &Q,QElemType e)
    {
        if(Q.front==Q.rear)
            return ERROR;          //队空
        e=Q.base[Q.front];         //保存队头元素
        Q.front=(Q.front+1)%MAXQSIZE;  //队头指针+1
        return OK;
    }
    
    5、取队头元素
    SElemType GetHead(SqQueue Q)
    {
        if(Q.front!=Q.rear)  //队列不为空
            return Q.base[Q.front];  //返回队头指针元素的值,队头指针不变
    }
    

    链式队列

    #define MAXQSIZE 100
    typedef struct Qnode
    {
        QElemType data;
        struct Qnode *next;
    }QNode,*QueuePtr;
    
    typedef struct
    {
        QueuePtr front;
        QueuePtr rear;
    }LinkQueue;
    
    1、初始化
    status InitQueue(LinkQueue &Q)
    {
        Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode));
        if(!Q.front)
            return(OVERFLOW);
        Q.front->next=NULL;
        return OK;
    }
    
    2、链队列销毁
    status DestroyQueue(LinkQueue &Q)
    {
        while(Q.front)
        {
            p=Q.front->next;
            free(Q.front);
            Q.front=p;
        }
        return OK;
    }
    
    3、入队
    status EnQueue(LinkQueue &Q,QElemType e)
    {
        p=(QueuePtr)malloc(sizeof(QNode));
        if(!p)
            return(OVERFLOW);
        p->data=e;
        p->next=NULL;
        Q.rear->next=p;
        Q.rear=p;
        return OK;
    }
    
    4、出队
    status EnQueue(LinkQueue &Q,QElemType e)
    {
        if(Q.front==Q.rear)
            return ERROR;
        p=Q.front->next;
        e=p->data;
        Q.front->next=p->next;
        if(Q.rear==p)
            Q.rear=Q.front;
        delete p;
        return OK;
    }
    
    5、取队头元素
    Status GetHead(LinkQueue Q,QElemType &e)
    {
        if(Q.front==Q.rear)
            return ERROR;
        e=Q.front->next->data;
        return OK;
    }
    
    展开全文
  • 栈和队列的定义和基本操作(c语言版)

    千次阅读 多人点赞 2018-08-16 15:10:15
    其限制是仅允许在表一端进行插入删除运算。这一端被称为栈顶,相对地,把另一端称为底。向一个插入新元素又称作进栈、入栈或压栈,它是把新元素放到栈顶元素上面,使之成为新栈顶元素;从一个删除元素...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,673
精华内容 1,469
关键字:

栈和队列的定义