数据结构与算法--队列

队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。

1、顺序队列

1.1 队列假溢出

当front和rear都指向了同一个元素，判为空。 当入队时，rear向后移动，指向新元素。 当出队时，front指向下一个元素。 当C4,C5,C6相继入队，C3,C4相继出队后，出现一个问题著名的假溢出问题，明明队列未满，却无法再继续入队。

1.2 循环队列

队列判空：Q.rear==Q.front

队列判满：(Q.rear+1)%MAXSIZE=Q.front

1.3 代码实现

c 实现

#include <stdio.h>
#include "stdlib.h"
#include "math.h"
#include "time.h"

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 20 /* 存储空间初始分配量 */

typedef int Status;
typedef int QElemType; /* QElemType类型根据实际情况而定，这里假设为int */

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


//1 初始化一个空队列Q
Status InitQueue(SqQueue *Q) {
    Q->front = 0;
    Q->rear = 0;
    return OK;
}

//2 将队列清空
Status ClearQueue(SqQueue *Q) {
    Q->front = Q->rear = 0;
    return OK;
}

//3 若队列Q为空队列,则返回TRUR,否则返回FALSE;
Status QueueEmpty(SqQueue Q) {
    //队空标记
    if (Q.front == Q.rear)
        return TRUE;
    else
        return FALSE;
}


//4 返回Q的元素个数,也就是队列的当前长度
int QueueLength(SqQueue Q) {
    return (Q.rear - Q.front + MAXSIZE)%MAXSIZE;
}

//5 若队列不空,则用e返回Q的队头元素,并返回OK,否则返回ERROR;
Status GetHead(SqQueue Q,QElemType *e) {
    //队列已空
    if (Q.front == Q.rear)
        return ERROR;
    *e = Q.data[Q.front];
    return OK;
    
}

//6 若队列未满,则插入元素e为新队尾元素
Status EnQueue(SqQueue *Q,QElemType e) {
    //队列已满
    if((Q->rear+1)%MAXSIZE == Q->front)
        return ERROR;
    //将元素e赋值给队尾
    Q->data[Q->rear] = e;
    //rear指针向后移动一位,若到最后则转到数组头部;
    Q->rear = (Q->rear+1)%MAXSIZE;
    return OK;
}

//7 若队列不空,则删除Q中队头的元素,用e返回值
Status DeQueue(SqQueue *Q,QElemType *e) {
    //判断队列是否为空
    if (Q->front == Q->rear) {
        return ERROR;
    }
    //将队头元素赋值给e
    *e = Q->data[Q->front];
    //front 指针向后移动一位,若到最后则转到数组头部
    Q->front = (Q->front+1)%MAXSIZE;
    return OK;
}


//8 从队头到队尾依次对队列的每个元素数组
Status QueueTraverse(SqQueue Q) {
    int i;
    i = Q.front;
    while ((i+Q.front) != Q.rear) {
        printf("%d   ",Q.data[i]);
        i = (i+1)%MAXSIZE;
    }
    printf("\n");
    return OK;
}


int main(int argc, const char * argv[]) {
    // insert code here...
    printf("顺序队列表示与操作实现\n");
    Status j;
    int i=0;
    QElemType d;
    SqQueue Q;
    InitQueue(&Q);
    printf("初始化队列后，队列空否？%u(1:空 0:否)\n",QueueEmpty(Q));
    printf("入队:\n");
    while (i < 10) {
        EnQueue(&Q, i);
        i++;
    }
    QueueTraverse(Q);
    printf("队列长度为: %d\n",QueueLength(Q));
    printf("现在队列空否？%u(1:空 0:否)\n",QueueEmpty(Q));
    printf("出队:\n");
   //出队
    DeQueue(&Q, &d);
    printf("出队的元素:%d\n",d);
    QueueTraverse(Q);
    //获取队头
    j=GetHead(Q,&d);
    if(j)
        printf("现在队头元素为: %d\n",d);
    ClearQueue(&Q);
    printf("清空队列后, 队列空否？%u(1:空 0:否)\n",QueueEmpty(Q));
    return 0;
}

