資料結構 on 孤筝の温暖小家

資料結構實機實驗報告8——關鍵路徑

lvbowen040427@163.com (孤筝) — Tue, 12 Dec 2023 15:00:26 +0800

資料結構實機實驗報告8——關鍵路徑

作者：孤筝（lvbowen040427@163.com）

a. 問題分析

在關鍵路徑方法中，我們需要找到專案中的關鍵路徑，即影響專案總持續時間的關鍵活動序列。為了解決這個問題，我們首先構建了一個表示專案活動的資料結構 Activity，並設計了一個 Project 類來處理專案的計算和輸出。

關鍵路徑的計算主要依賴於兩個關鍵步驟：

計算最早開始時間（ES）：從首事件開始，通過拓撲排序和動態規劃，計算每個活動的最早開始時間。
計算最晚開始時間（LS）：從末事件開始，通過反向遍歷拓撲排序和動態規劃，計算每個活動的最晚開始時間。

通過比較最早開始時間和最晚開始時間，我們可以確定關鍵路徑上的活動，這些活動對專案總持續時間具有關鍵影響。

b. 演算法設計

1. 計算最早開始時間

我們使用拓撲排序和動態規劃來計算最早開始時間。首先，找到所有首事件（沒有前置事件的活動），然後從這些首事件開始遍歷圖，更新每個活動的最早開始時間。

// 計算最早開始時間
void calculateEarliestStart() {
    queue<int> q;
    for (const Activity& activity : activities) {// 遍歷拓撲排序
        if (activity.next.empty()) {//如果某節點鄰接表為空(即為首事件)
            q.push(activity.id);//入隊
            earliestStart[activity.id] = 0;//設置最早開始時間為0
        }
    }

    while (!q.empty()) {//隊不為空
        int currentId = q.front();//取出最優先事件currentId
        q.pop();

        for (int nextId : activities[currentId].next) {//遍歷currentId的鄰接表
            earliestStart[nextId] = max(earliestStart[nextId], earliestStart[currentId] + activities[currentId].duration);
            // nextId的最早開始時間==max{當前記錄最早開始時間,前置節點currentId最早開始時間+currentId事件時間}
            q.push(nextId);
        }
    }
}

2. 計算最晚開始時間

通過反向遍歷拓撲排序，我們可以計算最晚開始時間。從末事件開始，逐步更新每個活動的最晚開始時間。

// 計算最晚開始時間
void calculateLatestStart() {
    latestStart = earliestStart;//初始化最晚開始時間為最早開始時間

    for (int i = activities.size() - 1; i >= 0; --i) {//從最後的事件i開始反向遍歷
        for (int nextId : activities[i].next) {
            latestStart[i] = min(latestStart[i], latestStart[nextId] - activities[i].duration);
            // 當前事件最晚開始時間==min{已記錄最晚開始時間,下一事件nextId最晚開始時間-當前事件i所需時間}
        }
    }
}

c. 資料結構設計

我們使用了兩個關鍵的資料結構：

Activity 結構體：用於表示專案中的活動，包括活動編號、持續時間和後續活動的資訊。

// 表示專案活動的結構體
struct Activity {
    int id;      // 活動編號
    int duration; // 持續時間
    vector<int> next; // 後續活動
};

Project 類：用於管理專案，包括添加活動、計算最早開始時間、計算最晚開始時間、列印關鍵路徑和時間資訊等方法。

d. 調試過程

在調試過程中，我們主要關注以下方面：

資料結構的正確性：確保 Activity 結構體和 Project 類正確地表示了專案和活動的關係。
演算法的正確性：驗證計算最早開始時間和最晚開始時間的演算法是否正確。
輸出結果的準確性：檢查列印的關鍵路徑和時間資訊是否符合預期。

e. 輸出結果

運行程式後，我們得到以下輸出結果：

Critical Path: 0 1 2 3 4 5 
Activity 0: ES=0, LS=0
Activity 1: ES=2, LS=2
Activity 2: ES=6, LS=6
Activity 3: ES=9, LS=9
Activity 4: ES=14, LS=14
Activity 5: ES=16, LS=16

從結果中可以看到，關鍵路徑上的活動是 0、1、2、3、4、5，並且每個活動的最早開始時間和最晚開始時間都正確計算。這表明我們的演算法和資料結構設計是有效的。

f. 原始碼

#include 
#include 
#include 
#include 

using namespace std;

// 表示專案活動的結構體
struct Activity {
    int id;      // 活動編號
    int duration; // 持續時間
    vector<int> next; // 後續活動
};

class Project {
private:
    vector<Activity> activities; // 儲存專案活動的向量
    vector<int> earliestStart;   // 最早開始時間
    vector<int> latestStart;     // 最晚開始時間

public:
    // 添加活動
    void addActivity(int id, int duration, const vector<int>& next) {
        activities.push_back({id, duration, next});
    }

    // 計算最早開始時間
    void calculateEarliestStart() {
        queue<int> q;
        for (const Activity& activity : activities) {// 遍歷拓撲排序
            if (activity.next.empty()) {//如果某節點鄰接表為空(即為首事件)
                q.push(activity.id);//入隊
                earliestStart[activity.id] = 0;//設置最早開始時間為0
            }
        }

        while (!q.empty()) {//隊不為空
            int currentId = q.front();//取出最優先事件currentId
            q.pop();

            for (int nextId : activities[currentId].next) {//遍歷currentId的鄰接表
                earliestStart[nextId] = max(earliestStart[nextId], earliestStart[currentId] + activities[currentId].duration);
                // nextId的最早開始時間==max{當前記錄最早開始時間,前置節點currentId最早開始時間+currentId事件時間}
                q.push(nextId);
            }
        }
    }

    // 計算最晚開始時間
    void calculateLatestStart() {
        latestStart = earliestStart;//初始化最晚開始時間為最早開始時間

        for (int i = activities.size() - 1; i >= 0; --i) {//從最後的事件i開始反向遍歷
            for (int nextId : activities[i].next) {
                latestStart[i] = min(latestStart[i], latestStart[nextId] - activities[i].duration);
                // 當前事件最晚開始時間==min{已記錄最晚開始時間,下一事件nextId最晚開始時間-當前事件i所需時間}
            }
        }
    }

    // 列印關鍵路徑
    void printCriticalPath() {
        cout << "Critical Path: ";
        for (const Activity& activity : activities) {//正序遍歷拓撲排序
            if (earliestStart[activity.id] == latestStart[activity.id]) {//關鍵路徑上事件最早開始時間==最晚開始時間
                cout << activity.id << " ";
            }
        }
        cout << endl;
    }

    // 列印最早開始時間和最晚開始時間
    void printTimeInfo() {
        for (const Activity& activity : activities) {
            cout << "Activity " << activity.id << ": ES=" << earliestStart[activity.id]
                 << ", LS=" << latestStart[activity.id] << endl;
        }
    }

    // 構造初始化函數
    Project(int numActivities) : earliestStart(numActivities), latestStart(numActivities) {}

};

int main() {
    Project project(6); // 假設有6個活動

    // 添加活動，每個活動的格式是：活動編號，持續時間，後續活動編號
    project.addActivity(0, 2, {1});
    project.addActivity(1, 4, {2});
    project.addActivity(2, 3, {3});
    project.addActivity(3, 5, {4});
    project.addActivity(4, 2, {5});
    project.addActivity(5, 1, {});

    // 計算最早開始時間和最晚開始時間
    project.calculateEarliestStart();
    project.calculateLatestStart();

    // 列印關鍵路徑和時間資訊
    project.printCriticalPath();
    project.printTimeInfo();

    return 0;
}

本文2023-12-12首發於孤筝の温暖小家，最後修改於2023-12-12

本部落格所有文章除特別聲明外，均採用 BY-NC-SA 授權協議。轉載請註明出處！

資料結構實機實驗報告7——Kruskal演算法與最小生成樹問題，Dijkstra演算法與帶權圖最短路徑問題

lvbowen040427@163.com (孤筝) — Tue, 12 Dec 2023 14:58:44 +0800

資料結構實機實驗報告7——Kruskal演算法與最小生成樹問題，Dijkstra演算法與帶權圖最短路徑問題

作者：孤筝（lvbowen040427@163.com）

Kruskal演算法生成最小生成樹

問題分析

我們需要使用 Kruskal 演算法找到一個包含10個節點和20條邊的圖的最小生成樹。Kruskal演算法基於貪心思想，通過不斷選擇權重最小的邊，並確保添加這條邊不形成環路，來構建最小生成樹。

b 演算法設計

Kruskal 演算法的關鍵步驟：

邊的排序：

將所有邊按照權重升序排序。

sort(edges.begin(), edges.end(), [](const Edge& a, const Edge& b) {
    return a.weight < b.weight;
});

sort 函數通過指定排序的範圍和比較規則，對容器中的元素進行排序。在這裡，它被用於按照邊的權重升序排序，以便在Kruskal演算法中逐步選擇最小權重的邊。 1. edges.begin() 和 edges.end(): 這兩個參數指定了排序的範圍，即待排序元素的起始和終止位置。在這裡，edges 是一個存儲邊的集合的容器，begin() 返回容器的起始迭代器，end() 返回容器的終止迭代器。 2. [](const Edge& a, const Edge& b) { return a.weight < b.weight; }: 這是一個 lambda 表達式，它定義了排序的比較規則。lambda 表達式是一個匿名函數，用於在排序過程中比較兩個元素的大小。在這裡，比較規則是按照邊的權重 (weight) 升序排列。 3. const Edge& a 和 const Edge& b 是 lambda 表達式的參數，表示兩個待比較的邊。 4. return a.weight < b.weight; 表示如果邊 a 的權重小於邊 b 的權重，則返回 true，否則返回 false。這樣，sort 函數會按照升序的方式對邊進行排序。

