列印二叉樹的所有路徑

sunmenggmail發表於2012-04-16
二叉樹

http://blog.csdn.net/randyjiawenjie/article/details/6772145

看看思路，下面的小bug還比較多


二叉樹的常見問題有如下幾個，如果解決好了，就跟連結串列一樣輕鬆：唯一不一樣的是，二叉樹是非線性結構。常見的問題如下：

二叉樹的問題
1.二叉樹三種周遊（traversal）方式：

[cpp] view plaincopy
  1. 二叉樹的問題  
  2. 1.二叉樹三種周遊（traversal）方式：  
  3. 2.怎樣從頂部開始逐層列印二叉樹結點資料  
  4. 3.如何判斷一棵二叉樹是否是平衡二叉樹  
  5. 4.設計一個演算法，找出二叉樹上任意兩個節點的最近共同父結點，複雜度如果是O(n2)則不得  
  6.   
  7. 分。  
  8. 5.如何不用遞迴實現二叉樹的前序/後序/中序遍歷？  
  9. 6.在二叉樹中找出和為某一值的所有路徑  
  10. 7.怎樣編寫一個程式，把一個有序整數陣列放到二叉樹中？  
  11. 8.判斷整數序列是不是二叉搜尋樹的後序遍歷結果  
  12. 9.求二叉樹的映象  
  13. 10.一棵排序二叉樹（即二叉搜尋樹BST），令 f=(最大值+最小值)/2，設計一個演算法，找出距  
  14.   
  15. 離f值最近、大於f值的結點。複雜度如果是O(n2)則不得分。  
  16. 11.把二叉搜尋樹轉變成排序的雙向連結串列  
  17. 12.列印二叉樹中的所有路徑（與題目5很相似）  


3.如何判斷一棵二叉樹是否是平衡二叉樹
4.設計一個演算法，找出二叉樹上任意兩個節點的最近共同父結點，複雜度如果是O(n2)則不得分。
5.如何不用遞迴實現二叉樹的前序/後序/中序遍歷？
6.在二叉樹中找出和為某一值的所有路徑（注意是到葉子節點）
7.怎樣編寫一個程式，把一個有序整數陣列放到二叉樹中？
8.判斷整數序列是不是二叉搜尋樹的後序遍歷結果
9.求二叉樹的映象
10.一棵排序二叉樹（即二叉搜尋樹BST），令 f=(最大值+最小值)/2，設計一個演算法，找出距離f值最近、大於f值的結點。複雜度如果是O(n2)則不得分。
11.把二叉搜尋樹轉變成排序的雙向連結串列
12.列印二叉樹中的所有路徑（與題目6很相似）

解決思路：

1.二叉樹三種周遊（traversal）方式：任何一本資料結構的書都有描述，略過；

2.怎樣從頂部開始逐層列印二叉樹結點資料？

設定一個佇列，然後只要佇列不為空，將對首元素的左右孩子加入佇列（如果左右孩子不為空），然後將佇列的首元素出對即可，如下圖所示：

二叉樹如下圖所示：

那麼，整個過程如下：

自然，就輸出了a,b,c,d,e,f

3.如何判斷一個二叉樹是否是平衡的？

太簡單了，利用遞迴就可以了：判斷根節點的左右子樹深度之差是否小於等於1(這裡需要用到求深度的方法)，如果是，根節點就是平衡的；然後，在判斷根節點的左孩子和右孩子是否是平衡的。如此繼續下去，直到遇見葉子節點。一旦不是，立刻返回false;

計一個演算法，找出二叉樹上任意兩個節點的最近共同父結點，複雜度如果是O(n2)則不得分

首先找到這兩個點key1和key2，並且記錄下找到這兩個點的路徑Path1和Path2。然後，找到第一個點k滿足，key1<k<key2就可以了。

如圖：

假設key1 = 5，key2 = 7，那麼顯然，Path1{8,6,5}, Path2{8,6,7}。滿足第一個key1<k<key2的k為6。故k = 6。

至於怎麼求出Path1和Path2，可以看問題12。

5.如何不用遞迴實現二叉樹的前序/後序/中序遍歷？（網易面試就問到了，悲劇了，當時一下子卡住了）

