2. 程式人生 > >數據結構——棧和隊列相關算法實現

數據結構——棧和隊列相關算法實現

阿新 • • 發佈：2018-04-19
建立 分配 ron deque 限定 () 指向 參考 empty

數據結構棧和隊列的基本算法實現

限定性線性表——棧

棧的定義

棧作為一種限定性的線性表，是將線性表的插入和刪除操作限制為僅在表的一端進行。

基本算法演示

/*
棧的常見操作：
    1.初始化棧
    2.元素進棧
    3.元素出棧
    4.棧的遍歷
    5.判斷棧是否為空棧
    6.清空整個棧 


*/ 
# include <stdio.h>
# include <stdlib.h>

typedef struct Node
{
    int date;
    struct Node * pNext;
}NODE,* PNODE;

typedef struct Stack
{
    PNODE pTop;
    PNODE pBottom;
}STACK, * PSTACK;




void init(PSTACK pS)
{
    pS->pTop = (PNODE)malloc(sizeof(NODE));
    if (NULL == pS->pTop)
    {
        printf("動態內存分配失敗");
        exit(-1);
        
    }
    else
    {
        pS->pBottom = pS->pTop;//如果分配成功的話，這兩個節點都指向 同一個節點（頭節點） 
        pS->pTop->pNext = NULL; //模擬最後的那個“頭節點”pS->Bottom->pNext = NUll 也是一樣 
    }
    
}


void push(PSTACK pS, int val)
{
    PNODE pNew = (PNODE)malloc(sizeof(NODE));
    pNew->date = val;
    pNew->pNext = pS->pTop;//按照邏輯來的話，進棧時，新的元素會在棧頂，所以要pNext->pTop 
    pS->pTop = pNew; //把新的入棧的元素作為棧的top 
    
} 

void traverse(PSTACK pS)
{
    PNODE p = pS->pTop;
    while (p != pS->pBottom)
    {
        printf("%d ",p->date);
        p = p->pNext;
    }
    printf("\n");
        
    return;
} 

bool empty(PSTACK pS)
{
    if(pS->pTop == pS->pBottom)
         return true; //如果為空，返回true（證明是空的） 
    else
        return false;
} 

//把pS所指向的棧出棧一次，並把出棧的元素存入pVal形參所指向的變量中，
//如果出棧成功，返回true，否則返回false 
bool pop(PSTACK pS,int * pVal)
{
    if (empty(pS))//pS 本身存放的就是S的地址，直接返回給empty()函數 
    {
        return false;
    }
    else
    {
        //首先需要一個指針r來指向 棧頂元素，但是如果是pS->pTop = pS->pNext 的話
        //內存就沒有釋放，造成內存泄漏，所以這個方法不可取。 
          
        PNODE r = pS->pTop;
        *pVal = r->date;
        pS->pTop = r->pNext;//r 指向棧頂，所以把r的next域賦給棧頂
        free(r);
        r = NULL; 
        return true;
         
        
    }
}
//清空 

void clear(PSTACK pS)
{
    if(empty(pS))
    {
        return;
    }
    else
    {
        PNODE p = pS->pTop;
        PNODE q = NULL;
        while(p!=pS->pBottom)
        {
            q = p->pNext;
            free(p);
            p = q;  
            
        }
        //清空之後pTop 的值一定要改寫
         pS->pTop = pS->pBottom; 
        
    }
    
}




int main(void)
{
    STACK S; 
    int val;
    init(&S);//對棧進行初始化 ,去地址才會放入元素 
    push(&S,1);
    push(&S,2);
    push(&S,3);
    push(&S,4);
    push(&S,5);
    push(&S,6);
    traverse(&S);
    clear(&S); //清空之後就會提示出棧失敗 

    if(pop(&S,&val))//需要判斷是否為空，如果空了就無法出棧，所以需要一個返回值，但是進棧不會滿的。 
    {
        printf("出棧成功，出棧的元素是%d\n",val);
    }
    else
    {
        printf("出棧失敗!\n"); 
    }
    traverse(&S); 
    return 0;
}

運行演示

技術分享圖片

算法小結