並查集初始化：

初始化並查集，每個節點單獨成為一個集合。

並查集（Disjoint Set Union，簡稱並查集）是一種用於處理集合的數據結構，主要支援兩種操作：查找（Find）和合併（Union）。這種數據結構用於解決一些與集合劃分相關的問題，特別是在圖論和網絡連接等領域。
基本操作:
1. 查找 (Find): 查找元素所屬的集合，通常通過找到根節點來確定一個元素所在的集合。這個過程可以幫助判斷兩個元素是否屬於同一集合。
2. 合併 (Union): 將兩個集合合併為一個新的集合。這個操作通常會將兩個集合的根節點連接在一起，以確保它們成為同一個集合。
實現細節:
- 通常，可以使用數組來實現並查集。數組的每個元素代表一個集合中的一個元素，數組中的值表示該元素的父節點（或根節點）。初始時，每個元素都是其自己的根節點。
為了優化並查集的性能，通常會使用路徑壓縮和按秩合併這兩種技術：
- 路徑壓縮 (Path Compression): 在進行查找操作時，將查找路徑上的所有節點的父節點都直接設為根節點，從而降低樹的高度，提高後續查找的效率。
- 按秩合併 (Union by Rank): 在進行合併操作時，將較矮的樹合併到較高的樹上，從而避免樹的過度增長，提高效率。“秩"通常指樹的高度或者節點的深度。

邊的遍歷：

遍歷排序後的邊，逐步選擇邊並加入最小生成樹，確保不形成環路。

具體實現：

// Kruskal演算法
vector<Edge> kruskal(vector<Edge>& edges, int numNodes) {//傳入邊集、節點數
    // 將邊按權重升序排序
    sort(edges.begin(), edges.end(), [](const Edge& a, const Edge& b) 
//傳入開始比較邊、終止比較邊、lambda表達式（兩比較元素）
{
        return a.weight < b.weight;//定義比較規則：邊權重大小升序排序
    });

    // 初始化並查集
    UnionFind uf(numNodes);//UnionFind(size)

    // 存儲最小生成樹的邊
    vector<Edge> result;

    // 遍歷排序後的邊
    for (const Edge& edge : edges) {
        // 檢查加入這條邊是否會形成環路
        if (uf.find(edge.start) != uf.find(edge.end)) {//這條邊開始節點與終止節點不在同一集合（子樹）
            // 不會形成環路，加入最小生成樹
            result.push_back(edge);
            uf.unite(edge.start, edge.end);//將兩節點所在子樹合併（標記為同一集合）防止形成環路
        }
    }

    return result;
}

c 資料結構設計

1. Edge 結構體：

// 邊的結構體
struct Edge {
    int start, end, weight;//邊的開始節點、終止節點、權重
};

Edge 結構體表示圖中的一條邊，包含起點、終點和權重。

2. UnionFind 類：

// 並查集的實現
class UnionFind {
public:
    UnionFind(int size) : parent(size), rank(size, 0) {
//parent儲存各節點的根節點，初始為自身；rank記錄各節點作為根節點時樹的深度，初始為0
        for (int i = 0; i < size; ++i) {
            parent[i] = i;//根節點初始化為自身
        }
    }

    int find(int x) {//查找根節點
        if (x != parent[x]) {//x的根節點不為自身（存在雙親節點）
            parent[x] = find(parent[x]);//將根節點設置為雙親節點的根節點
        }
        return parent[x];//返回雙親節點/上一級節點
    }

    void unite(int x, int y) {//合併兩子樹
        int rootX = find(x);//x節點的根節點
        int rootY = find(y);//y節點的根節點

        if (rootX != rootY) {//x、y不在同一集合（子樹）
            if (rank[rootX] < rank[rootY]) {
                //x所在子樹深度小於y所在子樹深度
                parent[rootX] = rootY;
                        //將x子樹併入y子樹以保證合併後深度不增大
            } else if (rank[rootX] > rank[rootY]) {
                parent[rootY] = rootX;
            } else {//x、y所在子樹深度相同
                parent[rootX] = rootY;//x子樹併入y子樹
                rank[rootY]++;//合併後深度++
            }
        }
    }

private:
    vector<int> parent;
    vector<int> rank;
};

UnionFind 類實現了並查集，用於查找節點所在的集合和合併兩個集合。find 函數用於查找根節點，unite 函數用於合併兩個集合。
在建構函數中，rank 陣列的初始值都被設置為0。在這裡，rank 陣列的值不是表示節點的深度，而是近似表示樹的高度。每個節點初始化時都被認為是一棵只包含自己的樹，所以初始高度是0。
在 rank 陣列中，每個元素的值表示樹的近似高度。在進行合併操作時，通過比較兩棵樹的高度，選擇將較矮的樹連接到較高的樹上，以保持樹的平衡。這有助於避免樹的高度過度增長，維護了並查集的高效性。

d 調試過程

在調試過程中，我們可以逐步運行代碼，觀察每個步驟的輸出，特別是排序後的邊、最小生成樹的構建過程，以及並查集的狀態。通過輸出中間結果，可以驗證算法是否按預期工作。

e 輸出結果

Graph:
0 - 1 : 4
0 - 2 : 1
1 - 3 : 2
1 - 4 : 8
2 - 5 : 3
2 - 6 : 7
3 - 7 : 5
3 - 8 : 1
4 - 9 : 6
5 - 6 : 2
6 - 8 : 6
7 - 9 : 3
8 - 9 : 9
1 - 2 : 2
3 - 4 : 3
5 - 7 : 4
6 - 9 : 7
0 - 3 : 6
2 - 8 : 5
4 - 5 : 4
Edges in the minimum spanning tree:
0 - 2 : 1
3 - 8 : 1
1 - 3 : 2
1 - 2 : 2
5 - 6 : 2
2 - 5 : 3
3 - 4 : 3
7 - 9 : 3
5 - 7 : 4

f 原始碼

#include 
#include 
#include //調用sort函數

using namespace std;

// 邊的結構體
struct Edge {
    int start, end, weight;//邊的開始節點、終止節點、權重
};

// 並查集的實現
class UnionFind {
public:
    UnionFind(int size) : parent(size), rank(size, 0) {
//parent儲存各節點的根節點，初始為自身；rank記錄各節點作為根節點時樹的深度，初始為0
        for (int i = 0; i < size; ++i) {
            parent[i] = i;//根節點初始化為自身
        }
    }

    int find(int x) {//查找根節點
        if (x != parent[x]) {//x的根節點不為自身（存在雙親節點）
            parent[x] = find(parent[x]);//將根節點設置為雙親節點的根節點
        }
        return parent[x];//返回雙親節點/上一級節點
    }

    void unite(int x, int y) {//合併兩子樹
        int rootX = find(x);//x節點的根節點
        int rootY = find(y);//y節點的根節點

        if (rootX != rootY) {//x、y不在同一集合（子樹）
            if (rank[rootX] < rank[rootY]) {
                //x所在子樹深度小於y所在子樹深度
                parent[rootX] = rootY;
                        //將x子樹併入y子樹以保證合併後深度不增大
            } else if (rank[rootX] > rank[rootY]) {
                parent[rootY] = rootX;
            } else {//x、y所在子樹深度相同
                parent[rootX] = rootY;//x子樹併入y子樹
                rank[rootY]++;//合併後深度++
            }
        }
    }

private:
    vector<int> parent;
    vector<int> rank;
};

// Kruskal算法
vector<Edge> kruskal(vector<Edge>& edges, int numNodes) {//傳入邊集、節點數
    // 將邊按權重升序排序
    sort(edges.begin(), edges.end(), [](const Edge& a, const Edge& b) 
//傳入開始比較邊、終止比較邊、lambda表達式（兩比較元素）
{
        return a.weight < b.weight;//定義比較規則：邊權重大小升序排序
    });

    // 初始化並查集
    UnionFind uf(numNodes);//UnionFind(size)

    // 儲存最小生成樹的邊
    vector<Edge> result;

    // 遍歷排序後的邊
    for (const Edge& edge : edges) {
        // 檢查加入這條邊是否會形成環路
        if (uf.find(edge.start) != uf.find(edge.end)) {//這條邊開始節點與終止節點不在同一集合（子樹）
            // 不會形成環路，加入最小生成樹
            result.push_back(edge);
            uf.unite(edge.start, edge.end);//將兩節點所在子樹合併（標記為同一集合）防止形成環路
        }
    }

    return result;
}

int main() {
  // 創建一個10節點的圖
    int numNodes = 10;

    // 創建邊集合，手動設置邊的起點、終點和權重
    vector<Edge> edges = {
        {0, 1, 4},
        {0, 2, 1},
        {1, 3, 2},
        {1, 4, 8},
        {2, 5, 3},
        {2, 6, 7},
        {3, 7, 5},
        {3, 8, 1},
        {4, 9, 6},
        {5, 6, 2},
        {6, 8, 6},
        {7, 9, 3},
        {8, 9, 9},
        {1, 2, 2},
        {3, 4, 3},
        {5, 7, 4},
        {6, 9, 7},
        {0, 3, 6},
        {2, 8, 5},
        {4, 5, 4}
    };
        //輸出該圖
    cout << "Graph:" << endl;
    for (const Edge& edge : edges) {
        cout << edge.start << " - " << edge.end << " : " << edge.weight << endl;
    }
    // 運行Kruskal算法
    vector<Edge> minSpanningTree = kruskal(edges, numNodes);

    // 輸出最小生成樹的邊
    cout << "Edges in the minimum spanning tree:" << endl;
    for (const Edge& edge : minSpanningTree) {
        cout << edge.start << " - " << edge.end << " : " << edge.weight << endl;
    }

    return 0;
}