看看書，基本任何一本資料結構的書都有，主要利用棧。

6.在二叉樹中找出和為某一值的所有路徑？

還是先解決12題目，訪問二叉樹到葉子節點的任意路徑。這個問題解決了，自然求和看是否滿足條件就可以了。

7.怎樣編寫一個程式，把一個有序整數陣列放到二叉樹中？

遞迴，還是利用遞迴：

設有int array[begin,end]，首先將array[(begin + end)/2]加入二叉樹，然後遞迴去做array[begin,(begin + end)/2 - 1]和array[(begin + end)/2 + 1, end]。注意寫好函式的形式就可以了。一切都很自然。

8.判斷整數序列是不是二叉搜尋樹的後序遍歷結果？

看看吧，後續遍歷是這樣做的：左右根，所以訪問的最有一個節點實際上就是整棵二叉樹的根節點root：然後，找到第一個大於該節點值的根節點b，b就是root右子樹最左邊的節點（大於根節點的最小節點）。那麼b前面的就是root的左子樹。既然是二叉搜尋樹的遍歷結果，那麼在b和root之間的遍歷結果，都應該大於b。去拿這個作為判斷的條件。

9.求二叉樹的映象？

還是利用遞迴：只要節點不為空，交換左右子樹的指標，然後在分別求左子樹的映象，再求右子樹的映象，直到節點為NULL。

10.一棵排序二叉樹（即二叉搜尋樹BST），令 f=(最大值+最小值)/2，設計一個演算法，找出距離f值最近、大於f值的結點。複雜度如果是O(n2)則不得分。

首先，在BST中，最小值就是最左邊的節點，最大值就是最右邊的節點。
在分別求出min和max後，求出f。然後利用查詢，找出一個大於f的節點就可以了。
複雜度為logN。

11.把二叉搜尋樹轉變成排序的雙向連結串列

12..列印二叉樹中的所有路徑

路徑的定義就是從根節點到葉子節點的點的集合。

還是利用遞迴：用一個list來儲存經過的節點，如果已經是葉子節點了，那麼列印list的所有內容；如果不是，那麼將節點加入list，然後繼續遞迴呼叫該函式，只不過，入口的引數變成了該節點的左子樹和右子樹。

程式如下：

