关于二叉查找树的一些题目

转载自：http://blog.csdn.net/beiyeqingteng/article/category/859395

1. 找出二叉查找树中第n大的值

问题：

给一个二叉查找树（BST），找出第 k 大的值。比如：

该图中，第3大的值是10.

分析：

我们可以通过类似中序遍历的方法把BST从大到小排序，然后，就可以得到第 k 大的值了。代码如下

public class NthLeaf {        static int k = 0;    // get the nth leaf by using preorder traversal    public void getNthleve(Node root, int n) {        if (root == null)            return;         if (root.rightChild != null)            getNthleve(root.rightChild, n);         k++;        if (k == n) {            System.out.println(root.toString());        }           else            getNthleve(root.leftChild, n);     }           public static void main(String[] args) {         Node a = new Node(8);         Node b = new Node(3);         Node c = new Node(10);         Node d = new Node(14);         Node e = new Node(13);         Node f = new Node(1);         Node g = new Node(6);         Node h = new Node(4);         Node i = new Node(7);             a.leftChild = b;         a.rightChild = c;         c.rightChild = d;         d.leftChild = e;         b.leftChild = f;         b.rightChild = g;         g.leftChild = h;         g.rightChild = i;         System.out.println("begin!");             new NthLeaf().getNthleve(a, 3);        }   }class Node {    Node leftChild = null;    Node rightChild = null;    int value;    Node(int value) {        this.value = value;    }    @Override    public String toString() {        return value + "";    }}

2.问题：
给定一个二叉树，从左到右，找出第 k 个叶子节点。

比如

图中二叉树的第 3 个叶子节点（从左到右）是 11.

分析：

因为顺序是从左往右数，所以，对于一个节点下的两个叶子节点来讲（比如 6 下面有两个叶子节点 5 和 11），我们要确保先遍历最左边一个，然后再遍历右边一个。这样，其实，在中序遍历，前序遍历和后序遍历中，都能保证左边叶子节点比右边叶子节点先被遍历。我们只需要对每一个遍历的节点进行检查，看是否是叶子节点，是，则把个数+1. 代码如下：

public class NthLeaf {static int k = 0;// get the nth leaf by using preorder traversalpublic void getNthleve(Node root, int n) {if (root == null) return;if (root.rightChild == null && root.leftChild == null) {k++;if (k == n) {System.out.print(root.toString());}}getNthleve(root.leftChild, n);getNthleve(root.rightChild, n);}public static void main(String[] args) { Node a = new Node(2);     Node b = new Node(7);     Node c = new Node(5);     Node d = new Node(2);     Node e = new Node(6);     Node f = new Node(9);     Node g = new Node(5);     Node h = new Node(11);     Node i = new Node(4);          a.leftChild = b;     a.rightChild = c;     b.leftChild = d;     b.rightChild = e;     c.rightChild = f;     e.leftChild = g;     e.rightChild = h;     f.rightChild = i;          new NthLeaf().getNthleve(a, 3);}}class Node {    Node leftChild = null;    Node rightChild = null;    int value;    Node(int value) {        this.value = value;    }    @Override    public String toString() {        return value + "";    }}

3.问题：
给你一个complete 二叉树，逆时针打印所有边缘节点， 比如：

那么，逆时针打印边缘节点后，输出：1 , 3， 5， 9， 8,  6 .

分析：

如果想写一个方法实现这个要求是很难的，但是，我们可以考虑分步实现。

第一步：打印左边的边缘节点；

第二步：打印底部所有节点；

第三步：打印右边所有边缘节点。

public static void printLeft(Node root) {if (root.leftChild != null || root.rightChild != null) {print(root);printLeft(root.leftChild);}}public static void printButtom(Node root) { if (root != null) {if (root.leftChild == null && root.rightChild == null) {print(root);}printButtom(root.leftChild);printButtom(root.rightChild);}}public static void printRight(Node root, Node node) {if (root.leftChild != null || root.rightChild != null) {printRight(root.rightChild, node);// do not print the root againif (root != node) {print(root);}}}

4. check whether two binary trees are identical

Question:
Given two binary trees, check whether they are identical or not.
Analyze:
we first compare the roots of these two trees, if they are the same, we continue to compare the root of their left and right subtrees.
Code:

boolean sameTree(Node a, Node b) {   // 1. both empty -> true   if (a == null && b == null) return(true);  // 2. both non-empty -> compare them   else if (a!=null && b!=null) {     return (a.data == b.data &&       sameTree(a.leftChild, b.leftChild) &&       sameTree(a.rightChild, b.rightChild)     );   }   // 3. one empty, one not -> false   else return false; } 

5.检查一个数组是否可能是一棵二叉查询树后序遍历的结果

问题：

给一个数组，检查它是否可能是一棵二叉查询树后序遍历的结果。换句话说，是否存在一棵二叉查询树，对它进行后序遍历后，得到的数组和给定的数组完全一样。

比如，对上面这个二叉查询树后序遍历后，得到的数组是：[1, 4, 7, 6, 3, 13, 14, 10, 8]。

思路：

因为二叉树后序遍历的时候，先左后右然后中间。所以，数组的最后一个一定是整个二叉查询树的根（比如 8），而且，数组前一部分比数组最后一个值（也就是二叉查询树的根）小，因为它们是根的左子树部分。数组剩余部分，是根的右子树部分。而且，在剩余部分里，所有的值都必须比根要大。这样，我们可以把原来的数组分成两个部分，然后每一个部分可以进行递归判断，直到数组的长度小于等于2。（因为当长度小于等于2时，什么样的情况都是可以的）。

我们先把给定的数组分成两个部分，即我们需要先找到数组的分界点。代码如下：

[java] view plaincopy

1. /** 
2.      *  
3.      * @param array  the input array     
4.      * @param begin  the starting index of the array 
5.      * @param end    the ending index of the array 
6.      * @return   the turning point of the array, where the left part of turning point is smaller than array[end], the right  
7.      *           part of the turning point is larger than array[end]. 
8.      */  
9.     public int turningPoint(int[] array, int begin, int end) {  
10.           
11.         int tp = -1;  
12.         for (int i = begin; i < end; i++) {  
13.             if (array[i] > array[end]) {  
14.                 tp = i;  
15.                 break;  
16.             }  
17.         }  
18.           
19.         return tp;  
20.     }  

找到分界点后，我们还要判断从分界点开始，到数组末，是否所有的值都比数组的最后一个值（也就是根）大，否则，这样的数组不是一个二叉查询树的后序遍历。代码如下：

[java] view plaincopy

1. //check whether all the elements from strat are larger than array[end]  
2.     public boolean checkValid(int[] array, int start, int end) {  
3.         for (int i = start; i < end; i++) {  
4.             if (array[i] < array[end]) return false;  
5.         }  
6.         return true;  
7.     }  

有了上面两个方法，我们就可以把递归写出来了，代码如下：

[java] view plaincopy

1. // the main method to check whether the array is identical to a BST's post order array  
2.     public boolean isPostOrder(int[] array, int begin, int end) {  
3.         // the exit  
4.         if ((end - begin + 1) <= 2) return true;  
5.         //get the turning point  
6.         int turningPoint = turningPoint(array, begin, end);  
7.         boolean result = checkValid(array, turningPoint, end);  //check whether the right part of the array is valid  
8.         if (result == false) {  
9.             return false;  
10.         }  
11.         // recursion  
12.         return isPostOrder(array, begin, turningPoint - 1) && isPostOrder(array, turningPoint, end - 1);  
13.     }