2. 程式人生 > >佇列及其c語言實現

佇列及其c語言實現

阿新 • • 發佈：2019-01-08

佇列的基本概念

佇列 (Queue) :也是運算受限的線性表。是一種先進先出 (First In First Out ,簡稱 FIFO) 的線性表。只允許在表的一端進行插入,而在另一端進行刪除。
隊首 (front) :允許進行刪除的一端稱為隊首。
隊尾 (rear) :允許進行插入的一端稱為隊尾。

佇列中沒有元素時稱為空佇列。在空佇列中依次加入元素 a 1 , a 2 , …, a n 之後, a 1 是隊首元素, a n 是隊尾元素。顯然退出佇列的次序也只能是 a 1 , a 2 , …, a n ,即佇列的修改是依先進先出的原則進行的,如圖 3-5 所示。

這裡寫圖片描述

基本操作

  1. 建立新佇列
  2. 判空
  3. 進隊
  4. 出隊
  5. 清空隊
  6. 獲得隊頭元素
  7. 遍歷隊
  8. 銷燬隊
  9. 隊長

順序佇列

利用一組連續的儲存單元 ( 一維陣列 ) 依次存放從隊首到隊尾的各個元素,稱為順序佇列。對於佇列,和順序棧相類似,也有動態和靜態之分。這裡介紹靜態順序佇列.其型別定義如
下:

typedef int datatype;
#define MAX_QUEUE_SIZE 100
typedef struct queue
{ 
    datatype queue_array[MAX_QUEUE_SIZE];
    int front;
    int rear;
}sp_queue;

設立一個隊首指標 front ,一個隊尾指標rear ,分別指向隊首和隊尾元素。
◆ 初始化: front=rear =0。
◆ 入隊:將新元素插入 rear 所指的位置,然後rear 加 1 。
◆ 出隊:刪去 front 所指的元素,然後加 1 並返回被刪元素。
◆ 佇列為空: front=rear 。
◆ 隊滿: rear = MAX_QUEUE_SIZE - 1 或front=rear 。

在非空佇列裡,隊首指標始終指向隊頭元素,而隊尾指標始終指向隊尾元素的下一位置。順序佇列中存在“假溢位”現象。因為在入隊和出隊操作中,頭、尾指標只增加不減小,致使被刪除元素的空間永遠無法重新利用。因此,儘管佇列中實際元素個數可能遠遠小於陣列大小,但可能由於尾指標巳超出向量空間的上界而不能做入隊操作。該現象稱為假溢位。如圖 3-6 所示是陣列大小為 5 的順序佇列中隊首、隊尾指標和佇列中元素的變化情況。
假溢位現象

程式碼實現

/* 順序佇列介面定義標頭檔案*/
#define true 1
#define false 0


/* 隊的最大長度 */
#define MAX_QUEUE_SIZE 100
 

/* 佇列的資料型別 */
typedef int datatype;

/* 靜態鏈的資料結構 */
typedef struct queue{
    datatype sp_queue_array[MAX_QUEUE_SIZE];
    /* 隊頭 */
    int front;
    /* 隊尾 */
    int rear;
}sp_queue;


/* 靜態順序鏈的介面定義 */


/* 靜態鏈的初始化 */
sp_queue queue_init();

/* 判斷佇列是否為空,若為空
 * 返回true
 * 否則返回false
*/
int queue_empty(sp_queue q);


/* 插入元素e為隊q的隊尾新元素 
 * 插入成功返回true
 * 隊滿返回false
*/
int queue_en(sp_queue *q, datatype e);


/* 隊頭元素出隊
 * 用e返回出隊元素,並返回true
 * 若隊空返回false
*/
int queue_de(sp_queue *q, datatype *e);

/* 清空隊 */
void queue_clear(sp_queue *q);


/* 獲得隊頭元素
 * 佇列非空,用e返回隊頭元素,並返回true
 * 否則返回false
*/
int get_front(sp_queue, datatype *e );


/* 獲得隊長 */
int queue_len(sp_queue q);

/* 遍歷隊 */
void queue_traverse(sp_queue q, void(*visit)(sp_queue q));


