详解数据结构:队列(含栈与队列扩展)

一、顺序队列

有一种线性序列,特点是先进先出,这种存储结构称为队列。队列也是一种线性表,只不过它是操作受限的线性表,只能再两端操作:一端进、一端出。进的一端称为队尾,出的一端称为队头。队列可以用顺序存储,也可以使用链式存储。

1、顺序队列的定义

队列的顺序存储采用一段连续的空间存储数据元素,并用两个整型变量记录队头和队尾元素的下标。顺序存储方式的队列如下图:

顺序队列的结构体定义如下:

cpp 复制代码
typedef  struct SqQueue{
    ElemType *base; //空间基地址
    int front,rear; //头指针,尾指针
}SqQueue;

说明:

  • ElemType是指元素类型,需要什么类型就写什么类型。
  • typedef将结构体等价于类型名SqQueue。

顺序队列定义好了之后,还要先定义一个最大分配空间,顺序结构都是如此,需要预先分配空间,因此可以采用宏定义。

cpp 复制代码
#define Maxsize 100

上面的结构体定义采用了动态分配的形式,也可以采用静态分配的形式,使用一个定长数组存储数据元素,用两个整型变量记录队头和队尾元素的下标。静态分配的顺序队列结构体定义如下:

cpp 复制代码
typedef  struct SqQueue{
    ElemType data[Maxszie]; //定长数组
    int front,rear; //头指针,尾指针
}SqQueue;

注意 :队列只能在一端进,一端出,不允许在中间查找、取值、插入、删除等操作,先进先出是人为规定的,如果破坏规则,就不是队列了。

完美图解:

假设现在顺序队列Q分配了6个空间,然后继续入队和出队操作。

**注意:**Q.front和Q.rear都是整型下标。

(1)开始时为空队,Q.front=Q.rear。如下图

(2)元素a­1入队,放入队尾Q.rear的位置,然后Q.rear后移一位。

(3)元素a2入队,放入队尾Q.rear的位置,然后Q.rear后移一位。

(4)元素a3、a4、a5分别按顺序入队,队尾Q.rear依次后移。

(5)元素a1出队,队头Q.front后移一位。

(6)元素a2­出队,队头Q.front后移一位。

(7)元素a6进队,放在队尾Q.rear的位置,然后Q.rear后移一位。

(8)元素a7­入队,此时队尾Q.rear已经超过了数组的最大下标,无法再进队,但是前面还有两个空间却出现了队满的情况,这种情况称为**"假溢出"。**

解决方法:上面第七步元素a6进队之后,队尾Q.rear要后移一个位置,此时已经超过了数组的最大下标,即Q.rear+1=Maxsize(最大空间为6),那么如果前面有空闲,Q.rear可以转向前面下标为0的位置。

元素a7进队,放入队尾Q.rear的位置,然后Q.rear后移一位。

元素a8入队,放入队尾Q.rear的位置,然后Q.rear后移一位。

这时,虽然队列空间存满了,但是出现了一个大问题!当队满了,Q.front=Q.rear,这和队空的条件一模一样,这样无法区分到底是队空还是队满。

解决办法:

  • 设置一个标志,标记队空和队满;
  • 浪费一个空间,当队尾Q.rear的下一个位置是Q.front时,就认为是队满。

上述到达尾部又向前存储的队列称为循环队列,为了避免"假溢出",顺序队列往2、往采用循环队列

2、循环队列的定义

首先简述循环队列队空、队满的判定条件,以及出队、队列元素个数计算等基本操作方法。

(1)队空

无论队头和队尾在什么位置,只有Q.rear和Q.front指向同一个位置,就认为队空。如果将循环队列中的一维数组画成环形图,队空的情况如下图:

循环队列空的判定条件为Q.front==Q.rear。

(2)队满

在此采用浪费一个空间的方法,当队尾Q.rear的下一个位置Q.front时,就认为是队满。但是Q.rear向后移动一个位置(Q.rear+1)后,就很有可能超出数组的最大下标,这时它的下一个位置应该是0。