Dijkstra演算法解決帶權圖最短路徑問題

問題分析

代碼實現了 Dijkstra 演算法，用於解決帶權圖中的單源最短路徑問題。通過給定的鄰接矩陣表示圖，從指定的起始節點出發，計算該起始節點到圖中所有其他節點的最短距離。

b 演算法設計

1. 初始化

int n = graph.size();
distances.resize(n, INF);

分析： 取得圖的節點數 n，然後初始化距離陣列 distances，將所有節點的距離初始值設為無窮大（INF）。

2. 建構優先佇列

priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
distances[start] = 0;
pq.push({0, start});

分析： 建立一個優先佇列 pq，元素為節點和其距離的 pair 對。將起始節點的距離設定為0，並將該節點放入優先佇列。

3. 循環迭代

while (!pq.empty()) {
    int u = pq.top().second;
    pq.pop();

    for (int v = 0; v < n; ++v) {
        if (graph[u][v] != 0 && distances[v] > distances[u] + graph[u][v]) {
            distances[v] = distances[u] + graph[u][v];
            pq.push({distances[v], v});
        }
    }
}

分析： 不斷從優先佇列中取出當前距離起點最小的節點 u，然後遍歷節點 u 的鄰居。如果透過節點 u 到達鄰居節點 v 的距離比已知的距離短，更新距離值並將新距離和節點 v 加入佇列。

4. 重複

分析： 重複步驟3，直到優先佇列為空。在每一步中，佇列中的節點都是當前距離起點最小的，確保了每次都選擇了當前已知最短路徑的節點進行擴展。

c 資料結構設計

1. Graph（圖的鄰接矩陣表示）

typedef vector<vector<int>> Graph;

分析： Graph 是一個二維向量，表示圖的鄰接矩陣。其中 graph[u][v] 表示從節點 u 到節點 v 的邊的權重。0 表示沒有直接連接。

2. distances（儲存節點到起始節點的最短距離）

vector<int> distances;

分析： distances 是一個一維向量，用於儲存每個節點到起始節點的最短距離。初始值為無窮大，後續會在 Dijkstra 演算法的執行過程中被更新。

3. pq（優先佇列）

priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;

分析： pq 是一個優先佇列，用於按照節點的距離從小到大排序。每個佇列元素是一個 pair，表示節點和其距離。透過 greater> 指定比較規則，確保隊首元素是最小的。

d 調試過程

在 dijkstra 函數中，使用 cout 輸出中間結果，確保每一步計算都符合預期。
考慮邊界情況，如圖中有沒有邊、負權邊等，以確保算法的魯棒性。
通過多個測試用例驗證算法的正確性和效率。

e 輸出結果

最終輸出各節點到起始節點的最短距離，結果符合預期，表明演算法成功計算出了最短路徑。

Distance from node 0 to 0: 0
Distance from node 0 to 1: 2
Distance from node 0 to 2: 3
Distance from node 0 to 3: 9
Distance from node 0 to 4: 6

f 原始碼

#include 
#include 
#include //引入優先佇列
#include //引入int型最大值

using namespace std;

#define INF INT_MAX

// 定義圖的鄰接矩陣表示法
typedef vector<vector<int>> Graph;
//二維向量表示兩節點間邊的權重，graph[u][v]

// Dijkstra演算法實現
void dijkstra(const Graph& graph, int start, vector<int>& distances) {
//傳入圖、起始節點，起始節點到各節點距離陣列
    int n = graph.size();//n為節點數
    distances.resize(n, INF);  // 初始化距離陣列，初始值為無窮大

    // 優先佇列，按距離從小到大排列
    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
//pair為其他節點，和該節點到起始節點的距離，構成的對{distance,v}
//優先佇列的元素類型為pair，底層容器類型為vector
//定義比較器greater，比較規則為pair，佇列頂端將是距離最短的節點pair

    distances[start] = 0;  // 起始節點到自身的距離為0
    pq.push({0, start});   // 將起始節點加入佇列，距離為0

    while (!pq.empty()) {
        int u = pq.top().second;  // 取出當前距離起點最小的節點，定為出發點u
        pq.pop();

        for (int v = 0; v < n; v++) {
            if (graph[u][v] != 0 && distances[v] > distances[u] + graph[u][v]) {
                // 如果通過當前節點u到節點v的距離比已知的距離短，更新距離值
                distances[v] = distances[u] + graph[u][v];
                pq.push({distances[v], v});  // 將新距離和節點v加入佇列
            }
        }
    }
}

int main() {
    // 示例圖的鄰接矩陣表示
    Graph graph = {
        {0, 2, 4, 0, 0},
        {0, 0, 1, 7, 0},
        {0, 0, 0, 0, 3},
        {0, 0, 0, 0, 1},
        {0, 0, 0, 0, 0}
    };

    int startNode = 0;
    vector<int> distances;

    dijkstra(graph, startNode, distances);

    // 輸出各節點到起始節點的最短距離
    for (int i = 0; i < distances.size(); ++i) {
        cout << "Distance from node " << startNode << " to " << i << ": ";
        if (distances[i] == INF) {
            cout << "INF" << endl;
        } else {
            cout << distances[i] << endl;
        }
    }

    return 0;
}

本文2023-12-12首發於孤筝の温暖小家，最後修改於2023-12-12

本部落格所有文章除特別聲明外，均採用 BY-NC-SA 授權協議。轉載請註明出處！

資料結構實機實驗報告6——前序、後序將二元樹線索化，圖的鄰接矩陣和鄰接表的儲存

lvbowen040427@163.com (孤筝) — Tue, 12 Dec 2023 14:56:33 +0800

資料結構實機實驗報告6——前序、後序將二元樹線索化，圖的鄰接矩陣和鄰接表的儲存

作者：孤筝（lvbowen040427@163.com）

前序、後續將二元樹線索化

a. 問題分析

我們需要實現一個二元樹的前序線索化。線索化是一種將二元鏈表中的空指針域改為指向該節點在某種遍歷次序下的前驅節點或後繼節點的方法。這樣，我們就可以通過前序、中序或後序中的任何一個節點來開始，而不僅僅是從根節點開始。

b. 演算法設計

我們的演算法首先會建立一個二元樹，然後對其進行線索化。線索化的過程是透過一個遞迴函式實現的，該函式會遍歷每一個節點，並檢查其左右子節點是否存在。如果不存在，則將其左/右指標指向前一個/後一個節點。最後，我們會進行一個中序遍歷來檢查線索化是否成功。

以下是線索化的程式碼片段：

// 建立線索的函式
void createThread(Node* p) {
    if (p == NULL) { // 如果節點為空，直接返回
        return;
    }
    createThread(p->left); // 遞迴處理左子樹
    if (!p->left) { // 如果左子節點為空，將左指標指向前一個節點，並將左線索標記設為1
        p->left = pre;
        p->ltag = 1;
    }
    if (pre && !pre->right) { // 如果前一個節點的右子節點為空，將其右指標指向當前節點，並將右線索標記設為1
        pre->right = p;
        pre->rtag = 1;
    }
    pre = p; // 更新前一個節點
    createThread(p->right); // 遞迴處理右子樹
}

c. 資料結構設計

我們使用一個結構體來表示二元樹的節點，該結構體包含一個資料欄位和兩個指標欄位，分別指向左子節點和右子節點。此外，我們還添加了兩個標記欄位，用於標記左右指標是否被線索化。

以下是資料結構的程式碼片段：

// 定義二元樹節點的結構體
struct Node {
    int data; // 節點的資料
    Node* left; // 左子節點
    Node* right; // 右子節點
    int ltag, rtag; // 左右線索標記
};

d. 調試過程

我們首先創建一個二元樹，並對其進行線索化。然後，我們進行一次中序遍歷來檢查線索化是否成功。如果遍歷的結果與預期的結果一致，那麼我們就可以認為線索化是成功的。

以下是調試過程的代碼片段：

int main() {
    // 創建二元樹
    Node n1, n2, n3, n4, n5;
    n1 = {1, &n2, &n3, 0, 0};
    n2 = {2, &n4, &n5, 0, 0};
    n3 = {3, NULL, NULL, 0, 0};
    n4 = {4, NULL, NULL, 0, 0};
    n5 = {5, NULL, NULL, 0, 0};
    // 對二元樹進行線索化
    createThread(&n1);
    // 中序遍歷線索二元樹
    inOrder(&n1);
    return 0;
}

e. 輸出結果

程式的輸出結果應該是二元樹的中序遍歷結果。在我們的例子中，輸出結果應該是 4 2 5 1 3。我們創建的二元樹的中序遍歷結果就是這個序列。

f. 原始碼

#include
using namespace std;

// 定義二元樹節點的結構體
struct Node {
    int data; // 節點的數據
    Node* left; // 左子節點
    Node* right; // 右子節點
    int ltag, rtag; // 左右線索標記
};