所有的算法已經給出，值得註意的是在clear()算法中 PNODE p = pS->pTop;PNODE q = NULL; 定義了兩個指針，以為一個被free掉後就無法進行操作了，對於pop()函數就沒有這個問題，因為它只執行了一次 ，也就是說，只進行了一次出棧操作，然後操作完成之後才把r指針給free掉的，所以一個指針就可以完成這個操作。
技術分享圖片

限定性線性表——隊列

隊列是另外一種限定性的線性表，它只允許在表的一端插入元素，在另外一端刪除元素。

基本算法演示（鏈隊列）

/*
隊列的常見操作：
    1.初始化隊列
    2.元素進隊列
    3.元素出隊列
    4.隊列的遍歷

*/ 

#include <stdio.h>
#include <stdlib.h> 

typedef struct Node

{
    int date;
    struct Node * pNext;
}NODE, * PNODE;//LInkQueueNode


typedef struct LinkQueue
{
    PNODE pFront;
    PNODE pRear;
}LINKQUEUE,* PLINKQUEUE;

bool InitQueue(PLINKQUEUE pQ)
{
    pQ->pFront= (PNODE)malloc(sizeof(NODE));
    if (NULL == pQ->pFront)
    {
        printf("動態內存分配失敗！");
        exit(-1);
        
    }
    else if(NULL != pQ->pFront)
    {
        pQ->pRear = pQ->pFront;
        pQ->pFront->pNext = NULL;
        return (true);
    }
    else
        return (false);//溢出 
    
    
}

bool EnterQueue(PLINKQUEUE pQ ,int x)
{
    
    
    PNODE pNew = (PNODE)malloc(sizeof(NODE));
    if(pNew != NULL)
    {
    pNew->date = x;
    pNew->pNext = NULL;
    pQ->pRear->pNext = pNew;
    pQ->pRear = pNew;
    return (true); 
    
    }
    else
        return false;

} 

void traverse(PLINKQUEUE pQ)
{
    PNODE p = pQ->pFront->pNext;//註意這個地方隊列和棧的不同
                                //PNODE p = pS->pTop;   while (p != pS->pBottom)  這是棧的條件 

    while (p)
    {
        printf("%d ",p->date);
        p = p->pNext;
    }
    printf("\n");
        
    return;
} 

bool DeleteQueue(PLINKQUEUE pQ,int * x)   //出隊
{
    PNODE p;
    if (pQ->pRear==NULL)      //隊列為空
        return false;
    p=pQ->pFront;            //p指向第一個數據節點
    if (pQ->pFront==pQ->pRear)  //隊列中只有一個節點時
        pQ->pFront=pQ->pRear=NULL;//必須要更改值，不然指針就會指向他處 
    else                    //隊列中有多個節點時
        pQ->pFront=pQ->pFront->pNext;
    *x = p->date;
    free(p);
    return true;
}


int main()
{
    LINKQUEUE Q;
    int x;
    InitQueue(&Q);
    EnterQueue(&Q,10);
    EnterQueue(&Q,20);
    EnterQueue(&Q,30);
    EnterQueue(&Q,40);
    traverse(&Q);
    DeleteQueue(&Q,&x);
    traverse(&Q);
    return 0; 
}

運行演示

技術分享圖片

算法小結

隊列的操作和棧的操作基本原理上是差不多的，值得註意的是再對隊列進行遍歷的話和棧的遍歷稍微有點差別。其中需要註意的地方已經在代碼塊中進行了說明。

基本算法演示（循環隊列）

/*
    1.循環隊列初始化
    2.循環隊列進隊
    3.循環隊列出隊
    4.循環隊列遍歷
    5.循環隊列長度
*/

// 實現循環隊列 
#include <stdio.h>
#include <stdlib.h> 
#define MaxSize 21
typedef int ElementType;

typedef struct  {
    int data[MaxSize];    
    int rear;      // 隊尾指針 
    int front;     // 隊頭指針 
}Queue,*L;

void InitQueue(Queue * Q )
{
    Q->front = Q->rear = 0;
}
// 元素入隊
void AddQ(Queue *PtrQ, int item)
{
    if( (PtrQ->rear+1)%MaxSize == PtrQ->front )
    {
        printf("隊列滿.\n");
        return;
    }
    PtrQ->rear = (PtrQ->rear+1) % MaxSize;
    PtrQ->data[PtrQ->rear] = item; 
}