图中,队列的最大空间是Maxsize,当Q,rear=Maxsize-1时,Q.rear+1=Maxszie。而根据循环队列的规则,Q.rear的下一个位置是0。可以考了取余运算,即(Q.rear+1)%Maxsize=0。而此时Q.front=0,即(Q.rear+1)%Maxsize=Q.front,此时为队满的临界状态。

在上图中,加入最大空间数Maxsize=100,当Q.rear=1时,Q.rear+1=2,取余后(Q.rear+1)%Maxsize=2,而此时Q.front=2,即(Q.rear+1)%Maxsize=Q.front。队满的一般状态也可以采用此公式判断队满。因为一个不大于Maxsize的数与Maxisze取余运算,结果仍然为该数本身,所以一般状态下,取余运算没有任何影响。只有在临界状态(Q.rear+1=Maxsize)下,取余运算才会变成0.

因此,循环队列队满的判定条件为:(Q.rear+1)%Maxsize=Q.front

(3)入队

入队时,首先将元素x放入Q.rear所指的空间,然后Q,rear后移一位。

入队操作,当Q.rear后移一位,为了处理临界状态(Q.rear+1)=Maxsize,需要加1后取余运算。

代码实现:

Q.base[Q.rear]=e; //新元素插入队尾

Q.rear=(Q.rear+1)%Maxsize; //队尾指针加1

(4)出队

先用变量保存队头元素,然后队头Q.front后移一位。

出队操作,当Q.rear后移一位时,为了处理临界状态(Q.front+1)=Maxsize,需要加1后取余运算。

代码实现:

e=Q.base[Q.front]; //保存队头元素

Q.front=(Q.front+1)%Maxsize; //队头指针加1

注意:循环队列无论使出对还是入队,队尾、队头加1后都要取余运算,主要是为了处理临界状态。

(5)队列元素个数计算

循环队列中到底存了多少个元素,循环队列的内容实际上为Q.front~Q.rear-1这一切邮件的数据元素,但是不可以直接用两个下标相减得到。因为队列是循环的,所以存在两种情况:

①Q.rear≥Q.front

②Q.rear<Q.front

可以看到循环队列中的元素实际上为6个,当两者之差是负数的时候,可以将差值加上Maxsize计算元素个数,即Q.rear-Q.front+Maxsize。

因此在计算元素个数时,可以分为两种情况判断:

①Q.rear≥Q.front:元素个数为Q.rear-Q.front

②Q.rear<Q.front:元素个数为Q.rear-Q.front+Maxsize。

也可以采用取余的方法及那个这两种情况巧妙地统一为一个语句。

队列元素的个数为:(Q.rear-Q.front+Maxsize)%Maxsize。

(6)小结

队空:

cpp 复制代码
Q.front==Q.rear;//Q.rear和Q.front指向同一个位置

队满:

cpp 复制代码
(Q.rear+1)%Maxsize==Q.front;//Q.rear向后移一位正好是Q.front

入队:

cpp 复制代码
Q.base[Q.rear]=e; //新元素插入队尾

Q.rear=(Q.rear+1)%Maxsize; //队尾指针加1

出队:

cpp 复制代码
e=Q.base[Q.front]; //保存队头元素

Q.front=(Q.front+1)%Maxsize; //队头指针加1

队列中元素个数:

cpp 复制代码
(Q.rear-Q.front+Maxsize)%Maxsize。

3 、循环队列的基本操作

循环队列的基本包括初始化、入队、出队、取队头元素、求队列长度。

(1)初始化

初始化循环队列,首先分配一个大小为Maxsize的空间,然后令Q.rear=Q.front=0,即队头和队尾为0,队列为空。

代码实现:

cpp 复制代码
bool InitQueue(SqQueue &Q)//注意使用引用参数,否则出了函数,其改变无效
{
    Q.base=new int[Maxsize];//分配空间
    if(!Q.base) return false;
    Q.front=Q.rear=0; //头指针和尾指针置为零,队列为空
    return true;
}

(2)入队

入队时,首先判断队列是狗已满,如果已满,则入队失败;如果未满,则将新元素插入队尾,队尾后移一位。

代码实现:

cpp 复制代码
bool EnQueue(SqQueue &Q,int e)//将元素e放入Q的队尾
{
    if((Q.rear+1)%Maxsize==Q.front) //尾指针后移一位等于头指针,表明队满
        return false;
    Q.base[Q.rear]=e; //新元素插入队尾
    Q.rear=(Q.rear+1)%Maxsize; //队尾指针加1
    return true;
}

(3)出队

出队时,首先判断队列是否为空,如果队列为空,则出队失败;如果队列不空,则用变量保存队头元素,然后队头后移一位。

代码实现:

cpp 复制代码
bool DeQueue(SqQueue &Q, int &e) //删除Q的队头元素,用e返回其值
{
    if(Q.front==Q.rear)
        return false; //队空
    e=Q.base[Q.front]; //保存队头元素
    Q.front=(Q.front+1)%Maxsize; //队头指针加1
    return true;
}

(4)取队头元素

取队头元素时,只要把队头元素数据复制一份即可,并未改变队头位置,因此队列中的内容没有改变。

代码实现:

cpp 复制代码
int GetHead(SqQueue Q)//返回Q的队头元素,不修改队头指针
{
    if(Q.front!=Q.rear) //队列非空
        return Q.base[Q.front];
    return -1;
}

(5)求队列的长度

通过前面的分析,我们已经知道循环队列中的元素个数为:(Q.rear-Q.front+Maxsize)%Maxsize,循环队列中元素个数即为循环队列的元素。

代码实现:

cpp 复制代码
int QueueLength(SqQueue Q)
{
    return (Q.rear-Q.front+Maxsize)%Maxsize;
}

二、链队列

队列除了用顺序存储,也可以用链式存储。

顺序队列是分配一段连续的空间,用两个整型下标front和rear分别指向队头和队尾。而链队列类似一个单链表,需要两个指针front和rear分别指向队头和队尾。从队头出列,从队尾入队,为了出队时删除元素方便,可以增加一个头结点。

注意:链队列需要头结点。

因为链队列是一个单链表的形式,因此可以借助单链表的定义。

链队列中节点的结构体定义如下:

cpp 复制代码
typedef  struct Qnode{
  int data;
  struct Qnode *next;
}Qnode,*Qptr;
链队列的结构体定义如下图:
typedef struct{
  Qnode *front;
  Qnode *rear;
}LinkQueue;

链队列的操作和单链表一样,只不过他只能队头删除,在队尾插入,是操作受限的单链表。

1、初始化

链队列的初始化,即创建一个头结点,头指针和尾指针指向头结点。

代码实现:

cpp 复制代码
void InitQueue(LinkQueue &Q)//注意使用引用参数,否则出了函数,其改变无效
{
    Q.front=Q.rear=new Qnode; //创建头结点,头指针和尾指针指向头结点
    Q.front->next=NULL;
}

2 、入队

先创建一个新节点,将元素e存入该节点的数值域。

然后将新节点插入队列,尾指针后移。

赋值解释:

①Q.rear->next=s:把s节点的地址赋值给队尾节点的next域,即尾节点的next指针指向s。

②Q.rear=s:把s节点的地址赋值给尾指针,即尾指针指向s,尾指针永远指向队尾。

代码实现:

cpp 复制代码
void EnQueue(LinkQueue &Q,int e)//将元素e放入队尾
{
    Qptr s;
    s=new Qnode;
    s->data=e;
    s->next=NULL;
    Q.rear->next=s;//新元素插入队尾
    Q.rear=s;     //队尾指针后移
}

3、出队

出队相当于删除第一个元素,即将第一个元素节点跳过去。首先用p指针指向第一个数据节点,然后跳过该节点,即Q.front->next=p->next。

若队列中只有一个元素,删除后需要修改尾指针。

代码实现:

cpp 复制代码
bool DeQueue(LinkQueue &Q,int &e) //删除Q的队头元素,用e返回其值

{

    Qptr p;

    if(Q.front==Q.rear)//队空

        return false;

    p=Q.front->next;

    e=p->data;     //保存队头元素

    Q.front->next=p->next;

    if(Q.rear==p) //若队列中只有一个元素,删除后需要修改队尾指针

        Q.rear=Q.front;

    delete p;

    return true;

}

4、取队头元素