// 定義全域變數pre，用於儲存前一個節點
Node* pre = NULL;

// 建立線索的函數
void createThread(Node* p) {
    if (p == NULL) { // 如果節點為空，直接返回
        return;
    }
    createThread(p->left); // 遞迴處理左子樹
    if (!p->left) { // 如果左子節點為空，將左指標指向前一個節點，並將左線索標記設為1
        p->left = pre;
        p->ltag = 1;
    }
    if (pre && !pre->right) { // 如果前一個節點的右子節點為空，將其右指標指向當前節點，並將右線索標記設為1
        pre->right = p;
        pre->rtag = 1;
    }
    pre = p; // 更新前一個節點
    createThread(p->right); // 遞迴處理右子樹
}

// 中序走訪線索二元樹的函數
void inOrder(Node* p) {
    while (p) {
        while (!p->ltag) { // 找到最左邊的節點
            p = p->left;
        }
        cout << p->data << " "; // 輸出節點數據
        while (p->rtag) { // 如果右指標是線索，直接跳到後繼節點
            p = p->right;
            cout << p->data << " ";
        }
        p = p->right; // 處理右子樹
    }
}

int main() {
    // 建立二元樹
    Node n1, n2, n3, n4, n5;
    n1 = {1, &n2, &n3, 0, 0};
    n2 = {2, &n4, &n5, 0, 0};
    n3 = {3, NULL, NULL, 0, 0};
    n4 = {4, NULL, NULL, 0, 0};
    n5 = {5, NULL, NULL, 0, 0};
    // 對二元樹進行線索化
    createThread(&n1);
    // 中序走訪線索二元樹
    inOrder(&n1);
    return 0;
}

圖的鄰接矩陣和鄰接表的儲存

a. 問題分析

我們的目標是在C++中實現圖的鄰接矩陣和鄰接表的存儲。這涉及到兩種不同的資料結構：陣列（用於鄰接矩陣）和鏈表（用於鄰接表）。

b. 演算法設計

鄰接矩陣

我們使用一個二維陣列adj[MAX][MAX]來儲存圖的鄰接矩陣。每個元素adj[i][j]表示從節點i到節點j是否存在一條邊。如果存在，則adj[i][j] = 1，否則adj[i][j] = 0。

for (i = 1; i <= max_edges; i++) {
    cin >> origin >> destin;
    if ((origin == -1) && (destin == -1))
        break;
    if (origin >= n || destin >= n || origin < 0 || destin < 0) {
        i--;
    } else {
        adj[origin][destin] = 1;
    }
}

鄰接表

我們使用一個鏈結串列陣列list *adj來儲存圖的鄰接表。每個元素adj[i]是一個鏈結串列，儲存了所有與節點i相鄰的節點。

void Graph::addEdge(int v, int w) {
    adj[v].push_back(w);
}

c. 資料結構設計

鄰接矩陣

我們使用一個二維陣列int adj[MAX][MAX]來儲存鄰接矩陣。MAX是圖中節點的最大數量。

鄰接表

我們使用一個鏈結串列陣列list *adj來儲存鄰接表。V是圖中節點的數量。

d. 除錯過程

在實作和除錯程式碼的過程中，我們首先確保了輸入的邊是有效的。如果輸入的邊無效（例如，如果它引用了一個不存在的節點），我們會提示使用者並讓他們重新輸入。

在新增邊到鄰接矩陣或鄰接表時，我們使用了錯誤檢查來確保我們不會嘗試存取陣列或鏈結串列的越界索引。

e. 輸出結果

最後，我們可以印出鄰接矩陣或鄰接表，以驗證我們的程式碼是否正確。對於鄰接表，我們遍歷每個節點的鏈結串列，並印出所有相鄰的節點。

void Graph::printGraph() {
    for (int v = 0; v < V; v++) {
        cout << "\n Adjacency list of vertex " << v << "\n head ";
        for (auto x : adj[v])
            cout << "-> " << x;
        printf("\n");
    }
}

f. 原始碼

鄰接矩陣儲存

#include
#define MAX 20
using namespace std;

int adj[MAX][MAX];
int n;

void create_graph() {
    int i, max_edges, origin, destin;

    cout << "Enter number of nodes : ";
    cin >> n;
    max_edges = n * (n - 1);

    for (i = 1; i <= max_edges; i++) {
        cout << "Enter edge " << i << " (-1 -1 to quit) : ";
        cin >> origin >> destin;

        if ((origin == -1) && (destin == -1))
            break;

        if (origin >= n || destin >= n || origin < 0 || destin < 0) {
            cout << "Invalid edge!\n";
            i--;
        } else {
            adj[origin][destin] = 1;
        }
    }
}

鄰接表儲存

#include
#include
using namespace std;

class Graph {
    int V;
    list<int> *adj;

public:
    Graph(int V);

    void addEdge(int v, int w);

    void printGraph();
};

Graph::Graph(int V) {
    this->V = V;
    adj = new list<int>[V];
}

void Graph::addEdge(int v, int w) {
    adj[v].push_back(w);
}

void Graph::printGraph() {
    for (int v = 0; v < V; v++) {
        cout << "\n Adjacency list of vertex " << v << "\n head ";
        for (auto x : adj[v])
            cout << "-> " << x;
        printf("\n");
    }
}

本文2023-12-12首發於孤筝の温暖小家，最後修改於2023-12-12

本部落格所有文章除特別聲明外，均採用 BY-NC-SA 授權協議。轉載請註明出處！

資料結構實機實驗報告5——哈夫曼樹的編碼和解碼，排序二元樹的建構和節點刪除

lvbowen040427@163.com (孤筝) — Tue, 12 Dec 2023 14:54:04 +0800

資料結構實機實驗報告5——哈夫曼樹的編碼和解碼，排序二元樹的建構和節點刪除

作者：孤筝（lvbowen040427@163.com）

實現哈夫曼樹的編碼和解碼

a. 問題分析

目標：

實現排序二叉樹的構建和節點刪除。

問題：

構建排序二叉樹的過程是否正確？
是否正確實現了節點的插入和刪除？
是否能夠處理重複值的節點？
是否能夠正確處理樹的平衡性？

b. 算法設計

1. 構建排序二叉樹：

根據輸入的數據，依次插入節點到排序二叉樹中。

輸入： 一組數據值。 輸出： 排序二叉樹的根節點 root。

TreeNode* buildBST(vector<int>& values) {
    TreeNode* root = nullptr;
    for (int val : values) {
        root = insertNode(root, val);
    }
    return root;
}

2. 插入節點：

遞歸地找到合適的位置插入新節點。

輸入： 當前子樹的根節點 node，要插入的值 val。 輸出： 插入後的子樹根節點。

TreeNode* insertNode(TreeNode* node, int val) {
    if (node == nullptr) {
        return new TreeNode(val);
    }
    if (val < node->val) {
        node->left = insertNode(node->left, val);
    } else if (val > node->val) {
        node->right = insertNode(node->right, val);
    }
    return node;
}

3. 刪除節點：

找到要刪除的節點，並根據其子節點的情況進行刪除操作。

輸入： 當前子樹的根節點 node，要刪除的值 val。 輸出： 刪除後的子樹根節點。

TreeNode* deleteNode(TreeNode* node, int val) {
    if (node == nullptr) {
        return nullptr;
    }
    if (val < node->val) {
        node->left = deleteNode(node->left, val);
    } else if (val > node->val) {
        node->right = deleteNode(node->right, val);
    } else {
        if (node->left == nullptr) {
            TreeNode* temp = node->right;
            delete node;
            return temp;
        } else if (node->right == nullptr) {
            TreeNode* temp = node->left;
            delete node;
            return temp;
        }
        TreeNode* temp = findMin(node->right);
        node->val = temp->val;
        node->right = deleteNode(node->right, temp->val);
    }
    return node;
}

4. 查找最小節點：

在右子樹中找到最小的節點（用於刪除節點時替換）。

輸入： 當前子樹的根節點 node。 輸出： 最小節點的指針。

TreeNode* findMin(TreeNode* node) {
    while (node->left != nullptr) {
        node = node->left;
    }
    return node;
}

c. 數據結構設計

TreeNode 結構體：
- 存儲節點值 val，以及左右子節點指針 left 和 right。
std::vector：
- 用於存儲輸入的數據值。
遞歸函數：
- 用於實現節點的插入和刪除操作。

d. 調試過程

構建排序二叉樹：
- 檢查節點是否按照排序二叉樹的規則正確插入。
- 檢查重複值的處理是否正確。
刪除節點：
- 測試刪除葉子節點、只有一個子節點的節點和兩個子節點的節點。
- 檢查刪除後樹的結構是否仍然符合排序二叉樹的規則。
平衡性檢查：
- 雖然排序二叉樹不保證平衡，但檢查極端情況下（如完全升序或降序輸入）樹的深度是否過大。

e. 輸出結果

運行程序並使用測試用例（例如輸入 [5,3,6,2,4,7] 並刪除節點 3）檢查輸出結果。確保輸出包括構建後的樹結構和刪除節點後的樹結構，並驗證其正確性。

Original BST:
    5
   / \
  3   6
 / \   \
2   4   7

After deleting node 3:
    5
   / \
  4   6
 /     \
2       7

f. 源代碼

#include 
#include 
#include 

using namespace std;

// 定義二叉樹節點結構
struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