//打印
//顺序队列表示与操作实现
//初始化队列后，队列空否？1(1:空 0:否)
//入队:
//0   1   2   3   4   5   6   7   8   9
//队列长度为: 10
//现在队列空否？0(1:空 0:否)
//出队:
//出队的元素:0
//1   2   3   4   5   6   7   8
//现在队头元素为: 1
//清空队列后, 队列空否？1(1:空 0:否)

swift 实现

let MAXSIZE = 20;

struct SqQueue<T> {
    var data = [T?].init(repeating: nil, count: MAXSIZE)
    var front:Int = 0; /* 头位置 */
    var rear:Int = 0;  /* 尾位置，若队列不空，指向队列尾元素的下一个位置 */
    
    // 将队列清空
    mutating func clear() -> Bool {
        front = 0
        rear = 0
        return true;
    }
    
    // 若队列Q为空队列,则返回TRUR,否则返回FALSE;
    func isEmpty() -> Bool {
        return front == rear;
    }
    
    // 返回Q的元素个数,也就是队列的当前长度
    func length() -> Int {
        return ((rear - front) + MAXSIZE) % MAXSIZE ;
    }
    
    // 若队列不空,则返回Q的队头元素,否则返回nil;
    func getHead() -> T? {
        return front == rear ? nil : data[front]
    }
    
    // 若队列未满,则插入元素e为新队尾元素
    mutating func insert(_ e:T) -> Bool {
        //队列已满
        if ((rear + 1) % MAXSIZE) == front {
            return false;
        }
        //将元素e赋值给队尾
        data[rear] = e;
        //rear指针向后移动一位,若到最后则转到数组头部;
        rear = (rear + 1) % MAXSIZE;
        return true;
    }
    
    // 若队列不空,则删除队头的元素,返回删除值
    mutating func delete() -> T? {
        //判断队列是否为空
        if front == rear {
            return nil;
        }
        //将队头元素赋值给temp
        let temp = data[front]
        //front 指针向后移动一位,若到最后则转到数组头部
        front = (front + 1) % MAXSIZE;
        return temp;
    }
    
    func traverse() -> Void {
        var i = front
        while i != rear {
            print("\(data[i] ?? nil)", terminator:"");
            i = (i + 1) % MAXSIZE
        }
        print("");
    }
}
print("顺序队列表示与操作实现");
var s = SqQueue<Int>();
print("初始化队列后，队列空否？\(s.isEmpty())");
print("入队:");
var i = 0;
while (i < 10) {
    s.insert(i);
    i += 1;
}
s.traverse()
print("队列长度为: \(s.length())");
print("现在队列空否？\(s.isEmpty())");
print("出队:")
//出队
print("出队的元素:\(s.delete())");
s.traverse()
 //获取队头
print("现在队头元素为: \(s.getHead())");
s.clear()
print("清空队列后, 队列空否？\(s.isEmpty())");

//打印
//顺序队列表示与操作实现
//初始化队列后，队列空否？true
//入队:
//Optional(0)Optional(1)Optional(2)Optional(3)Optional(4)Optional(5)Optional(6)Optional(7)Optional(8)Optional(9)
//队列长度为: 10
//现在队列空否？false
//出队:
//出队的元素:Optional(0)
//Optional(1)Optional(2)Optional(3)Optional(4)Optional(5)Optional(6)Optional(7)Optional(8)Optional(9)
//现在队头元素为: Optional(1)
//清空队列后, 队列空否？true

2、链式队列

c实现

#include <stdio.h>
#include "stdlib.h"
#include "math.h"
#include "time.h"

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 20 /* 存储空间初始分配量 */

typedef int Status;
typedef int QElemType; /* QElemType类型根据实际情况而定，这里假设为int */

/* 结点结构 */
typedef struct QNode {
    QElemType data;
    struct QNode *next;
}QNode,*QueuePtr;

/* 队列的链表结构 */
typedef struct {
    QueuePtr front,rear; /* 队头、队尾指针 */
}LinkQueue;