队头元素实际上是Q.front->next指向的节点,即第一个数据节点,队头元素就是该节点的数据域存储的元素。

代码实现:

cpp 复制代码
int GetHead(LinkQueue Q)//返回Q的队头元素,不修改队头指针

{

    if (Q.front!=Q.rear) //队列非空

        return Q.front->next->data;

    return -1;

}

三、栈和队列的应用

1 、数制的转换

题目:将一个十进制数n转换为二进制数

解题思路:十进制转换为二进制,可以采用辗转相除法,取余数的方法得到。例如十进制数11转二进制,先求余数11%2=1,求商11/2=5,然后用商5求余数,求商,直到商为0,结束。

先求出的余数是二进制的低位,后求出的余数是二进制的高位,将得到的余数逆序输出就是所要的二进制数,逆序输出正号符合栈的先入后出的性质,因此可以借助栈来实现。

算法步骤:

  1. 初始化一个栈。
  2. 如果n!=0,将n%2入栈,更新n=n/2。
  3. 重复运行第二步,直到n=0为止。
  4. 如果栈不空,弹出栈顶元素e,输出e,知道栈空。

完美图解:

十进制11转换为二进制的计算步骤如下:

  1. 初始化n=11;
  2. n%2=1,1入栈,更新n=11/2=5;
  3. n%2=1,1入栈,更新n=5/2=2;
  4. n%2=0,0入栈,更新n=2/2=1;
  5. n%2=1,1入栈,更新n=1/2=0;
  6. n=0,算法停止。

入栈过程如下图:

如果栈不空,则一直出栈,出栈过程如下:

出栈的结果正好事十进制数11转化为二进制数1011。

代码实现:

cpp 复制代码
void binaryconversion(int n)

{

    SqStack S;//定义一个栈S

    int e;

    InitStack(S);//初始化栈

    while(n)

    {

        Push(S,n%2);//将n%2压入栈中

        n=n/2;

    }

    while(!Empty(S))//如果栈不空

    {

        Pop(S,e);//出栈

        cout<<e<<"\t";//输出栈顶元素

    }

}

算法复杂度分析:

每次取余后除以2,n除以2多少次变为1那么第一个while语句就执行了多少次,假设执行了x次,则n/2x=1,x=log2n,因此复杂度为为O(log2n),使用的栈空间大小也是log2n,空间复杂度也是O(log2n)。

2、回文判定

题目:回文是指正反读均相同的字符序列,也就是字符串沿中心线对称。写一算法判定给定的字符串是否为回文。

解题思路:回文是中心对称的,可以将字符串前一半入栈,然后,栈中元素和字符串后一般进行比较。即将第一个出栈元素和后一半中第一个字符比较,如相等,则再将出栈一个元素与后一个字符比较......直到栈空为止,则字符序列为回文。在出栈元素与串中字符比较不等时,则字符序列不是回文。

算法步骤:

  1. 初始化一个栈S。
  2. 求字符串长度,将前面一半的字符串依次入栈S。
  3. 如果栈不空,弹出栈顶元素e,与字符串后一半元素比较。若n为激素,则跳过中心点,比较中心点后面的元素。如果元素相等,则继续比较直到栈空,返回true;如果元素不等,则返回false。

完美图解:

代码实现:

cpp 复制代码
bool palindrome(char *str)//判断字符串是否为回文

{

    SqStack S;//定义一个栈S

    int len,i;

    char e;

    len=strlen(str);//返回字符串长度

    InitStack(S);//初始化栈

    for(i=0;i<len/2;i++)//将字符串前一半依次入栈

        Push(S,str[i]);

    if(len%2==1)//字符串长度为奇数,跳过中心点

        i++;

    while(!Empty(S))//如果栈不空

    {

        Pop(S,e);//出栈

        if(e!=str[i])//比较元素是否相等

            return false;

        else

            i++;

    }

    return true;

}

算法复杂度分析:

如果字符串长度为n,将前一半入栈,后一半依次和出栈元素比较,相当于扫描了整个字符串,因此时间复杂度为O(n),使用栈空间大小是n/2,空间复杂度也为O(n)。

3、双端队列

题目:设计一个数据结构,使其具有栈和队列两种特性。