void visit(sp_queue s);


/* 介面實現檔案 */
#include<stdio.h>
#include<stdlib.h>
#include"sp_queue.h"


sp_queue queue_init()
{
    sp_queue q;
    q.front = q.rear = 0;
    return q;
}



int queue_empty(sp_queue q)
{
    return q.front == q.rear;
}


int queue_en(sp_queue *q, datatype e)
{
    /* 隊滿 */
    if (q -> rear == MAX_QUEUE_SIZE)
        return false;

    /* 入隊 */
    q -> sp_queue_array[q -> rear] = e;
    printf("q.sp_queue_array[%d]=%d\n", q -> rear, e);
    q -> rear += 1;
    return true;

}


int queue_de(sp_queue *q, datatype *e)
{
    /* 隊空 */
    if(queue_empty(*q))
        return false;

    /* 出隊 */
    q -> rear -= 1;
    *e = q -> sp_queue_array[q -> rear];
    return true;
}


void queue_clear(sp_queue *q)
{
    q -> front = q -> rear = 0;
}


int get_front(sp_queue q, datatype *e)
{
    /* 隊空 */
    if(q.front == q.rear)
        return false;

    /* 獲取隊頭元素 */
    *e = q.sp_queue_array[q.front];
    return true;
}


int queue_len(sp_queue q)
{
    return (q.rear - q.front);
}


void queue_traverse(sp_queue q, void (*visit)(sp_queue q))
{
    visit(q);
}

void visit(sp_queue q)
{
    /* 隊空 */
    if (q.front == q.rear)
        printf("佇列為空\n");

    int temp = q.front;
    while(temp != q.rear)
    {
        printf("%d ",q.sp_queue_array[temp]);
        temp += 1;
    }
    printf("\n");
}



int main()
{
    sp_queue q = queue_init();
    queue_en(&q, 1);
    queue_en(&q, 2);
    printf("length=%d\n", queue_len(q));
    queue_en(&q, 3);
    printf("length=%d\n", queue_len(q));
    queue_en(&q, 4);
    printf("length=%d\n", queue_len(q));
    queue_en(&q, 5);
    printf("length=%d\n", queue_len(q));
    queue_en(&q, 6);
    printf("length=%d\n", queue_len(q));
    queue_traverse(q,visit);
    datatype *e = (datatype *)malloc(sizeof(*e));
    queue_de(&q,e);
    printf("queue_de(),e=%d length=%d\n", *e, queue_len(q));
    queue_traverse(q, visit);
    queue_clear(&q);
    queue_traverse(q, visit);
    printf("length:%d\n", queue_len(q));
}

注意:結構體變數作為函式的引數和其他普通變數一樣,值只會在函式體內被修改,想要通過函式更改結構體的值,可以通過結構體指標作為函式的引數實現.

佇列的鏈式表示和實現

佇列的鏈式儲存結構簡稱為鏈佇列,它是限制僅在表頭進行刪除操作和表尾進行插入操作的單鏈表。需要兩類不同的結點:資料元素結點,佇列的隊
首指標和隊尾指標的結點,如圖 3-8 所示。
這裡寫圖片描述
資料元素結點型別定義:

typedef struct q_node{
    datatype data;
    struct q_node *next;
}q_node;

指標結點型別:

typedef struct {
    q_node *front;
    q_node *rear;   
}link_queue;

鏈隊運算及指標變化

鏈隊的操作實際上是單鏈表的操作,只不過是刪除
在表頭進行,插入在表尾進行。插入、刪除時分別修改
不同的指標。鏈隊運算及指標變化如圖 3-9 所示。

這裡寫圖片描述

程式碼實現

/* 鏈式棧介面的定義標頭檔案 */
#define true 1
#define false 0


/* 佇列的資料型別 */
typedef int datatype;

/* 靜態鏈的資料結構 */
typedef struct q_node{
    datatype data;
    struct q_node *next;
}q_node,*link_node;

typedef struct l_queue{
    /* 隊頭指標 */
    q_node *front;
    /* 隊尾指標 */
    q_node *rear;
}*link_queue;