// 插入節點到排序二叉樹
TreeNode* insertNode(TreeNode* node, int val) {
    if (node == nullptr) {
        return new TreeNode(val);
    }
    if (val < node->val) {
        node->left = insertNode(node->left, val);
    } else if (val > node->val) {
        node->right = insertNode(node->right, val);
    }
    return node;
}

// 構建排序二叉樹
TreeNode* buildBST(vector<int>& values) {
    TreeNode* root = nullptr;
    for (int val : values) {
        root = insertNode(root, val);
    }
    return root;
}

// 查找最小節點
TreeNode* findMin(TreeNode* node) {
    while (node->left != nullptr) {
        node = node->left;
    }
    return node;
}

// 刪除節點
TreeNode* deleteNode(TreeNode* node, int val) {
    if (node == nullptr) {
        return nullptr;
    }
    if (val < node->val) {
        node->left = deleteNode(node->left, val);
    } else if (val > node->val) {
        node->right = deleteNode(node->right, val);
    } else {
        if (node->left == nullptr) {
            TreeNode* temp = node->right;
            delete node;
            return temp;
        } else if (node->right == nullptr) {
            TreeNode* temp = node->left;
            delete node;
            return temp;
        }
        TreeNode* temp = findMin(node->right);
        node->val = temp->val;
        node->right = deleteNode(node->right, temp->val);
    }
    return node;
}

// 打印二叉樹（層序遍歷）
void printBST(TreeNode* root) {
    if (root == nullptr) {
        return;
    }
    queue<TreeNode*> q;
    q.push(root);
    while (!q.empty()) {
        TreeNode* node = q.front();
        q.pop();
        cout << node->val << " ";
        if (node->left != nullptr) {
            q.push(node->left);
        }
        if (node->right != nullptr) {
            q.push(node->right);
        }
    }
    cout << endl;
}

int main() {
    vector<int> values = {5, 3, 6, 2, 4, 7};
    TreeNode* root = buildBST(values);

    cout << "Original BST: ";
    printBST(root);

    root = deleteNode(root, 3);
    cout << "After deleting node 3: ";
    printBST(root);

    return 0;
}

總結

通過測試，確保程序正確實現了排序二叉樹的構建和節點刪除功能。特別注意刪除節點時樹的結構是否仍然符合排序二叉樹的規則，並檢查重複值的處理是否正確。雖然排序二叉樹不保證平衡，但在實際應用中可以考慮進一步優化（如 AVL 樹或紅黑樹）以保持平衡性。

問題分析

本實驗的目標是實現基於排序二元樹的節點插入、中序遍歷、刪除整個樹以及刪除單獨某個節點的功能。具體要求包括使用struct實現節點，實現插入節點和刪除節點的功能。

b 演算法設計

插入節點演算法設計

插入節點的演算法是一個遞迴演算法。根據節點值與當前節點值的比較，選擇插入到左子樹或右子樹。如果當前子樹為空，創建一個新節點並返回；否則，遞迴調用插入函數。

TreeNode* insert(TreeNode* root, int val) {
    if (root == nullptr) {
        return new TreeNode(val);
    }

    if (val <= root->data) {
        root->left = insert(root->left, val);
    } else if (val > root->data) {
        root->right = insert(root->right, val);
    }

    return root;
}

構建排序二元樹演算法設計

構建排序二元樹的演算法使用了插入節點演算法。遍歷輸入序列，對每個元素調用插入節點函數，不斷更新根節點，最終得到一個排序二元樹。

TreeNode* buildTree(int input[], int size) {
    TreeNode* root = nullptr;

    for (int i = 0; i < size; ++i) {
        root = insert(root, input[i]);
    }

    return root;
}

中序遍歷演算法設計

中序遍歷演算法用於輸出排序二元樹的節點值，以驗證樹的構建是否正確。

void inorderTraversal(TreeNode* node) {
    if (node != nullptr) {
        inorderTraversal(node->left);
        cout << node->data << " ";
        inorderTraversal(node->right);
    }
}

刪除整個樹演算法設計

刪除整個樹的演算法是一個遞迴演算法。遞迴調用刪除函數，刪除左子樹和右子樹，最後刪除當前節點。

void deleteTree(TreeNode* node) {
    if (node != nullptr) {
        deleteTree(node->left);
        deleteTree(node->right);
        delete node;
    }
}

刪除單獨某個節點演算法設計

刪除單獨某個節點的演算法是一個遞迴演算法。根據節點值與待刪除值的比較，選擇在左子樹或右子樹中進行刪除。如果找到匹配的節點，分三種情況處理：節點沒有子節點、節點有一個子節點、節點有兩個子節點。

TreeNode* deleteNode(TreeNode* root, int val) {
    if (root == nullptr) {
        return root;
    }

    // 找到匹配節點
    if (val < root->data) {
        root->left = deleteNode(root->left, val);
    } else if (val > root->data) {
        root->right = deleteNode(root->right, val);
    } else {
        // 節點有一個或無子節點
        if (root->left == nullptr) {
            TreeNode* temp = root->right;
            delete root;
            return temp;
        } else if (root->right == nullptr) {
            TreeNode* temp = root->left;
            delete root;
            return temp;
        }

        // 節點有兩個子節點，找到右子樹的最小節點
        TreeNode* minRight = root->right;
        while (minRight->left != nullptr) {
            minRight = minRight->left;
        }

        // 複製最小節點的值到當前節點
        root->data = minRight->data;

        // 刪除右子樹中的最小節點
        root->right = deleteNode(root->right, minRight->data);
    }

    return root;
}

// 刪除單獨某個節點的介面函數
TreeNode* deleteSingleNode(TreeNode* root, int val) {
    TreeNode* nodeToDelete = findNode(root, val);
    if (nodeToDelete != nullptr) {
        root = deleteNode(root, val);
    }
    return root;
}

c 資料結構設計

節點結構

struct TreeNode {
    int data;
    TreeNode* left;
    TreeNode* right;

    TreeNode(int val) : data(val), left(nullptr), right(nullptr) {}
};

d 調試過程

在調試過程中，首先確保 deleteSingleNode 函數能夠正確執行。通過刪除單獨某個節點後，使用中序遍歷驗證排序二叉樹的節點值，以確保刪除操作的正確性。最後，通過輸出驗證整個實現的正確性。

e 輸出結果

針對輸入序列 7, 5, 9, 2, 5, 2, 6, 3, 7, 0，實驗的輸出結果如下：

排序二元樹: 0 2 2 3 5 5 6 7 7 9 
刪除節點 3 後的排序二元樹: 0 2 2 5 5 6 7 7 9 
刪除單獨節點 5 後的排序二元樹: 0 2 2 6 7 7 9

這個輸出結果表明刪除單獨某個節點的功能已經添加，並且在刪除節點 5 後，中序遍歷輸出排序二元樹的節點值，驗證刪除操作的正確性。

f 原始碼

#include 

using namespace std;

// 定義二元樹節點
struct TreeNode {
    int data;
    TreeNode* left;
    TreeNode* right;

    TreeNode(int val) : data(val), left(nullptr), right(nullptr) {}
};

// 插入節點到排序二元樹
TreeNode* insert(TreeNode* root, int val) {
    if (root == nullptr) {
        return new TreeNode(val);
    }

    if (val <= root->data) {
        root->left = insert(root->left, val);
    } else if (val > root->data) {
        root->right = insert(root->right, val);
    }

    return root;
}

// 中序遍歷
void inorderTraversal(TreeNode* node) {
    if (node != nullptr) {
        inorderTraversal(node->left);
        cout << node->data << " ";
        inorderTraversal(node->right);
    }
}

// 刪除整個樹
void deleteTree(TreeNode* node) {
    if (node != nullptr) {
        deleteTree(node->left);
        deleteTree(node->right);
        delete node;
    }
}

// 查找節點值為val的節點
TreeNode* findNode(TreeNode* root, int val) {
    if (root == nullptr || root->data == val) {
        return root;
    }

    if (val < root->data) {
        return findNode(root->left, val);
    } else {
        return findNode(root->right, val);
    }
}

// 刪除單獨某個節點
TreeNode* deleteNode(TreeNode* root, int val) {
    if (root == nullptr) {
        return root;
    }

    // 找到匹配節點
    if (val < root->data) {
        root->left = deleteNode(root->left, val);
    } else if (val > root->data) {
        root->right = deleteNode(root->right, val);
    } else {
        // 節點有一個或無子節點
        if (root->left == nullptr) {
            TreeNode* temp = root->right;
            delete root;
            return temp;
        } else if (root->right == nullptr) {
            TreeNode* temp = root->left;
            delete root;
            return temp;
        }

        // 節點有兩個子節點，找到右子樹的最小節點
        TreeNode* minRight = root->right;
        while (minRight->left != nullptr) {
            minRight = minRight->left;
        }

        // 複製最小節點的值到當前節點
        root->data = minRight->data;

        // 刪除右子樹中的最小節點
        root->right = deleteNode(root->right, minRight->data);
    }

    return root;
}

// 刪除單獨某個節點的介面函數
TreeNode* deleteSingleNode(TreeNode* root, int val) {
    TreeNode* nodeToDelete = findNode(root, val);
    if (nodeToDelete != nullptr) {
        root = deleteNode(root, val);
    }
    return root;
}