// 刪除隊頭元素並把隊頭元素返回
int DeleteQ( Queue *PtrQ )
{    
    if( PtrQ->front == PtrQ->rear )
    {
        printf("隊列空.\n");
        return -1;
    } 
    else {
        PtrQ->front = (PtrQ->front+1) % MaxSize;
        return PtrQ->data[PtrQ->front];
    }
}


// 隊列元素的遍歷
void print(Queue *PtrQ)
{
    int i = PtrQ->front;
    if( PtrQ->front == PtrQ->rear )
    {
        printf("隊列空.");
        return;
    }
    printf("隊列存在的元素如下:");
    while( i != PtrQ->rear)
    {
        printf("%d ", PtrQ->data[i+1]);
        i++;
        i = i % MaxSize;
    }
    return;
}

int len(Queue *PtrQ)
{
    return (PtrQ->rear-PtrQ->front+MaxSize)%MaxSize;
}
int main()
{
    Queue  Q;    //註意不是Queue * Q; 因為數組本身就是地址吧~（emmmm,應該是，求大佬解答） 
     int length;
     length = len(&Q);             //用Queue * Q 的話會報錯 
    InitQueue(&Q);
    AddQ(&Q,1);
    AddQ(&Q,2);
    AddQ(&Q,3);
    AddQ(&Q,4);
    
    print(&Q);
    DeleteQ(&Q);//出隊一次 
    print(&Q);
    printf("\n循環隊列的長度為%d",length);
    return 0;
}

運行演示

技術分享圖片

算法小結

循環隊列和鏈隊列基本是一致的，之所以引入“循環隊列”是因為，對於順序列會存在“假溢出的現象”。相關概念不多做解釋，原理主要在數據結構-用C語言描述（第二版）[耿國華] 一書的p101-103。值得註意的是，在main方法中和鏈隊列不同的是Queue Q;個人認為是利用數組模擬的原因，因為數組本身也是利用地址傳值嘛。關於循環隊列長度計算：當rear大於front時，循環隊列的長度：rear-front，當rear小於front時，循環隊列的長度:分為兩類計算 0+rear和Quesize-front即rear-front+Quesize。總的來說，總長度是(rear-front+Quesize)%Quesize

循環鏈表拓展

頭節點循環鏈表

帶頭結點的循環鏈表表示隊列, 並且只設一個指針指向隊尾元素結點， 試編寫相應的隊列初始化,入隊列和出隊列的算法。

/*  數據結構算法題(假設以帶頭結點的循環鏈表表示隊列,
 *  並且只設一個指針指向隊尾元素結點(註意不設頭指針)
 *  試編寫相應的隊列初始化,入隊列和出隊列的算法!) 
 */

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#define OK 1
#define ERROR 0

typedef int QElemType;
typedef int Status;

typedef struct QNode
{
    QElemType data;
    struct QNode * rear;
    struct QNode * next;
}QNode,*LinkQueue;


//鏈式隊列的初始化
Status InitLinkQueue(LinkQueue * L)
{

    (*L)=(LinkQueue)malloc(sizeof(QNode));
    if((*L)==NULL)
    {
        printf("內存分配失敗！\n");
        return OK;
    }
    (*L)->rear=(*L);
    return OK;
}

//鏈式隊列的建立
Status Create(LinkQueue * L,int n)
{
    srand(time(0));
    LinkQueue P;
    for(int i=0;i<n;i++)
    {
        P=(LinkQueue)malloc(sizeof(QNode));
        P->data=rand()%100+1;
        (*L)->rear->next=P;
        (*L)->rear=P;
    }
    P->next=(*L);
    return OK;
}

//入隊操作
Status EnQueue(LinkQueue * L,QElemType e)
{
    LinkQueue P;
    P=(LinkQueue)malloc(sizeof(QNode));
    P->data=e;
    P->next=(*L);
    (*L)->rear->next=P;
    (*L)->rear=P;
    return OK;
}


