【剑指Offer】63、二叉搜索树的第k个结点

题目描述

给定一棵二叉搜索树，请找出其中的第k小的结点。例如， （5，3，7，2，4，6，8） 中，按结点数值大小顺序第三小结点的值为4。

题解一：DFS 借助栈实现

 // 中序非递归
     public static TreeNode KthNode02(TreeNode pRoot, int k) {
         Stack<TreeNode> stack = new Stack<>();
         if(pRoot==null||k<=0){
                 return null;
             }
         int count=0;
             while(pRoot!=null||!stack.isEmpty()){
                 while(pRoot!=null){
                     stack.push(pRoot);
                     pRoot=pRoot.left;
                 }
                 pRoot = stack.pop();
                 count++;
                 if(count==k){
                     return pRoot;
                 }
                 pRoot=pRoot.right;
             }
             return null;
     }

题解二：中序遍历

 //中序遍历二叉搜索树后正好是从小到大的顺序，直接返回第k-1个即可
         private static ArrayList<TreeNode> treeNode=new ArrayList<TreeNode>();
         public static TreeNode KthNode01(TreeNode pRoot, int k) {
             //中序遍历
             InOrder(pRoot);
             if(treeNode.size()<1||k<1||k>treeNode.size()) {
                 return null;
             }
             return treeNode.get(k-1);
         }
         public static void InOrder(TreeNode node) {
             if(node!=null)
             {
                 InOrder(node.left);
                 treeNode.add(node);
                 InOrder(node.right);
             }
         }

题解三：递归

 public static int index = 0;
     public static TreeNode KthNode(TreeNode pRoot, int k) {
         //中序遍历寻找第k个
         if(pRoot != null){
             TreeNode node = KthNode(pRoot.left,k);
             if(node != null) {
                 return node;
             }
             index ++;
             if(index == k) {
                 return pRoot;
             }
             node = KthNode(pRoot.right,k);
             if(node != null) {
                 return node;
             }
         }
         return null;
     }

初始化树：

 public static class TreeNode{
        int val=0;
        TreeNode left=null;
        TreeNode right=null;
        public TreeNode(int val){
            this.val=val;
        }
    }
 private static List<TreeNode> nodeList = null;
    public static TreeNode createBinTree(int[] array) {
        nodeList=new LinkedList<TreeNode>();
        // 将一个数组的值依次转换为TreeNode节点
        for (int nodeIndex = 0; nodeIndex < array.length; nodeIndex++) {
            nodeList.add(new TreeNode(array[nodeIndex]));
        }
        // 对前lastParentIndex-1个父节点按照父节点与孩子节点的数字关系建立二叉树
        for (int parentIndex = 0; parentIndex < array.length / 2 - 1; parentIndex++) {
            // 左孩子
            nodeList.get(parentIndex).left = nodeList
                    .get(parentIndex * 2 + 1);
            // 右孩子
            nodeList.get(parentIndex).right = nodeList
                    .get(parentIndex * 2 + 2);
        }
        // 最后一个父节点:因为最后一个父节点可能没有右孩子，所以单独拿出来处理
        int lastParentIndex = array.length / 2 - 1;
        // 左孩子
        nodeList.get(lastParentIndex).left = nodeList
                .get(lastParentIndex * 2 + 1);
        // 右孩子,如果数组的长度为奇数才建立右孩子
        if (array.length % 2 == 1) {
            nodeList.get(lastParentIndex).right = nodeList
                    .get(lastParentIndex * 2 + 2);
        }
        return nodeList.get(0);
    }

测试：

 public static void main(String[] args) {
        int[] arr= {8,6,10,5,7,9,11};
         int k=2;
         TreeNode root = createBinTree(arr);
         TreeNode node = KthNode02(root, k);
         System.out.println(node.val);
 }
 输出：6