/*1 初始化队列*/
Status InitQueue(LinkQueue *Q){
    //1. 头/尾指针都指向新生成的结点
    Q->front = Q->rear = (QueuePtr)malloc(sizeof(QNode));
    //2.判断是否创建新结点成功与否
    if (!Q->front) {
        return ERROR;
    }
    //3.头结点的指针域置空
    Q->front->next = NULL;
    return OK;
}

/*2 销毁队列Q*/
Status DestoryQueue(LinkQueue *Q){
    //遍历整个队列,销毁队列的每个结点
    while (Q->front) {
        Q->rear = Q->front->next;
        free(Q->front);
        Q->front = Q->rear;
    }
    return OK;
}

/*3 将队列Q置空*/
Status ClearQueue(LinkQueue *Q){
    QueuePtr p,q;
    Q->rear = Q->front;
    p = Q->front->next;
    Q->front->next = NULL;
    while (p) {
        q = p;
        p = p->next;
        free(q);
    }
    return OK;
}

/*4 判断队列Q是否为空*/
Status QueueEmpty(LinkQueue Q){
    if (Q.front == Q.rear)
        return TRUE;
    else
        return FALSE;
}

/*5 获取队列长度*/
int QueueLength(LinkQueue Q){
    int i= 0;
    QueuePtr p;
    p = Q.front;
    while (Q.rear != p) {
        i++;
        p = p->next;
    }
    return i;
}

/*6 插入元素e为队列Q的新元素*/
Status EnQueue(LinkQueue *Q,QElemType e){
    //为入队元素分配结点空间,用指针s指向;
    QueuePtr s = (QueuePtr)malloc(sizeof(QNode));
    //判断是否分配成功
    if (!s) {
         return ERROR;
    }
    //将新结点s指定数据域.
    s->data = e;
    s->next = NULL;
    //将新结点插入到队尾
    Q->rear->next = s;
    //修改队尾指针
    Q->rear = s;
    return OK;
}


/*7 出队列*/
Status DeQueue(LinkQueue *Q,QElemType *e){
    QueuePtr p;
    //判断队列是否为空;
    if (Q->front == Q->rear) {
        return ERROR;
    }
    //将要删除的队头结点暂时存储在p
    p = Q->front->next;
    //将要删除的队头结点的值赋值给e
    *e = p->data;
    //将原队列头结点的后继p->next 赋值给头结点后继
    Q->front->next = p ->next;
    //若队头就是队尾,则删除后将rear指向头结点.
    if(Q->rear == p) Q->rear = Q->front;
    free(p);
    return OK;
}

/*8 获取队头元素*/
Status GetHead(LinkQueue Q,QElemType *e){
    //队列非空
    if (Q.front != Q.rear) {
        //返回队头元素的值,队头指针不变
        *e =  Q.front->next->data;
        return TRUE;
    }
    return  FALSE;
    
}

/*9 遍历队列*/
Status QueueTraverse(LinkQueue Q){
    QueuePtr p;
    p = Q.front->next;
    while (p) {
        printf("%d ",p->data);
        p = p->next;
    }
    printf("\n");
    return OK;
}


int main(int argc, const char * argv[]) {
    // insert code here...
    printf("链队列的表示与操作!\n");
    Status iStatus;
    QElemType d;
    LinkQueue q;
    //1.初始化队列q
    iStatus = InitQueue(&q);
    //2. 判断是否创建成
    if (iStatus) {
        printf("成功地构造了一个空队列\n");
    }
    //3.判断队列是否为空
    printf("是否为空队列?%d (1:是 0:否)\n",QueueEmpty(q));
    //4.获取队列的长度
    printf("队列的长度为%d\n",QueueLength(q));
    //5.插入元素到队列中
    EnQueue(&q, -3);
    EnQueue(&q, 6);
    EnQueue(&q, 12);
    printf("队列的长度为%d\n",QueueLength(q));
    printf("是否为空队列?%d (1:是 0:否)\n",QueueEmpty(q));
    //6.遍历队列
    printf("队列中的元素如下:\n");
    QueueTraverse(q);
    //7.获取队列头元素
    iStatus = GetHead(q, &d);
    if (iStatus == OK) {
        printf("队头元素是:%d\n",d);
    }
    //8.删除队头元素
    iStatus =DeQueue(&q, &d);
    if (iStatus == OK) {
        printf("删除了的队头元素为:%d\n",d);
    }
    //9.获取队头元素
    iStatus = GetHead(q, &d);
    if (iStatus == OK) {
        printf("新的队头元素为:%d\n",d);
    }
    //10.清空队列
    ClearQueue(&q);
    //11.销毁队列
    DestoryQueue(&q);
    return 0;
}