//出隊操作
Status DeQueue(LinkQueue * L,QElemType * e)
{
    LinkQueue temp;
    *e=(*L)->next->data;
    temp=(*L)->next;
    (*L)->next=(*L)->next->next;
    delete(temp);
    return OK;

}

//輸出
void Print(LinkQueue * L)
{
    LinkQueue P;
    P=(*L)->next;
    printf("輸出元素:\n");
    while(P!=(*L))
    {
        printf("%d ",P->data);
        P=P->next;
    }
    printf("\n");
}


int main()
{
    LinkQueue L;
    int ElemNumber;
    QElemType EnElem,DeElem;
    InitLinkQueue(&L);
    printf("請輸入元素個數：\n");
    scanf("%d",&ElemNumber);
    Create(&L,ElemNumber);
    Print(&L);
    printf("請輸入入隊元素：\n");
    scanf("%d",&EnElem);
    EnQueue(&L,EnElem);
    Print(&L);
    printf("出隊操作，並返回出隊元素：\n");
    DeQueue(&L,&DeElem);
    printf("出隊元素為：%d\n",DeElem);
    Print(&L);
    return 0;
}

參考文獻

  • 帶頭結點的循環鏈表表示隊列, 並且只設一個指針指向隊尾元素結點， 試編寫相應的隊列初始化,入隊列和出隊列的算法
  • 數據結構-用C語言描述（第二版）[耿國華]
  • 循環隊列長度計算

數據結構——棧和隊列相關算法實現

相關推薦

數據結構——棧和隊列相關算法實現