int main() {
    int input[] = {7, 5, 9, 2, 5, 2, 6, 3, 7, 0};
    TreeNode* root = nullptr;

    // 構建排序二元樹
    for (int i = 0; i < 10; ++i) {
        root = insert(root, input[i]);
    }

    // 顯示排序二元樹
    cout << "排序二元樹: ";
    inorderTraversal(root);
    cout << endl;

    // 刪除節點 3 後的排序二元樹
    int nodeToDelete = 3;
    root = deleteNode(root, nodeToDelete);
    cout << "刪除節點 " << nodeToDelete << " 後的排序二元樹: ";
    inorderTraversal(root);
    cout << endl;

    // 刪除單獨節點 5 後的排序二元樹
    int singleNodeToDelete = 5;
    root = deleteSingleNode(root, singleNodeToDelete);
    cout << "刪除單獨節點 " << singleNodeToDelete << " 後的排序二元樹: ";
    inorderTraversal(root);
    cout << endl;

    // 刪除整個樹
    deleteTree(root);

    return 0;
}

本文2023-12-12首發於孤筝の温暖小家，最後修改於2023-12-12

本部落格所有文章除特別聲明外，均採用 BY-NC-SA 授權協議。轉載請註明出處！

資料結構實機實驗報告4——二元樹的建構（完全二元樹BFS結果）、儲存（順序儲存與鏈式儲存）、遍歷（BFS與DFS）

lvbowen040427@163.com (孤筝) — Tue, 12 Dec 2023 14:43:54 +0800

資料結構實機實驗報告4——二元樹的建構（完全二元樹BFS結果）、儲存（順序儲存與鏈式儲存）、遍歷（BFS與DFS）

作者：孤筝（lvbowen040427@163.com）

1. 根據輸入建立二元樹，順序儲存和鏈結儲存

a. 問題分析：

在這個問題中，需要根據輸入的字元序列建立一個二元樹，要求實現兩種儲存方式：順序儲存和鏈式儲存。輸入的字元序列中，字元 ‘@’ 表示空節點。

b. 演算法設計：

順序儲存方式：

初始化一個陣列來表示順序儲存的二元樹。
依序遍歷輸入字元序列，將字元按照順序儲存到陣列中。
可以使用陣列的索引來表示節點的位置，假設父節點的索引為 i，則左子節點的索引為 2*i + 1，右子節點的索引為 2*i + 2。
將 ‘@’ 字元表示的空節點跳過，只儲存實際的資料。

鏈結儲存方式：

建立一個結構體 TreeNode 來表示二元樹的節點，包含資料、左子樹指標和右子樹指標。
使用佇列資料結構輔助建構二元樹。初始化一個根節點，將其入隊。
遍歷輸入字元序列，每次從佇列中取出一個節點，為其建立左子節點和右子節點，然後將它們入隊。

c. 資料結構設計：

順序存儲方式：

struct TreeNode 用於表示二元樹的節點。
陣列用於順序存儲二元樹節點。

鏈式存儲方式：

struct TreeNode 用於表示二元樹的節點，包含資料、左子樹指標和右子樹指標。
佇列資料結構用於輔助構建二元樹。

d. 除錯過程：

執行程式，按照輸入範例輸入字元以建構二元樹。
確保輸入的字元順序正確，空節點用 ‘@’ 表示。
鏈式儲存時用’#‘表示輸入完畢
驗證建立的二元樹的順序儲存和鏈式儲存是否正確。

e. 輸出結果：

輸出結果包括順序儲存的二元樹節點資料和鏈式儲存的二元樹的遍歷結果。

2. 深度遍歷演算法的實現

a. 問題分析：

在這個問題中，需要實現深度遍歷演算法，包括前序遍歷、中序遍歷和後序遍歷。對於順序儲存的二元樹，需要實現相應的遍歷演算法。

b. 演算法設計：

前序遍歷：

訪問根節點，然後遞迴遍歷左子樹和右子樹。

中序遍歷：

先遞迴遍歷左子樹，然後訪問根節點，最後遞迴遍歷右子樹。

後序遍歷：

先遞迴遍歷左子樹和右子樹，然後訪問根節點。

c. 資料結構設計：

遞迴演算法。

3. 廣度遍歷演算法的實現

a. 問題分析：

在這個問題中，需要實現廣度遍歷演算法（層次遍歷）。對於鏈式存儲的二元樹，需要實現相應的遍歷演算法。

b. 演算法設計：

使用佇列資料結構，從根節點開始，將節點逐層加入佇列，並逐個存取佇列中的節點。

c. 資料結構設計：

佇列資料結構。

非常抱歉，我理解你的要求，下面將使用具體的樣例 abc@@@d@ef@ 和 abc@@@d@ef@# 來完善調試過程和輸出結果，並結合你提供的程式碼進行說明。

樣例

abc@@@d@ef@，abc@@@d@ef@#

調試過程：

使用順序存儲方式：
- 依次讀入字元 ‘a’， ‘b’， ‘c’， ‘@’， ‘@’， ‘@’， ’d’， ‘@’， ’e’， ‘f’。
- 構建順序存儲的二元樹，陣列元素如下： ['a', 'b', 'c', '@', '@', '@', 'd', '@', 'e', 'f']。
使用鏈式存儲方式：
- 創建根節點 ‘a’，將其入隊。
- 讀入字元 ‘b’，創建 ‘a’ 的左子節點 ‘b’，將其入隊。
- 讀入字元 ‘c’，創建 ‘a’ 的右子節點 ‘c’，將其入隊。
- 讀入字元 ‘@’，表示左子節點為空。
- 讀入字元 ‘@’，表示右子節點為空。
- 讀入字元 ’d’，創建 ‘b’ 的左子節點 ’d’，將其入隊。
- 讀入字元 ‘@’，表示右子節點為空。
- 讀入字元 ’e’，創建 ‘c’ 的左子節點 ’e’，將其入隊。
- 讀入字元 ‘f’，創建 ‘c’ 的右子節點 ‘f’，將其入隊。

輸出結果：

順序存儲方式：
- 先序遍歷結果： a b d c e f
- 中序遍歷結果： d b a e c f
- 後序遍歷結果： d b e f c a
鏈式存儲方式：
- 前序遍歷結果： a b d c e f
- 中序遍歷結果： b d a e c f
- 後序遍歷結果： d b e f c a
- 廣度優先搜索（層次遍歷）結果： a b c d e f

原始碼

順序儲存

#include
using namespace std;
#define MAX_NODES 1000  // 最大節點數量
// 定義二元樹節點結構
struct TreeNode {
    char data;
};
// 創建一個新的二元樹節點
TreeNode* createNode(char data) {
    TreeNode* newNode = (TreeNode*)malloc(sizeof(TreeNode));
    newNode->data = data;
    return newNode;
}
// 順序儲存的字符二元樹結構
struct SequentialTree {
    TreeNode* nodes[MAX_NODES];
    int size; // 記錄節點數量
};
// 初始化順序儲存的字符二元樹
void initSequentialTree(SequentialTree* tree) {
    tree->size = 0;
    for (int i = 0; i < MAX_NODES; i++) {
        tree->nodes[i] = nullptr;
    }
}
// 插入一個節點到順序儲存的字符二元樹
void insertNode(SequentialTree* tree, char data) {
    if (tree->size < MAX_NODES) {
        TreeNode* newNode = createNode(data);
        tree->nodes[tree->size] = newNode;
        tree->size++;
    } else {
        printf("該二元樹已滿，無法插入節點\n");
    }
}
// 獲取根節點
TreeNode* getRoot(SequentialTree* tree) {
    return tree->nodes[0];
}
// 獲取左子節點
TreeNode* getLeftChild(SequentialTree* tree, int parentIndex) {
    int leftChildIndex = 2 * parentIndex + 1;
    if (leftChildIndex < tree->size) {//檢驗是否存在
        return tree->nodes[leftChildIndex];
    }
    return nullptr;
}
// 獲取右子節點
TreeNode* getRightChild(SequentialTree* tree, int parentIndex) {
    int rightChildIndex = 2 * parentIndex + 2;
    if (rightChildIndex < tree->size) {
        return tree->nodes[rightChildIndex];
    }
    return nullptr;
}
// 前序遍歷
void preorderTraversal(struct SequentialTree* tree, int index) {
    if (index >= tree->size || tree->nodes[index]->data == '@') {
        return;
    }
    printf("%c ", tree->nodes[index]->data); // 訪問根節點
    preorderTraversal(tree, 2 * index + 1); // 遍歷左子樹
    preorderTraversal(tree, 2 * index + 2); // 遍歷右子樹
}
// 中序遍歷
void inorderTraversal(struct SequentialTree* tree, int index) {
    if (index >= tree->size || tree->nodes[index]->data == '@') {
        return;
    }
    inorderTraversal(tree, 2 * index + 1); // 遍歷左子樹
    printf("%c ", tree->nodes[index]->data); // 訪問根節點
    inorderTraversal(tree, 2 * index + 2); // 遍歷右子樹
}
// 後序遍歷
void postorderTraversal(struct SequentialTree* tree, int index) {
    if (index >= tree->size || tree->nodes[index]->data == '@') {
        return;
    }
    postorderTraversal(tree, 2 * index + 1); // 遍歷左子樹
    postorderTraversal(tree, 2 * index + 2); // 遍歷右子樹
    printf("%c ", tree->nodes[index]->data); // 訪問根節點
}
int main() {
    SequentialTree* tree=(SequentialTree*)malloc(sizeof(SequentialTree));
    initSequentialTree(tree);
    char data='a';
    while (1){
        cin>>data;
        if(data=='#'){
            break;
        }
        insertNode(tree,data);
    }
    cout<<"先序遍歷結果:"<<endl;
    preorderTraversal(tree,0);
    cout<<endl;
    cout<<"中序遍歷結果:"<<endl;
    inorderTraversal(tree,0);
    cout<<endl;
    cout<<"後序遍歷結果:"<<endl;
    postorderTraversal(tree,0);
    cout<<endl;
    cout<<"層次遍歷結果:"<<endl;
    for(int i=0;i<tree->size;i++){
        if(tree->nodes[i]->data!='@')
            cout<<tree->nodes[i]->data<<' ';
    }
    cout<<endl;
    return 0;
}