//打印
//链队列的表示与操作!
//成功地构造了一个空队列
//是否为空队列?1 (1:是 0:否)
//队列的长度为0
//队列的长度为3
//是否为空队列?0 (1:是 0:否)
//队列中的元素如下:
//-3 6 12
//队头元素是:-3
//删除了的队头元素为:-3
//新的队头元素为:6

swift实现

class Node<T:Equatable> {
    var data:T?
    var next:Node?
    
    deinit {
        print("销毁节点\(String(describing: data))");
    }
}

extension Node: CustomStringConvertible, Equatable{
    static func == (lhs: Node<T>, rhs: Node<T>) -> Bool {
        return lhs.data == rhs.data && lhs.next == rhs.next;
    }
    
    var description: String {
        guard let next = next else {
            return "\(String(describing: data))"
        }
        return "\(String(describing: data)) -> " + String(describing: next)
    }
}

class LinkQueue<T:Equatable> {
    var front:Node<T>
    var rear:Node<T>
    
    // 1 初始化队列
    init() {
        let temp = Node<T>();
        front = temp;
        rear = temp;
    }
    
    // 2 队列置空
    func clear() -> Bool {
        rear = front;
        front.next = nil;
        return true
    }
    // 3 判断队列Q是否为空
    func isEmpty() -> Bool {
        return front == rear
    }
    // 4 获取队列长度
    func length() -> Int {
        var i = 0;
        var temp = front;
        while temp != rear {
            temp = temp.next ?? rear;
            i += 1;
        }
        return i;
    }
    // 5 插入元素e为队列新元素
    func insert(_ e:T) -> Bool {
        let temp = Node<T>();
        temp.data = e;
        temp.next = nil;
        
        rear.next = temp;
        rear = temp;
        return true;
    }
    // 6 出队列
    func delete() -> T? {
        if front == rear {
            return nil
        }
        let temp = front.next
        front.next = temp?.next;
        return temp?.data
    }
    
    // 7 获取队头元素
    func getHead() -> T? {
        if front == rear {
            return nil
        }
        return front.next?.data
    }
    
    deinit {
        print("销毁队列\(String(describing: front.next))");
    }
}

extension LinkQueue :CustomStringConvertible {
    var description: String {
        return String(describing: front.next)
    }
}

func main() -> Void {
    print("链队列的表示与操作!");
    //初始化队列q
    let l = LinkQueue<Int>();
    //判断队列是否为空
    print("是否为空队列?\(l.isEmpty())");
    //获取队列的长度
    print("队列的长度为\(l.length())");
    //插入元素到队列中
    l.insert(-3);
    l.insert(6);
    l.insert(12);
    print("队列的长度为\(l.length())");
    print("是否为空队列?\(l.isEmpty())");
    //遍历队列
    print("队列中的元素如下:");
    print(l);
    //获取队列头元素
    print("队头元素是:\(l.getHead())");
    //删除队头元素
    print("删除了的队头元素为:\(l.delete())");
    print(l);
    //获取队头元素
    print("新队头元素是:\(l.getHead())");
    //清空队列
    print("是否清空队列:\(l.clear()) 是否为空队列?\(l.isEmpty())");
}

main()

//打印
//链队列的表示与操作!
//是否为空队列?true
//队列的长度为0
//队列的长度为3
//是否为空队列?false
//队列中的元素如下:
//Optional(Optional(-3) -> Optional(6) -> Optional(12))
//队头元素是:Optional(-3)
//销毁节点Optional(-3)
//删除了的队头元素为:Optional(-3)
//Optional(Optional(6) -> Optional(12))
//新队头元素是:Optional(6)
//销毁节点Optional(6)
//销毁节点Optional(12)
//是否清空队列:true 是否为空队列?true
//销毁队列nil
//销毁节点nil