建立 分配 ron deque 限定 () 指向 參考 empty 數據結構棧和隊列的基本算法實現 限定性線性表——棧 棧的定義 棧作為一種限定性的線性表，是將線性表的插入和刪除操作限制為僅在表的一端進行。 基本算法演示 /* 棧的常見操作： 1.初始化棧

基本數據結構 - 棧和隊列

基本 tac 另一個 image 時間 直接 src 動態 def 摘要 　　本章介紹了幾種基本的數據結構，包括棧、隊列、鏈表以及有根樹，討論了使用指針的簡單數據結構來表示動態集合。本章的內容對於學過數據結構的人來說，沒有什麽難處，簡單的總結一下。 1、棧和隊列 　　棧和隊

C#數據結構—棧和隊列

() inf void 完全 ilo 是否為空 ide pen 判斷 一：棧 　　棧和隊列也是線性結構，線性表、棧和隊列這三種數據結構的數據元素以及數據元素間的邏輯關系完全相同，差別是線性表的操作不受限制，而棧和隊列的操作受到限制。棧的操作只能在表的一端進行，隊列的插入操作

大話數據結構 棧與隊列

引用 pty 建議 自己的 clas 有一個 empty 函數 我們 棧是限定僅在表尾進行插入和刪除操作的線性表。 我們把允許插入和刪除的一端稱為棧頂，另一端稱為棧底，不含任何數據元素的棧稱為空棧。棧又稱為後進先出的線性表，簡稱LIFO結構。 棧的插入操作，叫作進棧，也稱壓

數據結構--棧與隊列

隊列的實現 存儲空間 com 動態分配 數組 ati ont blog linklist 一 .棧 一.順序棧的實現A.棧的定義1.棧是一種特殊的線性表2.棧僅能在線性表的一端進行操作a.棧頂：允許操作的一端b.棧底：不允許操作的一端B.棧的特性後進先出(圖示)C.棧的操作

數據結構 棧與隊列知識小結

沒有 一個 修改 先進先出 知識 存儲 col 自己實現 strong 本章介紹了兩種特殊的線性表：棧和隊列，主要內容如下： （1）棧是限定僅在表尾進行插入和刪除的線性表，又稱為後進先出的的線性表。 兩種存儲結構：（順序表示）順序棧、鏈棧（鏈式表示）。 主要操作：進棧

數據結構(08)_隊列和棧的相互實現

opera ron 準備 pub clas 入隊 -o 直接 pre 1. 棧的隊列的相互實現 思考：棧和隊列在實現上非常相似，能否用相互實現？ 1.1. StackToQueue 用棧實現隊列等價於用“後進先出”的特性實現“先進先出”的特性.實現思路： 準備兩個棧用於實

JavaScript學習總結(二十一)——使用JavaScript的數組實現數據結構中的隊列與堆棧

運行 icu wql dem aix gaps sdg kml sam 今天在項目中要使用JavaScript實現數據結構中的隊列和堆棧，這裏做一下總結。 一、隊列和堆棧的簡單介紹 1.1、隊列的基本概念 　　隊列:是一種支持先進先出(FIFO)的集合,即先被插入的數據,先

【12】python 棧型數據結構模擬、隊列型數據結構模擬

出隊 分隔 ima bubuko pop nbsp info image img 一、壓棧操作模擬 #__author:"吉*佳" #date: 2018/10/21 0021 #function:棧 # 棧：即是先進後出的一種數據結構 # （1）模擬壓棧操作 st

數據結構之靜態隊列（循環隊列）

div int turn ont malloc r+ nbsp ron traverse # include <stdio.h> # include <malloc.h> typedef struct Queue { int * pBas

數據結構實驗之隊列一:排隊買飯

宋體 nis 小孩 pos tom ora spa ini end 數據結構實驗之隊列一:排隊買飯 題目描寫敘述 中午買飯的人特多,食堂真是太擁擠了,買個飯費勁,理

轉載：數據結構 二項隊列

在一起 最小 個性 .cn str 算法與數據結構 lan ren pan 0）引論 左堆的合並，插入，刪除最小的時間復雜度為O(logN)。二項隊列就是為了對這些結果進一步提高的一種數據結構。利用二項隊列，這三種操作的最壞時間復雜度為O(logN)，但是插入的平均時間復

Python與數據結構[2] -> 隊列/Queue[0] -> 數組隊列的 Python 實現

return 閱讀 位置 pri end 實現 http family 隊列實現 隊列 / Queue 數組隊列 數組隊列是隊列基於數組的一種實現，其實現類似於數組棧，是一種FIFO的線性數據結構。 Queue: <--| 1 | 2 | 3

數據結構 -- 鏈式隊列

是否 eno () empty value nbsp kqueue 先進先出 class 隊列：先進先出的數據結構 C#版本： 1 namespace Queue 2 { 3 interface IQueue<T> 4 {

數據結構設計——用隊列實現迷宮問題的求解

efi urn sleep color visit null ima != 圖片 1，問題描述 以一個m*n的長方陣表示迷宮，0和1分別表示迷宮中的通路和障礙。迷宮問題要求求出從入口（1，1）到出口（m,n）的一條通路，或得出沒有通路的結論。 基本要求： 首先實現一個以鏈

數據結構(07)_隊列

MF city 技術分享 HR vpd oss RoCE 常用操作 cit 1. .隊列的概念和實現 1.1.隊列的概念 隊列是一種特殊的線性表，僅能在線性表的兩端進行操作。 -隊頭（front）取出數據元素的一端； -隊尾（rear）插入數據元素的一端。隊列的特性：隊列

數據結構--實驗2--隊列的操作

定義 ase int seq *** all color 最大 emp 1 #include"stdio.h" 2 #include"malloc.h" 3 typedef int datatype; 4 5 #define MAXSIZE 50 /

c++刷題（3/100）數獨，棧和隊列

彈出 iter char col 編寫 實現 滑動窗口 title 表示 stack的基本操作 ? s.size()：返回棧中的元素數量 ? s.empty()：判斷棧是否為空，返回true或false ? s.push(元素)：返回對棧頂部“元素”的可變（可修改）引用 ?

簡單數據結構總結——單調隊列

個數 text 手寫 ora 介紹 解決 但是 總結 一個 單調隊列一般是具有單調性的隊列廢話 視具體題目而定，單調隊列有單調遞增和單調遞減兩種，一般來講，隊列的隊首是整個隊列的最大值或最小值 單調隊列可以解決許多問題，而且可以用來優化DP，但是這裏不講因為我還不會‘ 下面

python數據結構之雙隊列（二）

self for __init__ pri solid pen odin __name__ urn 書接上文，雙端隊列區別於單隊列為：雙端隊列可以對隊列頭和尾部同時進行操作，單隊列不行#coding:utf-8 class DoubleQueue(object):