鏈式儲存

#include
using namespace std;
// 二元樹節點結構
struct TreeNode {
    char data;
    TreeNode* left;
    TreeNode* right;
    TreeNode(char val) : data(val), left(nullptr), right(nullptr) {}
};
// 建立鏈式儲存的二元樹
TreeNode* createBinaryTree(const string& input) {
    if (input.empty()) {
        return nullptr;
    }
    queue<TreeNode*> nodeQueue;
    TreeNode* root = new TreeNode(input[0]);
    nodeQueue.push(root);
    for (int i = 1; i < input.length(); i += 2) {
        TreeNode* current = nodeQueue.front();
        nodeQueue.pop();
        if (input[i] != '@') {
            current->left = new TreeNode(input[i]);
            nodeQueue.push(current->left);
        }
        if (i + 1 < input.length() && input[i + 1] != '@') {
            current->right = new TreeNode(input[i + 1]);
            nodeQueue.push(current->right);
        }
    }
    return root;
}
// 前序遍歷
void preorderTraversal(TreeNode* root) {
    if (root) {
        cout << root->data << " ";
        preorderTraversal(root->left);
        preorderTraversal(root->right);
    }
}
// 中序遍歷
void inorderTraversal(TreeNode* root) {
    if (root) {
        inorderTraversal(root->left);
        cout << root->data << " ";
        inorderTraversal(root->right);
    }
}
// 後序遍歷
void postorderTraversal(TreeNode* root) {
    if (root) {
        postorderTraversal(root->left);
        postorderTraversal(root->right);
        cout << root->data << " ";
    }
}
// 廣度優先搜尋（層次遍歷）
void breadthFirstTraversal(TreeNode* root) {
    if (!root) {
        return;
    }
    queue<TreeNode*> nodeQueue;
    nodeQueue.push(root);
    while (!nodeQueue.empty()) {
        TreeNode* current = nodeQueue.front();
        nodeQueue.pop();
        cout << current->data << " ";
        if (current->left) {
            nodeQueue.push(current->left);
        }
        if (current->right) {
            nodeQueue.push(current->right);
        }
    }
}
int main() {
    string input;
    cin>>input;
    TreeNode* root = createBinaryTree(input);
    cout << "前序遍歷結果: ";
    preorderTraversal(root);
    cout << endl;
    cout << "中序遍歷結果: ";
    inorderTraversal(root);
    cout << endl;
    cout << "後序遍歷結果: ";
    postorderTraversal(root);
    cout << endl;
    cout << "廣度優先搜尋（層次遍歷）結果: ";
    breadthFirstTraversal(root);
    cout << endl;
    return 0;
}

本文2023-12-12首發於孤筝の温暖小家，最後修改於2023-12-12

本部落格所有文章除特別聲明外，均採用 BY-NC-SA 授權協議。轉載請註明出處！

資料結構實機實驗報告3——KMP演算法用於字串搜尋

lvbowen040427@163.com (孤筝) — Tue, 12 Dec 2023 14:42:01 +0800

資料結構實機實驗報告3——KMP演算法用於字串搜尋

作者：孤筝（lvbowen040427@163.com）

實驗目的：

本實驗旨在分析和測試KMP算法的實現，並研究其在字串搜尋中的應用。

實驗內容：

a 問題分析：

如何構建最長前綴後綴匹配表（LPS陣列）以提高搜尋效率？
如何在文本字串中執行匹配，利用LPS陣列來避免不必要的字元比較？
如何設計算法以實現模式字串的搜尋？

b 算法設計：

KMP算法的設計包括以下關鍵步驟：

構建LPS陣列：使用computeLPSArray函數來計算模式字串的LPS陣列，該陣列指示了模式字串中每個位置的前綴和後綴的最長匹配長度。
在文本中執行匹配：使用KMPSearch函數，該函數在文本字串中執行模式字串的匹配。它使用LPS陣列來智能地回溯，以提高搜尋效率。

c 資料結構設計：

在這次實驗中，我使用了以下資料結構：

字串：用於表示文本字串和模式字串。
向量（vector）：用於儲存LPS陣列。
整數變數：用於表示匹配過程中的索引。

d 調試過程：

在編寫和測試程式碼時，我遇到了一些可能的問題，如邏輯錯誤或邊界情況。這些問題需要仔細調試，以確保算法的正確性和性能。通過逐步調試和打印輸出結果，我確認程式碼能夠正確地找到模式字串在文本中的匹配位置。

e 輸出結果：

以下是一些範例輸出結果：

當文本字串為"ABABDABACDABABCABAB"，模式字串為"ABABCABAB"時，KMP算法找到了模式字串在文本中的匹配位置：

在索引 10 處找到匹配串

當文本字串和模式字串由使用者輸入時，KMP算法會在使用者提供的文本中查找使用者提供的模式，並輸出匹配位置。

f 原始碼：

#include
using namespace std;

// 計算匹配字串的最長前綴後綴匹配表（LPS陣列）
void computeLPSArray(const string& pattern, vector<int>& lps) {
    int length = 0;  // 前一個最長前綴後綴匹配的長度

    lps[0] = 0;  // lps[0] 總是為 0

    int i = 1;

    while (i < pattern.length()) {
        if (pattern[i] == pattern[length]) {
            length++;
            lps[i] = length;
            i++;
        } else {
            if (length != 0) {
                length = lps[length - 1];
            } else {
                lps[i] = 0;
                i++;
            }
        }
    }
}

// 使用KMP算法在文本中搜尋匹配字串
void KMPSearch(const string& text, const string& pattern) {
    int m = pattern.length();
    int n = text.length();

    vector<int> lps(m);
    computeLPSArray(pattern, lps);

    int i = 0;  // 用於文本[]
    int j = 0;  // 用於匹配串[]

    while (i < n) {
        if (pattern[j] == text[i]) {
            i++;
            j++;
        }

        if (j == m) {
            // 找到匹配串，打印起始位置
            cout << "在索引 " << i - j << " 處找到匹配串" << endl;
            j = lps[j - 1];
        } else if (i < n && pattern[j] != text[i]) {
            if (j != 0) {
                j = lps[j - 1];
            } else {
                i++;
            }
        }
    }
}

// int main() {
//     string text = "ABABDABACDABABCABAB";
//     string pattern = "ABABCABAB";

//     KMPSearch(text, pattern);

//     return 0;
// }


int main() {
    string text;
    string pattern;
    cin>>text;
    cin>>pattern;

    KMPSearch(text, pattern);

    return 0;
}

本文2023-12-12首發於孤筝の温暖小家，最後修改於2023-12-12

本部落格所有文章除特別聲明外，均採用 BY-NC-SA 授權協議。轉載請註明出處！

資料結構實機實驗報告2——稀疏矩陣乘法

lvbowen040427@163.com (孤筝) — Tue, 12 Dec 2023 14:38:24 +0800

資料結構實機實驗報告2——稀疏矩陣乘法

作者：孤筝（lvbowen040427@163.com）

問題分析

本實驗的主要目標是開發一個稀疏矩陣乘法演算法，該演算法能夠將兩個稀疏矩陣 A 和 B 相乘，然後輸出結果矩陣 C。在這個演算法中，稀疏矩陣使用三元組表示，並且使用者可以多次輸入不同的矩陣數據，計算它們的乘積。

演算法設計

稀疏矩陣乘法演算法的設計如下：

使用 struct 結構體來表示矩陣，其中包括矩陣的行數、列數、稀疏矩陣元素的個數，以及一個陣列用於儲存節點的資訊。
輸入函數 input 用於獲取矩陣的三元組表示，檢查輸入的合法性，然後儲存在記憶體中的結構體中。
輸出函數 output 將稀疏矩陣以標準矩陣的形式打印出來，便於使用者查看。
矩陣乘法函數 multiplier 接受兩個輸入矩陣 A 和 B，計算它們的乘積，並將結果儲存在矩陣 C 中。

資料結構設計

matrix 結構體包含了矩陣的行數 m、列數 n、稀疏矩陣元素的個數 L，以及 Ma 陣列用於儲存節點資訊。
node 結構體表示稀疏矩陣的每個非零元素，包括行索引 i、列索引 j 以及元素的值 data。

調試過程

程式碼中有一些錯誤處理機制，例如檢查輸入是否合法，檢查記憶體分配是否成功，以及檢查矩陣相乘是否合法。
在輸入稀疏矩陣數據時，使用者會得到錯誤訊息並要求重新輸入，以確保輸入的數據符合矩陣的大小。
稀疏矩陣乘法演算法中，會檢查矩陣的列和行是否匹配，以確保它們可以相乘。

輸出結果

Matlab驗證結果：