/* 靜態順序鏈的介面定義 */


/* 靜態鏈的初始化 */
link_queue queue_init();

/* 判斷佇列是否為空,若為空
 * 返回true
 * 否則返回false
*/
int queue_empty(link_queue q);

/* 插入元素e為隊q的隊尾新元素 
 * 插入成功返回true
 * 隊滿返回false
*/
int queue_en(link_queue q, datatype e);


/* 隊頭元素出隊
 * 用e返回出隊元素,並返回true
 * 若隊空返回false
*/
int queue_de(link_queue q, datatype *e);

/* 清空隊 */
void queue_clear(link_queue q);

/* 銷燬隊 */
void queue_destroy(link_queue q);

/* 獲得隊頭元素
 * 佇列非空,用e返回隊頭元素,並返回true
 * 否則返回false
*/
int get_front(link_queue q, datatype *e );


/* 獲得隊長 */
int queue_len(link_queue q);

/* 遍歷隊 */
void queue_traverse(link_queue q, void(*visit)(link_queue q));


void visit(link_queue q);



/* 介面的實現檔案 */
#include<stdio.h>
#include<stdlib.h>
#include"lp_queue.h"



link_queue queue_init()
{
    /* 新建頭結點 */
    link_node new_node = (link_node)malloc(sizeof(q_node));
    new_node -> next = NULL;
    /* 指標結點 */
    link_queue q = (link_queue)malloc(sizeof(*q));
    q -> front = q -> rear = new_node;
    return q;
}


int queue_empty(link_queue q)
{
    return q -> front == q -> rear;
}


int queue_en(link_queue q, datatype e)
{
    /* 新建資料結點 */
    link_node new_node = (link_node)malloc(sizeof(q_node));
    /* 記憶體分配失敗 */
    if(!new_node)
        return false;
    new_node -> data = e;
    q -> rear -> next = new_node;
    q -> rear = new_node;
    return true;
}

int queue_de(link_queue q, datatype *e)
{
    /* 佇列為空 */
    if (q -> front == q -> rear)
        return false;

    *e = q -> front -> next -> data;
    link_node temp = q -> front -> next;
    q -> front -> next = temp -> next;
    /* 防止丟失尾指標 */
    if (temp == q.rear -> next)
        q -> rear = q -> front; 
    free(temp);
    temp = NULL;
    return true;
}

void queue_clear(link_queue q)
{
    /* 頭結點 */
    link_node head = q -> front -> next;
    head -> next = NULL;
    q -> front = q -> rear = head;
    /* 第一個結點 */
    link_node temp = head -> next;
    while(temp)
    {
        link_node p = temp;
        temp = p -> next;
        free(p);
        p = NULL;
    }
}


void queue_destroy(link_queue q)
{
    queue_clear(q);
    free(q);
    q = NULL;
}


int get_front(link_queue q, datatype *e)
{
    /* 隊為空 */
    if (q -> front == q -> rear)
        return false;

    *e = q -> front -> next -> data;
    link_node temp = q -> front -> next;
    q -> front -> next = temp -> next;
    free(temp);
    temp = NULL;
    return true;
}


int queue_len(link_queue q)
{
    /* 頭結點 */
    link_node p = q -> front -> next;
    /* 計數器 */
    int count = 0;
    while(p)
    {
        count += 1;
        p = p -> next;
    }
    return count;
}


void queue_traverse(link_queue q, void(*visit)(link_queue q))
{
    visit(q);
}

void visit(link_queue q)
{
    /* 頭結點 */
    link_node p = q -> front -> next;
    if(!p)
    {
        printf("佇列為空");
    }
    while(p)
    {
        printf("%d ", p -> data);
        p = p -> next;
    }
    printf("\n");
}