解题思路:

栈是后进先出,队列是先进先出。

栈是在一端进出,队列是在一端进、另一端出。

允许两端都可以进行入队和出队的队列,就是双端队列。

双端队列是比较特殊的线性表,具有队列两种性质。

循环队列表示的双端队列,可以用环形形象地表达出来。双端队列和普通循环队列地区别如下图。双端队列包括前端和后端,可以从前端进入、前端出队、后端进队、后端出队。

1、双端队列结构体定义

双端队列可以用两个整型变量front和rear分别指向队头和队尾,采用顺序存储。静态分配空间形式地双端队列,其结构体定义如下:

cpp 复制代码
typedef  struct SqQueue{

  ElemType base[Maxsize]; //一维数组存储,也可以设置指针动态分配空间

  int front,rear; //头指针,尾指针

}DuQueue;

注意:在顺序存储中,静态分配空间采用的是以为定长数组存储数据,动态分配空间是在程序运行中使用new动态分配空间。

完美图解

(1)前端进队时,先令Q.front前移一位,再将元素放入Q.front的位置,a、b、c依次从前端进队。

(2)后端进队时,先将元素放入Q.rear的位置,再令Q.rear后移动一位,d从后端进队。

(3)此时d从后端出队,先令Q.rear前移一位,再将Q.rear位置取出。

(4)此时a从后端出队,先将Q.rear前移一位,再将Q.rear的元素取出。

(5)此时c从前端出队,先将Q.front位置元素取出,再令Q.front后移一位。

(6)此时b从前端出队,先将Q.front位置元素取出,再令Q.front后移一位。

因此,a、b、c、d依次进队,可以通过双端队列得到 d、a、c、b的出队顺序。

从上面的图中可以看出以下两个特点:

  1. 后端进、前端出或者前端进、后端出体现了先进先出的特点,符合队列的特性。
  2. 后端进、后端出或者前端进、前端出提点了后进先出的特点,符合栈的特性。

所以说,循环队列实现的双端队列,具有栈和队列两种性质。

2、双端队列的基本操作

双端队列的基本操作包括初始化、判队满、尾进、尾出、头进、头出、取队头、取队尾、求长度、遍历。

(1)初始化

初始化时,头指针和尾指针为零,双端队列为空。

代码实现:

cpp 复制代码
void InitQueue(DuQueue &Q)//注意使用引用参数,否则出了函数,其改变无效

{

    Q.front=Q.rear=0; //头指针和尾指针置为零,队列为空

}

(2)判队满

当队尾后移一位等于队头,表明队满,队尾后移一位即Q.rear+1,加1后有可能等于Maxsize,此时下一个位置为0,因此为处理临界状态,需要与Maxsize取余运算。队满的临界状态和一般状态如下图:

代码实现:

cpp 复制代码
bool isFull(DuQueue Q)

{

    if((Q.rear+1)%Maxsize==Q.front) //尾指针后移一位等于头指针,表明队满

        return true;

    else

        return false;

}

(3)尾进

尾部进队,即后端进队时,先将元素放入Q.rear位置,然后Q.rear后移一位,后移时为处理边界情况,需要加1后模Maxsize取余。

代码实现:

cpp 复制代码
bool push_back(DuQueue &Q,ElemType e)

{

    if(isFull(Q))

        return false;

    Q.base[Q.rear]=e; //先放入

    Q.rear=(Q.rear+1)%Maxsize;//向后移动一位

    return true;

}

(4)尾出

尾部出队,即后端出队时,先将Q.rear前移一位,然后取出元素。前移一位即Q.rear-1,当Q.rear为0时,Q.rear-1为负值,因此加上Maxsize,正好时Maxsize-1的位置。那么,Q.rear-1为正值时,加上Maxsize就超过了下标范围,需要模Maxsize取余。

尾出时,Q.rear前移一位的处理如下图所示。

代码实现:

cpp 复制代码
bool pop_back(DuQueue &Q,ElemType &x)

{

    if(isEmpty(Q))

        return false;

    Q.rear=(Q.rear-1+Maxsize)%Maxsize;//向前移动一位

    x=Q.base[Q.rear]; //取数据

    return true;

}

