{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"provenance":[{"file_id":"1AB3RNlLfkZBSZKu6_Wh20CkIpbxfJIve","timestamp":1663461789208}],"collapsed_sections":[],"authorship_tag":"ABX9TyMFBzGPzEJoWeXrsTNAIRVz"},"kernelspec":{"name":"python3","display_name":"Python 3"},"language_info":{"name":"python"}},"cells":[{"cell_type":"markdown","source":["#計算機程式設計二\n","#第五週上課內容\n","\n","## 主題：Binary Trees"],"metadata":{"id":"9xoK4OIjIfZA"}},{"cell_type":"markdown","source":["###GitHub 教材參考資料\n","\n","[i2p-nthu 程式設計二 Binary Trees](https://github.com/htchen/i2p-nthu/blob/master/%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88%E4%BA%8C/mid1/4-binary_tree.md)\n","\n","\n","\n"],"metadata":{"id":"05G1Fqg6GRZX"}},{"cell_type":"markdown","source":["這份講義想要解釋 binary tree 範例。\n","\n","用下圖的 binary tree 當作例子。最上面的 `Node` 叫做 root，然後長出左右兩個分支，兩個分支各自也都具備 binary tree 的結構。我們假設每個 `Node` 裡面放的數字都不相同。\n","\n","root node 根節點\n","\n","internal node \n","\n","leaf node （末梢，沒有分支，沒有子樹）\n","\n","subtree 子樹\n","\n","child node\n","\n","\n","```\n"," 2\n"," / \\\n"," 7 5 \n"," / \\ \\\n"," 3 6 9\n"," / \\ \\\n"," 8 11 4 \n","\n","``` "],"metadata":{"id":"azEB13vJtHte"}},{"cell_type":"markdown","source":["如果我們採用某種規則，依照一定的順序走過每個 `Node`，會得到一個序列。\n","\n","## in-order\n","譬如，從 root (裡面放的數字是 2) 開始，如果我們每次都先走左邊的分支，然後一路向下，直到左邊的分支的全部的`Node`都被走過，接著才走中間的 2，然後才繼續將右邊分支全走過，這樣得到的序列順序稱作 in-order，得到的序列會像底下這樣：\n","\n","```\n","3 7 8 6 11 2 5 9 4\n","```\n","\n","用遞迴的觀點來看，問題可以拆解成\n","1. 用 in-order 方式走過左邊以`7`為 root 的分支\n","2. 走過 root `2`\n","3. 用 in-order 方式走過右邊以`5`為 root 的分支\n","\n","接下來，以`7`為 root 的分支，如果要繼續用 in-order 方式走過，一樣是\n","1. 用 in-order 方式走過左邊以`3`為 root 的分支\n","2. 走過 root `7`\n","3. 用 in-order 方式走過右邊以`6`為 root 的分支\n","\n","如此不斷進行下去，直到碰到某個末梢 (稱作 leaf)，就不用再繼續下去。以這個例子來說，最早被走到的 leaf 是 `3`。\n","\n","總之，只要每次都遵守 *左 中 右* 的原則，全部左邊的分支都走過，才可以走中間，然後才可以走右邊分支，如此就可以列出 in-order 的序列。\n","\n","##pre-order\n","還有一種走法叫做 pre-order，每次都是先走中間的 `Node`，然後才把左邊的分支整個走過，接著才將右邊的分支整個走過。得到的序列會像底下這樣\n","```\n","2 7 3 6 8 11 5 9 4\n","```\n","\n","##從 pre-order 和 in-order 建構出 binary tree\n","前面已經看過，對於任一個 binary tree，我們可以列出 in-order 和 pre-order 序列。如果是反過來呢？ 假設已知 in-order 序列，或是已知 pre-order 序列，能否決定 binary tree 的長相？ \n","事實上，如果只知道 in-order 或 pre-order，並無法決定唯一可能的 binary tree 結構。但是如果同時給了 in-order 和 pre-order 序列，而且每個 `Node` 編號 (或是資料）都不相同，則一定可以決定出唯一的 binary tree 該長成甚麼樣子。我們試著寫程式來完成這項任務。\n","\n","首先要讀取 pre-order 和 in-order 序列。從 pre-order 的第一個數，可以知道如何將 in-order 序列分成左右兩段。例如\n","```\n"," pre-order: 2 7 3 6 8 11 5 9 4\n"," in-order: 3 7 8 6 11 2 5 9 4\n","```\n","\n","我們知道 pre-order 的第一個數 `2` 就是 root。接著就可以把 in-order 序列以 `2` 為分隔點，分成 `3 7 8 6 11` 以及 `5 9 4` 兩段。\n","```\n","\tpre-order: 7 3 6 8 11 5 9 4\n","\tin-order left: 3 7 8 6 11\n","\tin-order right: 5 9 4\n","```\n","\n","先從左邊開始，所以接下來的問題會變成\n","```\n","\tpre-order: 7 3 6 8 11 5 9 4\n","\tin-order: 3 7 8 6 11\n","```\n","\n","然後從 pre-oreder 的第一個數 `7`，我們知道要把 in-order 序列分成 `3` 和 `8 6 11`\n","```\n","\tpre-order: 3 6 8 11 5 9 4\n","\tin-order left: 3\n","\tin-order right: 8 6 11\n","```\n","\n","繼續走左邊，問題變成\n","```\n","\tpre-order: 3 6 8 11 5 9 4\n","\tin-order: 3\n","```\n","\n","這時候就可以建出一個 leaf `Node`，裡面放的數字是 `3`。然後，回到上一層，處理右邊\n","```\n","\tpre-order: 6 8 11 5 9 4\n","\tin-order: 8 6 11\n","```\n","\n","這時候 pre-order 第一個數是 `6`，分兩段變成\n","```\n","\tpre-order: 8 11 5 9 4\n","\tin-order left : 8\n","\tin-order right 11\n","```\n","\n","如此繼續做下去，最終我們可以把 pre-order 和 in-order 的每個數都看過一遍，而且可以依照對應的順序，把 binary tree 建構起來。"],"metadata":{"id":"mviKuWaapY32"}},{"cell_type":"code","source":["%%writefile E05_01.c\n","#include \n","#include \n","#define MIN -1000000\n","#define N 100\n","int in_seq[N];\n","int pre_seq[N];\n","\n","typedef struct t_node {\n"," int num;\n"," struct t_node *left;\n"," struct t_node *right; \n","} Node;\n","\n","Node *new_node(int num)\n","{\n"," Node *p = (Node *) malloc(sizeof(Node));\n"," p->num = num;\n"," p->left = NULL;\n"," p->right = NULL;\n"," return p;\n","}\n","\n","void in_order(Node *root)\n","{\n"," if (root) {\n"," in_order(root->left);\n"," printf(\" %d \", root->num);\n"," in_order(root->right);\n"," }\n","}\n","\n","void pre_order(Node *root)\n","{\n"," if (root) {\n"," printf(\" %d \", root->num);\n"," pre_order(root->left);\n"," pre_order(root->right);\n"," }\n","}\n","\n","void post_order(Node *root)\n","{\n"," if (root) {\n"," post_order(root->left);\n"," post_order(root->right);\n"," printf(\" %d \", root->num);\n"," }\n","}\n","\n","int find_in_seq(int start, int end, int num) {\n"," while (start <= end) {\n"," if (in_seq[start] == num) {\n"," return start;\n"," }\n"," start++;\n"," }\n"," return 0;\n","}\n","\n","/*\n"," start end\n"," cur idx\n"," [0] [1] [2] [3] [4] [5] [6] [7] [8]\n","pre-seq: 2 7 3 6 8 11 5 9 4\n","in-seq: 3 7 8 6 11 2 5 9 4\n","*/\n","\n","Node * build_tree(int start, int end)\n","{\n"," static int cur;\n"," if (start > end) return NULL;\n"," Node *p = new_node(pre_seq[cur]);\n"," cur++;\n"," if (startnum);\n"," p->left = build_tree(start, idx-1);\n"," p->right = build_tree(idx+1, end);\n"," }\n"," return p;\n","}\n","\n","void delete_tree(Node *p) \n","{\n"," if (p!=NULL) {\n"," delete_tree(p->left);\n"," delete_tree(p->right);\n"," free(p);\n"," }\n","}\n","\n","int find_max(Node *p)\n","{\n"," if (p!=NULL) {\n"," int left_max = find_max(p->left);\n"," if (left_max < p->num) {\n"," left_max = p->num;\n"," }\n"," int right_max = find_max(p->right);\n"," return (left_max > right_max) ? left_max : right_max;\n"," } else {\n"," return MIN;\n"," }\n","}\n","\n","void print_tree(FILE *fout, Node *p)\n","{\n"," static int dummy_node = -1;\n","\n"," if (p != NULL) {\n"," if (p->left != NULL) {\n"," fprintf(fout, \"%d -> %d;\\n\", p->num, p->left->num);\n"," print_tree(fout, p->left);\n"," } else {\n"," fprintf(fout, \"%d -> %d;\\n\", p->num, dummy_node--);\n"," }\n"," if (p->right != NULL) {\n"," fprintf(fout, \"%d -> %d;\\n\", p->num, p->right->num);\n"," print_tree(fout, p->right);\n"," } else {\n"," fprintf(fout, \"%d -> %d;\\n\", p->num, dummy_node--);\n"," }\n"," }\n","}\n","void write_gv(Node *tree, char *filename)\n","{\n"," FILE *fout = fopen(filename, \"w\");\n"," fprintf(fout, \"digraph T {\\n\");\n"," print_tree(fout, tree);\n"," fprintf(fout, \"}\\n\");\n","}\n","\n","int main(void)\n","{\n"," Node *root;\n"," int i, n;\n","\n"," scanf(\"%d\", &n);\n"," for (i=0; i 7;\n","7 -> 3;\n","3 -> -1;\n","3 -> -2;\n","7 -> 6;\n","6 -> 8;\n","8 -> -3;\n","8 -> -4;\n","6 -> 11;\n","11 -> -5;\n","11 -> -6;\n","2 -> 5;\n","5 -> -7;\n","5 -> 9;\n","9 -> -8;\n","9 -> 4;\n","4 -> -9;\n","4 -> -10;\n","}\n"]}]},{"cell_type":"markdown","source":["##寫程式\n","\n","###先定好 binary tree 所需的基本資料結構\n","```\n","typedef struct t_node {\n"," int data;\n"," struct t_node *left, *right;\n","} Node;\n","```\n","\n","每個 `Node` 裡面放的是整數。接下來就可以寫函數 `newNode`，用來產生一個新的 `Node`。\n","```\n","Node* newNode(int val)\n","{\n"," Node *node = (Node *) malloc(sizeof(Node));\n"," node->data = val;\n"," node->left = node->right = NULL;\n"," return node;\n","}\n","```\n","\n","接下來先看 `main` 裡面需要做哪些事\n","```\n","int main(void)\n","{\n"," int *in, *pre, n, i;\n"," scanf(\"%d\", &n); // get the size of tree\n"," in = (int *) malloc(n * sizeof(int)); //allocate space for inorder\n"," pre = (int *) malloc(n * sizeof(int)); // allocate space for preorder\n"," \n"," for(i=0; i inorder_end)\n"," return NULL;\n"," \n"," Node *tree_node = newNode(preorder[preorder_idx++]);\n"," if(inorder_start == inorder_end)\n"," return tree_node;\n"," \n"," int inorder_idx = \n"," idxSearch(inorder, inorder_start, inorder_end, tree_node->data);\n"," \n"," tree_node->left = \n"," constructTree(inorder, preorder, inorder_start, inorder_idx-1);\n"," tree_node->right = \n"," constructTree(inorder, preorder, inorder_idx+1, inorder_end);\n"," \n"," return tree_node;\n","}\n","```\n","\n","傳入的參數 `inorder_start` 和 `inorder_end`，用來標記目前要處理的是整個序列的哪一段。\n","至於 `preorder_idx` 則是一個 `static` 變數，不會因為函數呼叫結束就消失，所以會標記目前 pre-order 序列要檢查的是哪一個數，也就是目前用來將 in-order 序列分成左右的數，pre-order 序列一定是從左到右依序檢查。\n","\n","`tree_node` 指標所記錄的記憶體位置，是透過呼叫 `newNode` 產生的一個新的 `Node` 的位址，裡面放的數字是 `preorder[preorder_idx]`。假如 `inorder_start==inorder_end`，表示已經走到 leaf，這時候就可以把指標變數 `tree_node` 所記錄的位址傳回去。\n","\n","如果 `inorder_start` 小於 `inorder_end`，表示底下接的還是一個小的 binary tree，這時候就要用剛才存入 `tree_node->data` 的數，當作分界，找出那個數在 in-order 序列中的位置，然後把 in-order 序列分成兩半。搜尋位置是透過呼叫 `idxSearch` 來完成。\n","```\n","int idxSearch(int arr[], int start, int end, int value)\n","{\n"," int i;\n"," for (i = start; i <= end; i++)\n"," {\n"," if (arr[i] == value)\n"," return i;\n"," }\n"," return -1;\n","}\n","```\n","\n","找到之後把位置存在 `inorder_idx` 變數中。然後分別遞迴呼叫 `constructTree`，長出左右兩個分支。請注意傳入的起始和終止位置。\n","```\n","tree_node->left = constructTree(inorder, preorder, inorder_start, inorder_idx-1);\n","```\n","```\n","tree_node->right = constructTree(inorder, preorder, inorder_idx+1, inorder_end);\n","```\n","\n","兩個遞迴都結束之後，`tree_node` 就會指向一個基於目前處理的 in-order 序列範圍內所對應的 binary tree，最後把 `tree_node` 傳回去就完成了。\n"],"metadata":{"id":"iN_0HlHBEUWS"}},{"cell_type":"markdown","source":["\n","###把樹砍掉\n","```\n","void destroyTree(Node *root)\n","{\n"," if(root != NULL)\n"," {\n"," destroyTree(root->left);\n"," destroyTree(root->right);\n"," free(root);\n"," }\n","}\n","```\n","也是用遞迴呼叫來達成。\n"],"metadata":{"id":"vYJovEkZFZrw"}},{"cell_type":"markdown","source":["##找最大值\n","```\n","int maxValue(Node *tree)\n","{\n"," if (tree != NULL)\n"," {\n"," int maxval = tree->data;\n"," if (tree->left!=NULL) {\n"," int tmp = maxValue(tree->left);\n"," if (maxvalright!=NULL) {\n"," int tmp = maxValue(tree->right);\n"," if (maxval`)。假如 `tree` 不是 `NULL`，則做底下三件事：\n","1. 先假設目前的 `tree->data` 就是最大的數；\n","2. 如果左邊分支有東西，就遞迴呼叫 `tmp = maxValue(tree->left);` 找出其中最大的數，如果發現左邊最大的那個數，比目前假設最大的數還大，就更新；\n","3. 如果右邊分支有東西，就遞迴呼叫 `tmp = maxValue(tree->left);` 找出其中最大的數，如果發現右邊最大的那個數，比目前已知最大的數還大，就更新。"],"metadata":{"id":"Ao6gax6zFxi7"}},{"cell_type":"markdown","source":["##從 binary tree 生成 in-order 和 post-order 序列\n","```\n","void inorder(Node *root)\n","{\n"," if (root != NULL) {\n"," inorder(root->left);\n"," printf(\"%d \", root->data);\n"," inorder(root->right);\n"," }\n","}\n","void postorder(Node *root)\n","{\n"," if (root != NULL) {\n"," postorder(root->left);\n"," postorder(root->right);\n"," printf(\"%d \", root->data);\n"," }\n","}\n","```\n","\n","這兩件事很容易達成，關鍵在於遞迴呼叫以及 `printf` 的順序。如果是 in-order 序列，就依照 **左 中 右** 的順序，如果是 post-order 序列，則依照 **左 右 中** 的順序。"],"metadata":{"id":"kOHTpftrGV1_"}},{"cell_type":"markdown","source":["##視覺化\n","\n","最後我們要試著利用現成的工具，產生 binary tree 圖片。\n","\n","先到底下的網址，下載所需的軟體 graphviz：\n","http://www.graphviz.org/Download.php\n","\n","安裝完之後，就可以使用 GVEdit 程式。這個程式可以把 DOT 格式的文字檔，轉成對應的 graph 圖檔。\n","\n","假設我們產生了一個如下的 DOT 檔案，\n","```\n","\tdigraph T {\n","\t\t2 -> 7;\n","\t\t2 -> 5;\n","\t\t7 -> 3;\n","\t\t7 -> 6;\n","\t\t6 -> 8;\n","\t\t6 -> 11;\n","\t\t5 -> 9;\n","\t\t9 -> 4;\n","\t}\n","```\n","使用 GVEdit 程式就可以把上面的 binary tree 描述檔，轉成圖片\n","\n","所以我們只要寫程式，依照 binary tree 的長相，產生上述的 DOT 描述檔就行了，底下的兩個函數就是在做這件事。\n","```\n","void printTree(FILE *fout, Node *tree)\n","{\n"," if (tree!=NULL) {\n"," if (tree->left!=NULL)\n"," fprintf(fout, \"%d -> %d;\\n\", tree->data, tree->left->data);\n"," if (tree->right!=NULL)\n"," fprintf(fout, \"%d -> %d;\\n\", tree->data, tree->right->data);\n"," printTree(fout, tree->left);\n"," printTree(fout, tree->right);\n"," }\n","}\n","\n","void writeGV(Node *tree)\n","{\n"," FILE *fout = fopen(\"tree.gv\", \"w\");\n"," fprintf(fout, \"digraph T {\\n\");\n"," printTree(fout, tree);\n"," fprintf(fout, \"}\\n\");\n","}\n","```\n","\n","如果是 Mac OS，可以透過 `brew install graphviz` 安裝。如果要將 .gv 檔案轉成圖檔，只需要用 \n","`dot -Tpng tree.gv > tree.png`"],"metadata":{"id":"32Q5WhAOGuyg"}},{"cell_type":"code","source":["!apt -qqq install graphviz\n","!dot -Tpng tree.gv > tree.png\n","from IPython.display import Image\n","Image('tree.png')"],"metadata":{"id":"jRDKs2SfHnsO","colab":{"base_uri":"https://localhost:8080/","height":460},"executionInfo":{"status":"ok","timestamp":1665493158995,"user_tz":-480,"elapsed":2790,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"96b58f70-7713-40af-9a0b-3c066d624c22"},"execution_count":31,"outputs":[{"output_type":"execute_result","data":{"image/png":"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\n","text/plain":[""]},"metadata":{},"execution_count":31}]}]}