使用者可以輸入兩個矩陣 A 和 B，然後程式會計算它們的乘積並輸出結果矩陣 C。使用者可以選擇繼續進行稀疏矩陣乘法計算，也可以選擇退出程式。程式會一直運行，直到使用者選擇退出。

總結

總體而言，該實驗成功實現了稀疏矩陣的乘法操作，提供了友好的使用者介面和錯誤處理機制，以確保輸入的矩陣數據是有效的。然後，它正確計算了兩個稀疏矩陣的乘積並將結果以標準矩陣的形式輸出。

原始碼

#include
using namespace std;
#define MAX 1000

struct node{
    int i;
    int j;
    int data;
};
struct matrix{
    int m;
    int n;
    int L;
    node* Ma[MAX];
};

int input(matrix* A){
    int m,n,data;
    for(int i=0;i<A->L;i++){
        cin>>m>>n>>data;
        if(m<0||m>=A->m||n<0||n>=A->n){
            cout<<"輸入錯誤,行/列超出矩陣大小!"<<endl;
            return 1;
        }
        A->Ma[i]=(node*)malloc(sizeof(node));
        if(!A->Ma[i]){
            cout<<"申請空間失敗!"<<endl;
            return 2;
        }else{
            A->Ma[i]->i=m;
            A->Ma[i]->j=n;
            A->Ma[i]->data=data;
        }
    }
    return 0;
}

void output(matrix* A,string name){
    cout<<"矩陣"<<name<<"為:"<<endl;
    int nums[A->m][A->n];

    memset(nums,0,sizeof(nums));
    for(int i=0;i<A->L;i++){
        nums[A->Ma[i]->i][A->Ma[i]->j]=A->Ma[i]->data;
    }
    for(int i=0;i<A->m;i++){
        for(int j=0;j<A->n;j++){
            cout<<nums[i][j]<<'\t';
        }
        cout<<endl;
    }
}

void multiplier(matrix* A,matrix* B,matrix* C){
    C->m=A->m;
    C->n=B->n;
    C->L=0;
    int x,y,z;
    bool sert=false;
    for(int i=0;i<A->L;i++){
        for(int j=0;j<B->L;j++){
            if(A->Ma[i]->j==B->Ma[j]->i){//A的列號==B的行號
                x=A->Ma[i]->i;
                y=B->Ma[j]->j;
                z=A->Ma[i]->data*B->Ma[j]->data;
                sert=false;
                for(int k=0;k<C->L;k++){
                    if(x==C->Ma[k]->i&&y==C->Ma[k]->j){
                        C->Ma[k]->data+=z;
                        sert=true;
                        break;
                    }
                }
                if(!sert){
                    C->L++;
                    C->Ma[C->L-1]=(node*)malloc(sizeof(node));
                    C->Ma[C->L-1]->i=x;
                    C->Ma[C->L-1]->j=y;
                    C->Ma[C->L-1]->data=z;
                }
            }
        }
    }
}

int main(){
start:
    matrix* A=(matrix*)malloc(sizeof(matrix));
    matrix* B=(matrix*)malloc(sizeof(matrix));
    matrix* C=(matrix*)malloc(sizeof(matrix));
    cout<<"請輸入A矩陣三元組長度,矩陣行數,矩陣列數:"<<endl;
    cin>>A->L>>A->m>>A->n;
    cout<<"請輸入A矩陣:"<<endl;
    if(input(A)){
        cout<<"出現錯誤,請重新輸入!"<<endl;
        goto start;
    }
    output(A,"A");
    cout<<"請輸入B矩陣三元組長度,矩陣行數,矩陣列數:"<<endl;
    cin>>B->L>>B->m>>B->n;
    cout<<"請輸入B矩陣:"<<endl;
    if(input(B)){
        cout<<"出現錯誤,請重新輸入!"<<endl;
        goto start;
    }
    output(B,"B");
    multiplier(A,B,C);
    output(C,"C");

    cout<<"是否繼續進行稀疏矩陣乘法計算(y/n):";
    char choice;
choise:
    cin>>choice;
    if(choice=='y'||choice=='Y'){
        goto start;
    }else if(choice=='n'||choice=='N'){
        return 0;
    }else{
        cout<<"輸入錯誤,請重新輸入:";
        goto choise;
    }
    return 0;
}

本文2023-12-12首發於孤筝の温暖小家，最後修改於2023-12-12

本部落格所有文章除特別聲明外，均採用 BY-NC-SA 授權協議。轉載請註明出處！

資料結構上機實驗報告1——Fibonacci序列、劃分子集問題

lvbowen040427@163.com (孤筝) — Tue, 12 Dec 2023 14:31:17 +0800

資料結構上機實驗報告1——Fibonacci序列、劃分子集問題

作者：孤筝（lvbowen040427@163.com）

費波那契數列

問題分析

要正確實現程序的遞迴調用和返回，必須解決參數的傳遞和返回地址問題。具體地說，進行調用時，每遞迴一次都要給所有參變量重新分配儲存空間，並要把前一次調用的實參和本次調用後的返回地址保留。

演算法設計

演算法描述如下：

int Fib(int n){
    int fib;
    if(n==0) fib=0;
    else if(n==1) fib=1;
    else fib=Fib(n-1)+Fib(n-2);
    return fib;
}

資料結構設計

用堆疊去分配和管理儲存空間，系統在每次執行呼叫過程的語句時需要開闢一個「工作記錄」，用以保存呼叫前過程中所有參變數的值及呼叫後的返回位址，將此工作記錄存於堆疊中，以便在返回時能在堆疊頂端找到正確的資訊。

除錯過程

在每次呼叫函數的時候，將傳入的參數進行輸出，可以更直觀地看到堆疊的呼叫過程。以最開始Fib（2）的遞迴呼叫為例，程式先將Fib（5）、Fib（4）…Fib（1）儲存到堆疊中，當n==1時，將值返回上一個位址中，同理也將n==0時的值返回，這樣Fib（2）的值便有了，再返回到Fib（2）的上一個層級Fib（3）中。

輸出結果

原始碼

#include
using namespace std;

int Fibonacci(int n){
    int fib;
    if(n==0){
        fib=0;
    }else if(n==1){
        fib=1;
    }else if(n==2){
        fib=2;
    }else{
        fib=Fibonacci(n-1)+Fibonacci(n-2);
    }
    return fib;
}

int main(){
    int n=0;
    cout<<"請輸入n:";
start:
    cin>>n;
    cout<<"第n個Fibonacci數為"<<Fibonacci(n)<<endl;
    cout<<"是否繼續計算(y/n):";
    char choice;
choice:
    cin>>choice;
    if(choice=='y'||choice=='Y'){
        goto start;
    }else if(choice=='n'||choice=='N'){
        return 0;
    }else{
        cout<<"輸入錯誤,請重新輸入:";
        goto choice;
    }
    return 0;
}

劃分子集問題

問題分析

問題要求我們將一個集合中劃分成互不相交的子集，使任何子集上的元素無任何衝突，且劃分的子集數較少。此類問題常用在日程安排上。

演算法設計

衝突關係首先透過一個二維陣列表示出來，有衝突關係則賦值1，無衝突則賦值0。透過循環篩選法對其劃分，即從第一個元素開始，先將元素1單獨拿出，逐個判斷其他元素是否和拿出的所有元素有衝突關係，無衝突則拿出元素，並劃為一組。這樣循環一周，所有互相無衝突關係的已被劃為一組，循環此操作，即可完成劃分要求。

資料結構設計

透過一個循環佇列來儲存資料，每次循環一週，不斷迭代資料，不需要開闢新的儲存空間。

除錯過程

輸出結果

原始碼

#include
using namespace std;
int newr[9];

void DivideIntoGroup(int n,int R[][9],int cp[],int result[])
{
    int front,rear,group,pre,I,i;
    front=n-1;
    rear=n-1;
    for(i=0;i<n;i++)
    {
        newr[i]=0;
        cp[i]=i+1;
    }
    group=1;
    pre=0;
    do
    {
        front=(front+1)%n;
        I=cp[front];
        if(I<pre)
        {
            group=group+1;
            result[I-1]=group;
            for(i=0;i<n;i++)
            {
                newr[i]=R[I-1][i];
            }

        }
        else
        {
            if(newr[I-1]!=0)
            {
                rear=(rear+1)%n;
                cp[rear]=I;
            }
            else
            {
                result[I-1]=group;
                for(i=0;i<n;i++)
                {
                    newr[i]+=R[I-1][i];
                }
            }
        }
        pre=I;
    }while(rear!=front);
}
int main(){
    int result[9],cp[9];
    int R[9][9]=
    {
        {0,1,0,0,0,0,0,0,0},
        {1,0,0,0,1,1,0,1,1},
        {0,0,0,0,0,1,1,0,0},
        {0,0,0,0,1,0,0,0,1},
        {0,1,0,1,0,1,1,0,1},
        {0,1,1,0,1,0,1,0,0},
        {0,0,1,0,1,1,0,0,0},
        {0,1,0,0,0,0,0,0,0},
        {0,1,0,1,1,0,0,0,0},
    };
    DivideIntoGroup(9,R,cp,result);
    for(int i=0;i<9;i++)
    {
        cout<<i+1<<" ";
    }
    cout<<endl;
    for(int i=0;i<9;i++)
    {
        cout<<result[i]<<" ";
    }
    return 0;
}

本文2023-12-12首發於孤筝の温暖小家，最後修改於2023-12-12

本部落格所有文章除特別聲明外，均採用 BY-NC-SA 授權協議。轉載請註明出處！