數據結構之棧定義及基本操作實現

 

　　終於有可以有時間寫點數據結構的學習總結了，前段時間一直在緊張的忙一些項目，都沒有空出時間來學習數據結構，現在終於可以稍微喘口氣了，還是數據結構有意思，這兩天看了點棧的東西，寫下來總結一下，有錯誤的地方希望看到的朋友指出來，感激不盡。

　　根據學習，棧就是一種線性數據結構，棧的運算只能在表的一段進行，所以這種數據結構具有“后進先出”的特點。

　　接下來是棧的c語言實現。其中棧由一個top節點和bottom節點組成，這兩個節點分別指向棧的頂部和底部。其中棧的組成結點是由結構體實現，結構體由數據庫和指向下一個結點的指針域構成，下面是結點的c語言實現：

/*
定義實現棧的結點 
*/
typedef struct Node{
    int data;
    struct Node * pNext;
}NODE,* PNODE;

　　有了實現棧的結點，那么接下來就是該如何實現棧（具體的解釋看代碼）：

/*
定義棧的結構，此處采用鏈表實現靜態棧，所以僅僅需要給出棧的頭部指針和底部指針即可 
*/
typedef struct Strack{
    PNODE pTop;
    PNODE pBottom;
}STRACK,* PSTRACK;

　　棧的基本操作：棧的初始化，壓棧、棧的遍歷、出棧等操作　　

/*
對棧初始化的函數
對棧初始化僅僅是令棧中的top和bottom指針指向一個確定的地址，並且此地址指向的是棧的頭結點（頭結點的引入可以
大大方便對棧的操作）。 
*/
void init_strack(PSTRACK pS){
    pS->pTop=(PNODE)malloc(sizeof(NODE));   //定義一個新結點，這個結點就是棧的頭結點，並且讓pTop指向這個結點
    if(pS->pTop==NULL){
        printf("內存分配失敗");
        exit(-1);
    } 
    else{
        pS->pBottom=pS->pTop;    //令bottom和top都指向頭結點，則初始化棧完成，棧中沒有任何有效結點
        pS->pTop->pNext=NULL; 
    }
     
}

/*
壓棧函數
因為棧具有“先進后出、后進先出”的特性，所以，在將元素壓入棧時，也只能將棧壓入棧的頂部
由此，壓棧函數就是令棧的top指針指向新結點，新結點的指針域指向未壓入棧時的最頂部的元素。 
*/
int push(PSTRACK pS,int val){
    PNODE pNew=(PNODE)malloc(sizeof(NODE));  //定義一個新結點
    if(pNew->pNext==NULL){
        printf("內存分配失敗");
        exit(-1);
    }
    pNew->data= val;
    pNew->pNext=pS->pTop;  //指針賦值的順序不可以亂，為保證top所指向的地址不丟失，所以首先讓新結點的指針域指向pS->pTop所指向的結點
    pS->pTop=pNew;  //令top指針指向新的結點
    return 0; //0表示當前push成功 
}

/*
棧的遍歷函數
因為只是遍歷輸出，所以不能破壞棧原有的結構，所以我們只有定義一個新的結點p，讓其指向棧頂元素，
然后遍歷下移一個輸出其指向的元素的值 ，循環條件就是p=ps->pBottom 
*/
void traverse(PSTRACK ps){
    PNODE p=ps->pTop;  //讓新定義的結構體指針指向棧頂元素
    while(p!=ps->pBottom){
        printf("%d ", p->data);
        p=p->pNext;  //讓當前指針指向當前節點的下一個結點 
    } 
    printf("\n");
    return;
}


/*
判斷當前棧是否為空的函數
若為空，返回true
否則，返回false 
*/
bool isEmpty(PSTRACK ps){
    if(ps->pTop==ps->pBottom){
        return true;
    }
    else{
        return false;
    }
}

/*
彈棧函數：彈棧簡單的說就是將第一個數值彈出，然后將ps->pTop指向原第一個結點的下一個結點（即彈棧后的第一個結點），
然后在將被彈出的元素在內存中釋放掉。 
*/
bool pop(PSTRACK ps,int *pVal){
    if(isEmpty(ps)){  //判斷當前棧是否為空，若為空，則返回false 
        return false;
    }
    else{   
        PNODE p=ps->pTop;  //定義一個結點，這個結點在每次彈棧時都是指向棧頂，這樣可以保證不會造成被彈出元素的丟失 
        ps->pTop=p->pNext;  //讓top結點指向棧頂元素 
        *pVal=p->data;
        free(p);  //將被彈出元素釋放 
        p=NULL;
        return true;
    }     
}

　　上述就實現了對棧的基本操作，當然具體的應用還要看具體的算法要求。

 

上述是在大學時學習的，下面的是工作兩年后再次學習時的理解，可能會有不同的見解，都寫出來吧。

1、棧的定義：一種可以實現“先進后出”的數據存儲結構，數據的插入和刪除只能在數據的一端進行。

內存分為靜態內存和動態內存。

靜態內存在棧中分配；動態內存在堆中分配。

棧：由操作系統自動分配釋放，存放函數的參數值， 局部變量的值等。

堆：一般由程序猿分配釋放，若程序猿不釋放，程序結束時由OS回收（類似於c語言中的malloc函數分配的空間）。

 

2、棧的分類：

（1）靜態棧：以數組作為數據的存儲。

（2）動態棧：以鏈表作為數據的存儲方式。

 

