《算法導論》讀書筆記之第10章 基本數據結構

摘要

　　本章介紹了幾種基本的數據結構，包括棧、隊列、鏈表以及有根樹，討論了使用指針的簡單數據結構來表示動態集合。本章的內容對於學過數據結構的人來說，沒有什么難處，簡單的總結一下。

1、棧和隊列

　　棧和隊列都是動態集合，元素的出入是規定好的。棧規定元素是先進后出（FILO），隊列規定元素是先進先出（FIFO）。棧和隊列的實現可以采用數組和鏈表進行實現。在標准模塊庫STL中有具體的應用，可以參考http://www.cplusplus.com/reference/。

　　棧的基本操作包括入棧push和出棧pop，棧有一個棧頂指針top，指向最新如棧的元素，入棧和出棧操作操作都是從棧頂端進行的。

　　隊列的基本操作包括入隊enqueue和出隊dequeue，隊列有隊頭head和隊尾tail指針。元素總是從隊頭出，從隊尾入。采用數組實現隊列時候，為了合理利用空間，可以采用循環實現隊列空間的有效利用。

　　關於棧和隊列的基本操作如下圖所示：

采用數組簡單實現一下棧和隊列，實現隊列時候，長度為n的數組最多可以含有n-1個元素，循環利用，這樣方便判斷隊列是空還是滿。程序如下所示：

//stack.c

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

typedef struct stack
{
    int *s;
    int stacksize;
    int top;
}stack;

void init_stack(stack*s)
{
    s->stacksize = 100;
    s->s =(int*)malloc(sizeof(int)*s->stacksize);
    s->top = -1;
}
int stack_empty(stack s)
{
    return ((0 == s.stacksize) ? 1 : 0);
}

void push(stack *s,int x)
{
    if(s->top == s->stacksize)
        printf("up to overflow.\n");
    else
    {
        s->top++;
        s->s[s->top] = x;
        s->stacksize++;
    }
}
void pop(stack *s)
{
    if(0 == s->stacksize)
        printf("down to overflow.\n");
    else
    {
        s->top--;
        s->stacksize--;
    }
}
int top(stack s)
{
    return s.s[s.top];
}

int main()
{
    stack s;
    init_stack(&s);
    push(&s,19);
    push(&s,23);
    push(&s,34);
    push(&s,76);
    push(&s,65);
    printf("top is:%d\n",top(s));
    pop(&s);
    printf("top is:%d\n",top(s));
}

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

typedef struct queue
{
    int *q;
    int queuesize;
    int head;
    int tail;
}queue;

void enqueue(queue* q,int x)
{
    if(((q->tail+1) % q->queuesize) == q->head)
    {
        printf("queue is full.\n");
    }
    else
    {
        q->q[q->tail] = x;
        q->tail = (q->tail+1) % q->queuesize;
    }
}

int dequeue(queue* q,int *value)
{
    if(q->tail == q->head)
        return -1;
    else
    {
        *value = q->q[q->head];
        q->head = ((q->head++) % q->queuesize);
    }
}
int main()
{

    int value;
    queue q;
    q.queuesize=10;
    q.q = (int*)malloc(sizeof(int)*q.queuesize);
    q.head=0;
    q.tail=0;
    enqueue(&q,10);
    enqueue(&q,30);
    printf("head=%d\t tail=%d\n",q.head,q.tail);
    if(dequeue(&q,&value) == -1)
        printf("queue is empty.\n");
    else
        printf("value=%d\n",value);
    if(dequeue(&q,&value) == -1)
        printf("queue is empty.\n");
    else
        printf("value=%d\n",value);
    if(dequeue(&q,&value) == -1)
        printf("queue is empty.\n");
    else
        printf("value=%d\n",value);
    printf("head=%d\t tail=%d\n",q.head,q.tail);
    enqueue(&q,10);
    exit(0);
}

測試結果如下所示：

問題：

（1）說明如何用兩個棧實現一個隊列，並分析有關隊列操作的運行時間。