[cpp] view plaincopy
  1. 解答1：自己看書了  
  2. 解答2：  
  3. //問題2：怎樣從頂部開始逐層列印二叉樹結點資料  
  4. void PrintAtLevel(BiTNode* root){  
  5.     vector<BiTNode*> vector;  
  6.     vector.push_back(root);  
  7.     while(!vector.empty()){  
  8.         BiTNode* tmp = vector.front();  
  9.         if(tmp->lchild != NULL)  
  10.             vector.push_back(tmp->lchild);  
  11.         if (tmp->rchild != NULL)  
  12.             vector.push_back(tmp->rchild);  
  13.         cout << tmp->data << endl;  
  14.         vector.pop_back();  
  15.     }  
  16. }  
  17. //問題3：如何判斷一棵二叉樹是否是平衡二叉樹  
  18. int isBalencedTree(treeNode* root){  
  19.     if (root == NULL)  
  20.         return 0;  
  21.     int depth1 = getDepth(root->lchild);  
  22.     int depth2 = getDepth(root->rchild);  
  23.     if (depth1 == depth2 || depth1 == depth2 + 1 || depth1 == depth2 - 1)  
  24.         return 1;  
  25.     else  
  26.         return 0;  
  27.     int flag1 = isBalencedTree(root->lchild);  
  28.     int flag2 = isBalencedTree(root->rchild);  
  29.     if (flag1 && flag2)  
  30.         return 1;  
  31.     else  
  32.         return 0;  
  33. }  
  34. //問題4：設計一個演算法，找出二叉樹上任意兩個節點的最近共同父結點，複雜度如果是O(n2)  
  35.   
  36. 則不得分。  
  37. int getPublicAncestors(treeNode* root,int key1,int key2){  
  38.     treeNode* ptr = root;  
  39.     int path1[1000];  
  40.     int pathLen1 = 0;  
  41.     while (ptr != NULL){  
  42.         if (key1 == ptr->data){  
  43.             path1[pathLen1] = ptr->data;  
  44.             pathLen1 ++;  
  45.             printArray(path1,pathLen1);  
  46.             break;  
  47.         }  
  48.         else  
  49.             if (ptr->data > key1){  
  50.                 path1[pathLen1] = ptr->data;  
  51.                 pathLen1 ++;  
  52.                 ptr = ptr->lchild;  
  53.             }  
  54.             else  
  55.                 if (ptr->data < key1){  
  56.                     path1[pathLen1] = ptr->data;  
  57.                     pathLen1 ++;  
  58.                     ptr = ptr->rchild;  
  59.                 }  
  60.     }  
  61.     ptr = root;  
  62.         int path2[1000];  
  63.         int pathLen2 = 0;  
  64.         while (ptr != NULL){  
  65.             if (key2 == ptr->data){  
  66.                 path2[pathLen2] = ptr->data;  
  67.                 pathLen2 ++;  
  68.                 printArray(path2,pathLen2);  
  69.                 break;  
  70.             }  
  71.             else  
  72.                 if (ptr->data > key2){  
  73.                     path2[pathLen2] = ptr->data;  
  74.                     pathLen2 ++;  
  75.                     ptr = ptr->lchild;  
  76.                 }  
  77.                 else  
  78.                     if (ptr->data < key2){  
  79.                         path2[pathLen2] = ptr->data;  
  80.                         pathLen2 ++;  
  81.                         ptr = ptr->rchild;  
  82.                     }  
  83.         }  
  84.     int i = pathLen1 - 1;  
  85.     //key1和key2有序，  
  86.     if (key2 < key1){  
  87.         key2 = key2^key1;  
  88.         key1 = key2^key1;  
  89.         key2 = key2^key1;  
  90.     }  
  91.     for (; i > 0; i --){  
  92.         if (key1 < path1[i] && path1[i]< key2){  
  93.             int result = path1[i];  
  94.             return result;  
  95.         }  
  96.     }  
  97. }  
  98. //問題6：在二叉樹中找出和為某一值的所有路徑  
  99. void FindPath(treeNode* root, int path[],int pathLen,int expectedSum, int   
  100.   
  101. currentSum){  
  102.     if (root == NULL)  
  103.         return;  
  104.     currentSum += root->data;  
  105.     path[pathLen] = root->data;  
  106.     pathLen ++;  
  107.     if (currentSum == expectedSum && root->lchild == NULL && root->rchild ==   
  108.   
  109. NULL){  
  110.         printArray(path,pathLen);  
  111.     }  
  112.     if (root->lchild != NULL){  
  113.         FindPath(root->lchild,path,pathLen,expectedSum,currentSum);  
  114.     }  
  115.     if (root->rchild != NULL){  
  116.             FindPath(root-  
  117.   
  118. >rchild,path,pathLen,expectedSum,currentSum);  
  119.         }  
  120.     currentSum -= root->data;  
  121. }  
  122.   
  123. //問題7：怎樣編寫一個程式，把一個有序整數陣列放到二叉樹中？  
  124. void createTreeFromArray(int a[], int begin, int end, treeNode** root){  
  125.     if (begin > end)  
  126.         return;  
  127.     else{  
  128.         *root = (treeNode*) malloc(sizeof(treeNode));  
  129.         int mid = (begin + end) / 2;  
  130.         (*root)->data = a[mid];  
  131.         (*root)->rchild = NULL;  
  132.         (*root)->lchild = NULL;  
  133.         createTreeFromArray(a, begin ,mid - 1, &(*root)->lchild);  
  134.         createTreeFromArray(a, mid + 1 ,end, &(*root)->rchild);  
  135.     }  
  136. }  
  137. //問題8：判斷整數序列是不是二叉搜尋樹的後//序遍歷結果  
  138. int isPostTraverse(int a[], int begin ,int end){  
  139.     if(begin >= end)  
  140.         return 1;  
  141.     else{  
  142.         int root = a[end];  
  143.         int lroot;  
  144.         int i;  
  145.         int location = begin;  
  146.         for (i = begin; i < end ; i ++){  
  147.             if(a[i] > root){  
  148.                 location = i;  
  149.                 lroot = a[i];  
  150.                 break;  
  151.             }  
  152.         }  
  153.         for (i = location + 1; i < end; i++){  
  154.             if (a[i] < lroot){  
  155.                 return 0;  
  156.             }  
  157.         }  
  158.         int flag1 = isPostTraverse(a,begin,location -1);  
  159.         int flag2 = isPostTraverse(a,location,end - 1);  
  160.         if (flag1 && flag2)  
  161.             return 1;  
  162.         else  
  163.             return 0;  
  164.     }  
  165. }  
  166. //問題9：求二叉樹的映象  
  167. void changeMirror(treeNode** root){  
  168.     if ( *root == NULL)  
  169.         return;  
  170.     else{  
  171.         treeNode* temp = (*root)->lchild;  
  172.         (*root)->lchild = (*root)->rchild;  
  173.         (*root)->rchild = temp;  
  174.         changeMirror(&(*root)->lchild);  
  175.         changeMirror(&(*root)->rchild);  
  176.     }  
  177. }  
  178. //問題10：10.一棵排序二叉樹（即二叉搜尋樹BST），令 f=(最大值+最小值)/2，設計一個算  
  179.   
  180. //法，找出距離f值最近、大於f值的結點。複雜度如果是O(n2)則不得分。  
  181. int findNearMid(treeNode** root){  
  182.     treeNode* ptr = *root;  
  183.     int min, max;  
  184.     while (ptr != NULL){  
  185.         min = ptr->data;  
  186.         ptr = ptr->lchild;  
  187.     }  
  188.     printf("the min is %d\n",min);  
  189.     ptr = *root;  
  190.     while (ptr != NULL){  
  191.         max = ptr->data;  
  192.         ptr = ptr->rchild;  
  193.     }  
  194.     printf("the max is %d\n",max);  
  195.     int half = (min + max) >> 1;  
  196.     printf("half is %d\n",half);  
  197.     ptr = *root;  
  198.     while (1){  
  199.         if (ptr->data < half){  
  200.             ptr = ptr->rchild;  
  201.         }  
  202.         else  
  203.             if (ptr->data > half){  
  204.                 int result = ptr->data;  
  205.                 return result;  
  206.             }  
  207.             else  
  208.             {  
  209.                 return (ptr->rchild)->data;  
  210.             }  
  211.     }  
  212. }  
  213. //問題12：列印二叉樹中的所有路徑（與題目5很相似）  
  214. void printPathsRecur(treeNode* node, int path[], int pathLen) {  
  215.     if (node == NULL)  
  216.         return;  
  217.     // append this node to the path array  
  218.     path[pathLen] = node->data;  
  219.     pathLen++;  
  220.     // it's a leaf, so print the path that led to here  
  221.     if (node->lchild == NULL && node->rchild == NULL) {  
  222.         printArray(path, pathLen);  
  223.     } else {  
  224.         // otherwise try both subtrees  
  225.         printPathsRecur(node->lchild, path, pathLen);  
  226.         printPathsRecur(node->rchild, path, pathLen);  
  227.     }  
  228. }  
  229.   
  230. void printPaths(treeNode* node) {  
  231.     int path[1000];  
  232.     printPathsRecur(node, path, 0);  
  233. }  
  234. //用到的輔助函式：  
  235. /** 
  236.  * 求二叉樹的深度 
  237.  */  
  238. int getDepth(tNode root) {  
  239.     if (root == NULL)  
  240.         return 0;  
  241.     else  
  242.         return getDepth(root->lchild) > getLeaf(root->rchild) ? 1 +   
  243.   
  244. getDepth(  
  245.                 root->lchild) : 1 + getDepth(root->rchild);  
  246.     //  {  
  247.     //      int depthLchild = 1 + getDepth(root->lchild);  
  248.     //      int depthRchild = 1 + getDepth(root->rchild);  
  249.     //      return depthLchild > depthRchild ? depthLchild:   
  250.   
  251. depthRchild;  
  252.     //  }  
  253. }  
  254. /** 
  255.  * 列印陣列 
  256.  */  
  257. void printArray(int ints[], int len) {  
  258.     int i;  
  259.     for (i = 0; i < len; i++) {  
  260.         printf("%d ", ints[i]);  
  261.     }  
  262.     printf("\n");  
  263. }  

相關文章