int main()
{
    link_queue q = queue_init();
    queue_en(q, 1);
    queue_en(q, 2);
    printf("length=%d\n", queue_len(q));
    queue_en(q, 3);
    printf("length=%d\n", queue_len(q));
    queue_en(q, 4);
    printf("length=%d\n", queue_len(q));
    queue_en(q, 5);
    printf("length=%d\n", queue_len(q));
    queue_en(q, 6);
    printf("length=%d\n", queue_len(q));
    queue_traverse(q,visit);
    datatype *e = (datatype *)malloc(sizeof(*e));
    queue_de(q,e);
    printf("queue_de(),e=%d length=%d\n", *e, queue_len(q));
    queue_traverse(q, visit);
    queue_clear(q);
    queue_traverse(q, visit);
    printf("length:%d\n", queue_len(q));
}

執行結果:
這裡寫圖片描述

相關推薦

佇列及其c語言實現

佇列的基本概念 佇列 (Queue) :也是運算受限的線性表。是一種先進先出 (First In First Out ,簡稱 FIFO) 的線性表。只允許在表的一端進行插入,而在另一端進行刪除。 隊首 (front) :允許進行刪除的一端稱為隊首。 隊尾

棧和佇列：2.佇列（Queue）及其C語言實現

佇列是線性表的一種，在操作資料元素時，和棧一樣，有自己的規則：使用佇列存取資料元素時，資料元素只能從表的一端進入佇列，另一端出佇列，如圖1。 圖1 佇列示意圖 稱進入佇列的一端為“隊尾”；出佇列的一端為“隊頭”。資料元素全部由隊尾陸續進佇列，由隊頭陸續出佇列。 佇

基數排序及其C語言實現

基數排序不同於之前所介紹的各類排序，前邊介紹到的排序方法或多或少的是通過使用比較和移動記錄來實現排序，而基數排序的實現不需要進行對關鍵字的比較，只需要對關鍵字進行“分配”與“收集”兩種操作即可完成。 例如對無序表{50，123，543，187，49，30，0，2，11，100}進行基數排序，由於每個關鍵字都

氣泡排序演算法（起泡排序）及其C語言實現

起泡排序，別名“氣泡排序”，該演算法的核心思想是將無序表中的所有記錄，通過兩兩比較關鍵字，得出升序序列或者降序序列。 例如，對無序表{49，38，65，97，76，13，27，49}進行升序排序的具體實現過程如圖 1 所示： 圖 1 第一次起泡 如圖 1 所示是對無序表的第一次起泡排序，最終將無序

PID演算法及其C語言實現

在我們的日常生活中，總有這樣的例子，我們在走路的時候，基本上是不能閉著眼睛的，即使視力出現故障，也要有導盲犬、探路棍、盲道等措施彌補，所有這些措施其實都是提供了一個叫反饋環節的環節。我們的大腦收集到反饋資訊以後，一定會進行負反饋處理。走路的時候，眼睛看路，大腦會告訴你一個訊號：偏左了，偏右了，然後讓

資料結構：迴圈佇列（C語言實現）

生活中有很多佇列的影子，比如打飯排隊，買火車票排隊問題等，可以說與時間相關的問題，一般都會涉及到佇列問題；從生活中，可以抽象出佇列的概念，佇列就是一個能夠實現“先進先出”的儲存結構。佇列分為鏈式佇列和靜態佇列；靜態佇列一般用陣列來實現，但此時的佇列必須是迴圈佇列，否則

順序迴圈佇列的c語言實現

1. 迴圈佇列的順序儲存結構 typedef struct { QElemType data[MAXSIZE]; int front; /* 頭指標 */ int rear; /* 尾指標，若佇列不空，指向佇列尾元素的下一個位置 */ }SqQueue;

資料結構（嚴蔚敏）之五——迴圈佇列（c語言實現）

在這裡我先強調幾點概念： 1、在非空佇列中，頭指標始終指向佇列頭元素，而尾指標始終指向佇列尾元素的下一個位置。 2、在單佇列中我們判斷佇列是否為空的條件是：Q.front==Q.rear;而在迴圈佇列

佇列的C語言實現（通過核心連結串列）

0. 環境說明 本文的實驗環境是： win7作業系統+Keil 5 IDE. 非常適合嵌入式軟體開發 1. 打造自己的“list.h” 在微控制器程式開發中，有時候會用到佇列。能否設計一個通用的佇列呢？我想，可以把核心連結串列用起來。 以下程式碼是我