解答：棧中的元素是先進后出，而隊列中的元素是先進先出。現有棧s1和s2，s1中存放隊列中的結果，s2輔助轉換s1為隊列。入隊列操操作：當一個元素入隊列時，先判斷s1是否為空，如果為空則新元素直接入s1，如果非空則將s1中所有元素出棧並存放到s2中，然后在將元素入s1中，最后將s2中所有元素出棧並入s1中。此時s1中存放的即是隊列入隊的順序。出隊操作：如果s1為空，則說明隊列為空，非空則s1出棧即可。入隊過程需要在s1和s2來回交換，運行時間為O(n)，出隊操作直接是s1出棧運行時間為O(1)。舉例說明轉換過程，如下圖示：

我采用C++語言實現整程序如下：

#include <iostream>
#include <stack>
#include <cstdlib>
using namespace std;

template <class T>
class MyQueue
{
public:
    MyQueue();
    ~MyQueue();
    void enqueue(const T& data);
    int queue_empty() const;
    T dequeue();
private:
    stack<T>s1;
    stack<T>s2;
};

template<class T>
MyQueue<T>::MyQueue()
{

}
template<class T>
MyQueue<T>::~MyQueue()
{

}
template<class T>
void MyQueue<T>::enqueue(const T& data)
{
    if(s1.empty())
        s1.push(data);
    else
    {
        while(!s1.empty(d))
        {
            s2.push(s1.top());
            s1.pop();
        }
        s1.push(data);
    }
    while(!s2.empty())
    {
        s1.push(s2.top());
        s2.pop();
    }
}
template<class T>
int  MyQueue<T>::queue_empty() const
{
    return (s1.empty());
}
template<class T>
T MyQueue<T>::dequeue()
{
    T ret;
    if(!s1.empty())
    {
        ret = s1.top();
        s1.pop();
    }
     return ret;

}

int main()
{
    MyQueue<int> myqueue;
    myqueue.enqueue(10);
    myqueue.enqueue(20);
    myqueue.enqueue(30);
    cout<< myqueue.dequeue()<<endl;
    myqueue.enqueue(40);
    cout<< myqueue.dequeue()<<endl;
    cout<< myqueue.dequeue()<<endl;
    myqueue.enqueue(50);
    cout<< myqueue.dequeue()<<endl;
    cout<< myqueue.dequeue()<<endl;
    exit(0);
}

（2）說明如何用兩個隊列實現一個棧，並分析有關棧操作的運行時間。

解答：類似上面的題目，隊列是先進先出，而棧是先進后出。現有隊列q1和q2，q1中存放的是棧的結果，q2輔助q1轉換為棧。入棧操作：當一個元素如棧時，先判斷q1是否為空，如果為空則該元素之間入隊列q1，如果非空則將q1中的所有元素出隊並入到q2中，然后將該元素入q1中，最后將q2中所有元素出隊並入q1中。此時q1中存放的就是棧的如棧順序。出棧操作：如果q1為空，則棧為空，否則直接q1出隊操作。入棧操作需要在隊列q1和q2直接來來回交換，運行時間為O(n)，出棧操作是隊列q1出隊操作，運行時間為O(1)。我用C++語言實現完整程序如下：

#include <iostream>
#include <stack>
#include <cstdlib>
using namespace std;

template <class T>
class MyQueue
{
public:
    MyQueue();
    ~MyQueue();
    void enqueue(const T& data);
    int queue_empty() const;
    T dequeue();
private:
    stack<T>s1;
    stack<T>s2;
};

template<class T>
MyQueue<T>::MyQueue()
{

}
template<class T>
MyQueue<T>::~MyQueue()
{

}
template<class T>
void MyQueue<T>::enqueue(const T& data)
{
    if(s1.empty())
        s1.push(data);
    else
    {
        while(!s1.empty(d))
        {
            s2.push(s1.top());
            s1.pop();
        }
        s1.push(data);
    }
    while(!s2.empty())
    {
        s1.push(s2.top());
        s2.pop();
    }
}
template<class T>
int  MyQueue<T>::queue_empty() const
{
    return (s1.empty());
}
template<class T>
T MyQueue<T>::dequeue()
{
    T ret;
    if(!s1.empty())
    {
        ret = s1.top();
        s1.pop();
    }
     return ret;

}