(5)头进

头部进队时,即前端进队时,先将Q.front前移动一位,然后将元素放入Q.front位置。队头前移一位即Q.front-1,前移时为处理边界情况,需要加Maxsize再模Maxsize取余。和尾出的前移处理一样。

代码实现:

cpp 复制代码
bool push_front(DuQueue &Q,ElemType e)

{

    if(isFull(Q))

        return false;

    Q.front=(Q.front-1+Maxsize)%Maxsize;//先向前移动一位

    Q.base[Q.front]=e; //后放入

    return true;

}

(6)头出

头部进队,即前端出队时,先取出元素,然后Q.front后移一位,即Q.front+1,后移时为处理边界情况,需要模Maxsize取余。

代码实现:

cpp 复制代码
bool pop_front(DuQueue &Q,ElemType &x)

{

    if(isEmpty(Q))

        return false;

    x=Q.base[Q.front]; //取数据

    Q.front=(Q.front+1)%Maxsize;//向后移动一位

    return true;

}

(7)取队头

取队头是将Q.front位置的元素取出来,Q.front未改变。

代码实现:

cpp 复制代码
bool get_front(DuQueue Q,ElemType &x)

{

    if(isEmpty(Q))

        return false;

    x=Q.base[Q.front]; //取队头数据;

    return true;

}

(8)取队尾

因为Q.rear指针永远指向空,因此取队尾时,取Q.rear前面的那个位置,要想得到前面位置,为处理边界情况,需要加Maxsize再模Maxsize取余。注意:取队尾时,尾指针不移动。

代码实现:

cpp 复制代码
bool get_back(DuQueue Q,ElemType &x)

{

    if(isEmpty(Q))

        return false;

    x=Q.base[(Q.rear-1+Maxsize)%Maxsize];

    return true;

}

(9)求长度

和普通循环队列求长度的方法一样,都是从队头到队尾之间的元素个数。因为循环队列减法有可能有负值,因此需要加入Maxsize再模Maxsize取余。

代码实现:

cpp 复制代码
int length(DuQueue Q)

{

    return (Q.rear-Q.front+Maxsize)%Maxsize;

}

(10)遍历

双端队列的遍历,即从头到尾输出整个队列的元素,在输出过程中,队头和队尾元素并不移动,因此借助一个暂时变量即可。

代码实现:

cpp 复制代码
void traverse(DuQueue Q)

{

    if(isEmpty(Q))

    {

       cout<<"DuQueue is empty"<<endl;

       return ;

    }

    int temp=Q.front;//设置一个暂存变量,头指针未移动

    while(temp!=Q.rear)

    {

       cout<<Q.base[temp]<<"\t";

       temp=(temp+1)%Maxsize;

     }

     cout<<endl<<"traverse is over!"<<endl;

}

此外,还有另外两种方法:

(1)输出受限的双端队列

允许在一端进队和出队,另一端只允许进队,这样的双端队列称为输出受限的双端队列。

(2)输入受限的双端队列

允许在一端进队和出队,另一端只允许出队,这样的双端队列称为输入受限的双端队列。

相关推荐
Hera_Yc.H3 小时前
数据结构之一:复杂度
数据结构
肥猪猪爸4 小时前
使用卡尔曼滤波器估计pybullet中的机器人位置
数据结构·人工智能·python·算法·机器人·卡尔曼滤波·pybullet
linux_carlos4 小时前
环形缓冲区
数据结构
readmancynn4 小时前
二分基本实现
数据结构·算法
Bucai_不才4 小时前
【数据结构】树——链式存储二叉树的基础
数据结构·二叉树
盼海4 小时前
排序算法(四)--快速排序
数据结构·算法·排序算法
一直学习永不止步5 小时前
LeetCode题练习与总结:最长回文串--409
java·数据结构·算法·leetcode·字符串·贪心·哈希表
珹洺6 小时前
C语言数据结构——详细讲解 双链表
c语言·开发语言·网络·数据结构·c++·算法·leetcode
_whitepure6 小时前
常用数据结构详解
java·链表····队列·稀疏数组
几窗花鸢6 小时前
力扣面试经典 150(下)
数据结构·c++·算法·leetcode