資料結構---佇列（C語言陣列實現）

https://blog.csdn.net/morixinguan/article/details/51374296 資料結構---佇列（C語言陣列實現）   佇列是先進先出的過程。簡單地畫一幅畫來描述一下佇列： 一個簡單的、由陣列實現的佇列，可以由以下幾種最基本的操

線性表及其應用C語言實現（資料結構複習最全筆記）

一、順序表的表示與實現 1.線性表的順序結構定義 #define LIST_INIT_SIZE 100 //線性表儲存空間的初始分配量 #define LISTINCREMENT 10 //線性表儲存空間的分配增量 typedef struct { ElemType* el

C語言實現八大排序演算法詳解及其效能之間的

概述 排序是資料結構中的重要一節，也是演算法的重要組成部分。主要分為內部排序以及外部排序，今天我們講內部排序，也就是八大排序。 插入排序 直接插入排序 演算法思想 演算

C語言實現棧和佇列(棧和佇列的基本操作)

棧： 棧：棧（stack）又名堆疊，它是一種運算受限的線性表。其限制是僅允許在表的一端進行插入和刪除運算。這一端被稱為棧頂，相對地，把另一端稱為棧底。 特點：先進後出 stack.h #pragma once #include <stdio.h> #include <

[linux]二叉樹的建立及其遞迴遍歷（C語言實現)

基礎知識 二叉樹的特點： 每一個節點最多有兩棵子樹，所以二叉樹中不存在度大於2的節點，注意，是最多有兩棵，沒有也是可以的 左子樹和右子樹是有順序的，次序不能顛倒，這點可以在哈夫曼編碼中體現， 順序不同編碼方式不同 -即使樹中某個節點中只有一個子樹的花，也要區分它是左子樹還是右子樹

軟考：資料結構基礎——迴圈佇列C語言實現

  迴圈佇列得實現： 1.     在入隊和出隊時，我們通過      q->rear = (q->rear +1)%MAX_LENTH 來實現迴圈入隊     q

c語言實現佇列舉例

標頭檔案 /* * my_queue.h * * Created on: Dec 3, 2018 * Author: lgh */ #ifndef INCLUDE_MY_QUEUE_H_ #define INCLUDE_MY_QUEUE_H_ #include <std

鏈佇列的基本操作及C語言實現

佇列，可以理解為遵循“先進先出”原則的線性表，即資料元素依次從表的一端進，從表的另一端出。 鏈佇列，即用鏈式的儲存結構（連結串列）實現的佇列，其實現思想是：用連結串列的表頭一端表示佇列的隊頭，另一端表示佇列的隊尾（實現程式碼更加簡單）。 反過來的話，當佇列增加元素時，要採用頭插法，在刪除資料元素的時候，需

排序及其應用C語言實現（資料結構複習最全筆記）(期末複習最新版)

排序 關於排序給兩篇不錯的部落格參考： http://www.cnblogs.com/eniac12/p/5329396.html https://www.cnblogs.com/eniac12/p/5332117.html 知識前提 關於內外排序 內排序：指在排序

查詢及其應用C語言實現（資料結構複習最全筆記）

所謂查詢(Search)又稱檢索，就是在一個數據元素集合中尋找滿足某種條件的資料元素。查詢在計算機資料處理中是經常使用的操作。查詢演算法的效率高低直接關係到應用系統的效能。查詢的方法很多，本章將介紹一些常用的查詢演算法，主要有：線性表的查詢、樹表的查詢和散列表的查詢，並對有關的演算法進行效能分析

圖及其應用c語言實現（資料結構複習最全筆記）（期末複習最新版）

圖 一.圖的基本概念 1.圖的定義 圖是由頂點(vertex)集合及頂點間的關係組成的一種資料結構。Graph=(V,E)Graph=(V,E)其中，頂點集合 V={x|x∈某個物件資料集}V={x|x∈某個物件資料集} 是有窮非空集合；E={(x,y)|x,y∈V}E={(x,y