int main()
{
    MyQueue<int> myqueue;
    myqueue.enqueue(10);
    myqueue.enqueue(20);
    myqueue.enqueue(30);
    cout<< myqueue.dequeue()<<endl;
    myqueue.enqueue(40);
    cout<< myqueue.dequeue()<<endl;
    cout<< myqueue.dequeue()<<endl;
    myqueue.enqueue(50);
    cout<< myqueue.dequeue()<<endl;
    cout<< myqueue.dequeue()<<endl;
    exit(0);
}

 2、鏈表

　　鏈表與數組的區別是鏈表中的元素順序是有各對象中的指針決定的，相鄰元素之間在物理內存上不一定相鄰。采用鏈表可以靈活地表示動態集合。鏈表有單鏈表和雙鏈表及循環鏈表。書中着重介紹了雙鏈表的概念及操作，雙鏈表L的每一個元素是一個對象，每個對象包含一個關鍵字和兩個指針：next和prev。鏈表的操作包括插入一個節點、刪除一個節點和查找一個節點，重點來說一下雙向鏈表的插入和刪除節點操作，圖例如下：

鏈表是最基本的數據結構，凡是學計算機的必須的掌握的，在面試的時候經常被問到，關於鏈表的實現，百度一下就知道了。在此可以討論一下與鏈表相關的練習題。

（1）在單鏈表上插入一個元素，要求時間復雜度為O(1)。

解答：一般情況在鏈表中插入一元素是在末尾插入的，這樣需要從頭遍歷一次鏈表，找到末尾，時間為O(n)。要在O(1)時間插入一個新節點，可以考慮每次在頭節點后面插入，即每次插入的節點成為鏈表的第一個節點。

（2）在單鏈表上刪除一個給定的節點p，要求時間復雜度為O(1)。

解答：一般情況刪除一個節點時候，我們需要找到該節點p的前驅節點q，需要對鏈表進行遍歷，運行時間為O(n-1)。我們可以考慮先將q的后繼節點s的值替換q節點值，然后刪除s即可。如下圖刪除節點q的操作過程：

（3）單鏈表逆置，不允許額外分配存儲空間，不允許遞歸，可以使用臨時變量，執行時間為O(n)。

解答：這個題目在面試筆試中經常碰到，基本思想上將指針逆置。如下圖所示：

（4）遍歷單鏈表一次，找出鏈表中間節點。

解答：定義兩個指針p和q，初始都指向鏈表頭節點。然后開始向后遍歷，p每次移動2步，q移動一步，當p到達末尾的時候，p正好到達了中間位置。

（5）用一個單鏈表L實現一個棧，要求push和pop的操作時間為O(1)。

解答：根據棧中元素先進后出的特點，可以在鏈表的頭部進行插入和刪除操作。

（6）用一個單鏈表L實現一個隊列，要求enqueue和dequeue的操作時間為O(1)。

解答：隊列中的元素是先進先出，在單鏈表結構中增加一個尾指針，數據從尾部插入，從頭部刪除。

3、有根樹的表示

　　采用鏈表數據結構來表示樹，書中先降二叉樹的鏈表表示法，然后拓展到分支數無限制的有根數。先來看看二叉樹的鏈表表示方法，用域p、left和right來存儲指向二叉樹T中的父親、左孩子和右孩子的指針。如下圖所示：

　　對於分支數目無限制的有根樹，采用左孩子、右兄弟的表示方法。這樣表示的樹的每個節點都包含有一個父親指針p，另外兩個指針：

（1）left_child指向節點的最左孩子。

（2）right_sibling指向節點緊右邊的兄弟。