3、棧的相關操作（該處采用鏈表的動態棧）：

一點說明：

     因為用鏈表實現棧，其實其本質就是一個鏈表，只不過對該鏈表的插入（push）和刪除（pop）操作都在該鏈表的一端進行（該段被稱為棧頂，且人為限制就只在該棧頂進行操作），所以該鏈表就會具有了“先進后出”的特性，則被稱為棧結構。

     所以，嚴格來說，棧僅僅需要一個棧頂，該棧頂指向該鏈表的被稱為棧頂端的節點（所以，該棧頂也是一個該Node類型的指針）。

（1）棧中每個節點的結構：

 

 

（2）棧的結構：

因為通過棧頂可以找到該棧的所有元素，所以，該棧對應的鏈表應該是一個自上而下指向的鏈表。

該棧僅需要一個stop指針，指向棧頂元素。

 

 

（3）棧的初始化操作：

 

 

（4）棧的push操作：

 

 

（5）棧的pop操作：

 

 

（6）棧是否為空及棧的遍歷操作：

 

 

其實在棧中可以增加一個PNODE類型的指針sbuttom，讓該指針用於指向棧低節點，在判斷非空時，只要判斷sc->stop == sc->sbuttom時，就表示top和buttom重合了，指向了最底部的節點。其實，該buttom節點可以通過最后一個節點的next指針域是否為NULL來判斷（next指針域為NULL時，就表示該節點沒有下一個節點了，是棧低節點）。 

 

代碼：

#include <stdio.h>
#include <sys/malloc.h>
#include <stdlib.h>

/*
棧結構及其操作:
當前采用鏈表進行棧中數據的存儲。
*/


/*
定義棧中每一個節點的結構
*/
typedef struct Node{
    int data;  //數據域
    struct Node * pnext;  //指針域，指向棧中下一個節點
}NODE, * PNODE;  //定義兩個別名，方便操作

/*
定義棧的結構：
因為用鏈表實現棧，其實其本質也是一個鏈表，只不過該鏈表的插入（push）和刪除（pop）操作只能在鏈表的一端（該端被稱作棧頂）進行操作，所以該鏈表具有“先進后出”的特性，被稱作棧（個人理解）。
所以，嚴格來說，棧僅僅需要一個指向棧頂（鏈表的一端）struct Node *類型的指針就可以知道該棧中的所有數據。
*/
typedef struct Stack{
    struct Node * stop;  //棧的棧頂（指向棧中最頂部的那個元素）
} STACK;

//棧的初始化操作
struct Stack init_stack();

//push操作
void stack_push(STACK *sc, int data);

//pop操作
int pop(STACK *sc);

//遍歷操作
void trvel_stack(STACK *sc);

//判斷是否為空操作
int is_empty(STACK *sc);

int main(int argc, char const *argv[])
{
    STACK sc;
    sc = init_stack();

    //push幾個數據
    stack_push(&sc, 1);
    stack_push(&sc, 3);
    stack_push(&sc, 7);
    stack_push(&sc, 2);
    stack_push(&sc, 10);

    //遍歷
    trvel_stack(&sc);

    //pop一個數據出來
    pop(&sc);

    trvel_stack(&sc);

    return 0;
}

/*
棧的初始化操作
*/
struct Stack init_stack(){
    //先定義一個棧
    STACK sc;

    //初始化棧中的第一個節點(棧低節點)，該節點並沒有什么實際意義，不存放數據
    PNODE pbottom = (PNODE)malloc(sizeof(NODE));
    if (pbottom == NULL) {
        printf("內存分配失敗\n");
        exit(1);
    }
    pbottom->pnext = NULL;

    //將棧頂指向該元素
    sc.stop = pbottom;

    return sc;
}

/*
棧的push操作
*/
void stack_push(STACK *sc, int data){
    printf("調用了！\n");

    //新創建一個節點
    PNODE pnew = (PNODE)malloc(sizeof(NODE));
    printf("%p\n", pnew);
    if (pnew == NULL) {
        printf("內存分配失敗\n");
        exit(1);
    }
    pnew->data = data;

    //將新節點指向原top節點，將棧的top指向該新節點
    pnew->pnext = sc->stop;
    sc->stop = pnew;
}

/*
棧的pop操作
*/
int pop(STACK *sc){
    int res;
    //判斷棧是否為空
    if (is_empty(sc) == 1){
        printf("棧為空，不可pop\n");
        exit(1);
    } else {
        PNODE ptmp = sc->stop;  //先將需要被pop出的節點存儲起來
        sc->stop = sc->stop->pnext;  //將棧的top指向下一個節點
        res = ptmp->data;
        free(ptmp);  //將地址釋放
        return res;
    }
}

/*
判斷棧是否為空的操作
*/
int is_empty(STACK *sc){
    PNODE p = sc->stop;
    if (p == NULL || p->pnext == NULL) {
        return 1;  //true表示為空
    } else {
        return 0;  //false表示非空
    }
}

/*
遍歷棧
*/
void trvel_stack(STACK *sc){
    if (is_empty(sc) == 1) {
        printf("棧為空喲，無法遍歷呢~\n");
        exit(1);
    } else {
        printf("遍歷調用了！\n");
        PNODE ptmp = sc->stop;
        while (ptmp->pnext != NULL) {  //直到最后一個為NULL的節點，該節點就是最后一個節點
            printf("%d\n", ptmp->data);
            ptmp = ptmp->pnext;
        }
    }
    
}