【算法和数据结构】漫画算法之树的遍历和二叉堆

一、树的遍历

树的的机构

   A

B     C

深度优先遍历顺序关注的是父节点的被遍历到的顺序。即A

• 前序遍历的顺序：A,B,C
• 中序遍历的顺序：B,A,C
• 后续遍历的顺序：B,C,A

 

 

         A

    B         C

D     E   F     G

 

广度优先遍历（层序遍历）的遍历顺序为：A,B,C,D,E,F,G

 

示例中的树的

1、树的定义类

class TreeNode {
    private TreeNode leftTreeNode;
    private TreeNode rightTreeNode;
    private Integer nodeData;

    public TreeNode getLeftTreeNode() {
        return leftTreeNode;
    }

    public void setLeftTreeNode(TreeNode leftTreeNode) {
        this.leftTreeNode = leftTreeNode;
    }

    public TreeNode getRightTreeNode() {
        return rightTreeNode;
    }

    public void setRightTreeNode(TreeNode rightTreeNode) {
        this.rightTreeNode = rightTreeNode;
    }

    public Integer getNodeData() {
        return nodeData;
    }

    public void setNodeData(Integer nodeData) {
        this.nodeData = nodeData;
    }
}

2、树的遍历算法

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

public class TreeTraverseTest {


    public static void main(String[] args) {
        TreeNode treeNode = createTreeNode();
        //深度优先遍历测试
        //testDepthFirstTraversal(treeNode);
//        testDepthFirstTraversalByStack(treeNode);
        //广度优先遍历测试
        testBreadthFirstTraversal(treeNode);

    }


    /**
     * 递归实现深度优先遍历测试
     *
     * @param treeNode
     */
    public static void testDepthFirstTraversal(TreeNode treeNode) {
        //测试前序遍历，预期输出结果：1,2,3,4,5,6,7,8,9,10,11,12,13,14,15
        preOrderTraversalByRecursive(treeNode);

        //测试中序遍历，预期输出结果：4,3,5,2,7,6,8,1,11,10,12,9,14,13,15
        midOrderTraversal(treeNode);

        //测试后序遍历，预期输出结果：4,5,3,7,8,6,2,11,12,10,14,15,13,9,1
        afterOrderTraversal(treeNode);
    }


    /**
     * 利用栈进行深度优先遍历测试
     *
     * @param treeNode
     */
    public static void testDepthFirstTraversalByStack(TreeNode treeNode) {
        //测试前序遍历，预期输出结果：1,2,3,4,5,6,7,8,9,10,11,12,13,14,15
        preOrderTraversalByStack(treeNode);
        //测试中序遍历，预期输出结果：4,3,5,2,7,6,8,1,11,10,12,9,14,13,15
        midOrderTraversalByStack(treeNode);
        //测试后序遍历，预期输出结果：4,5,3,7,8,6,2,11,12,10,14,15,13,9,1
        afterOrderTraversalByStack(treeNode);
    }

    /**
     * 广度优先遍历测试
     *
     * @param treeNode
     */
    public static void testBreadthFirstTraversal(TreeNode treeNode) {
        //测试广度优先遍历,预期结果:1,2,9,3,6,10,13,4,5,7,8,11,12,14,15
        breadthFirstTraversalByQueue(treeNode);
    }


    public static TreeNode createTreeNode() {
        TreeNode node1 = new TreeNode();
        node1.setNodeData(1);
        TreeNode node2 = new TreeNode();
        node2.setNodeData(2);
        TreeNode node3 = new TreeNode();
        node3.setNodeData(3);
        TreeNode node4 = new TreeNode();
        node4.setNodeData(4);
        TreeNode node5 = new TreeNode();
        node5.setNodeData(5);
        TreeNode node6 = new TreeNode();
        node6.setNodeData(6);
        TreeNode node7 = new TreeNode();
        node7.setNodeData(7);
        TreeNode node8 = new TreeNode();
        node8.setNodeData(8);
        TreeNode node9 = new TreeNode();
        node9.setNodeData(9);
        TreeNode node10 = new TreeNode();
        node10.setNodeData(10);
        TreeNode node11 = new TreeNode();
        node11.setNodeData(11);
        TreeNode node12 = new TreeNode();
        node12.setNodeData(12);
        TreeNode node13 = new TreeNode();
        node13.setNodeData(13);
        TreeNode node14 = new TreeNode();
        node14.setNodeData(14);
        TreeNode node15 = new TreeNode();
        node15.setNodeData(15);

        node1.setLeftTreeNode(node2);
        node1.setRightTreeNode(node9);
        node2.setLeftTreeNode(node3);
        node2.setRightTreeNode(node6);
        node3.setLeftTreeNode(node4);
        node3.setRightTreeNode(node5);
        node6.setLeftTreeNode(node7);
        node6.setRightTreeNode(node8);
        node9.setLeftTreeNode(node10);
        node9.setRightTreeNode(node13);
        node10.setLeftTreeNode(node11);
        node10.setRightTreeNode(node12);
        node13.setLeftTreeNode(node14);
        node13.setRightTreeNode(node15);
        return node1;
    }

    /**
     * 深度优先遍历:前序遍历（递归）
     * 先打印树的根节点
     * 再打印树的左孩子节点
     * 最后打印树的右孩子节点
     *
     * @param treeNode
     */
    public static void preOrderTraversalByRecursive(TreeNode treeNode) {
        if (treeNode == null) {
            return;
        }
        //先打印当前节点的数据
        System.out.println(treeNode.getNodeData());
        //再打印当前节点的左节点的数据
        preOrderTraversalByRecursive(treeNode.getLeftTreeNode());
        //最后打印当前节点的右节点
        preOrderTraversalByRecursive(treeNode.getRightTreeNode());
    }

    /**
     * 深度优先遍历:前序遍历（栈）
     *
     * @param treeNode
     */
    public static void preOrderTraversalByStack(TreeNode treeNode) {
        Stack<TreeNode> stack = new Stack<>();
        Stack<TreeNode> mid = new Stack<>();
        TreeNode node = treeNode;
        while (node != null || !stack.isEmpty()) {
            //迭代访问节点的左孩子，并入栈
            while (node != null) {
                //打印根节点
                System.out.println(node.getNodeData());
                //将根节点入栈
                stack.push(node);
                //获取树的根节点的左节点
                node = node.getLeftTreeNode();
            }

            if (!stack.isEmpty()) {
                node = stack.pop();
                node = node.getRightTreeNode();
            }
        }
    }


    /**
     * 深度优先遍历:中序遍历
     * 先打印树的左孩子节点
     * 再打印树的根节点
     * 最后打印树的右孩子节点
     *
     * @param treeNode
     */
    public static void midOrderTraversal(TreeNode treeNode) {
        if (treeNode == null) {
            return;
        }
        //先打印左节点
        midOrderTraversal(treeNode.getLeftTreeNode());
        //再打印节点自身
        System.out.println(treeNode.getNodeData());
        //最后打印右节点
        midOrderTraversal(treeNode.getRightTreeNode());
    }

    /**
     * 中序遍历（stack）
     *
     * @param treeNode
     */
    public static void midOrderTraversalByStack(TreeNode treeNode) {
        Stack<TreeNode> stack = new Stack<>();
        TreeNode node = treeNode;
        while (node != null || !stack.isEmpty()) {
            while (node != null) {
                stack.push(node);
                node = node.getLeftTreeNode();
            }
            if (!stack.isEmpty()) {
                node = stack.pop();
                System.out.println(node.getNodeData());
                node = node.getRightTreeNode();
            }
        }
    }

    /**
     * 深度优先遍历:后序遍历
     * 先打印树的左孩子节点
     * 再打印树的右孩子节点
     * 最后打印树的根节点
     *
     * @param treeNode
     */
    public static void afterOrderTraversal(TreeNode treeNode) {
        if (treeNode == null) {
            return;
        }
        //先打印左节点
        afterOrderTraversal(treeNode.getLeftTreeNode());
        //再打印右节点
        afterOrderTraversal(treeNode.getRightTreeNode());
        //最后打印节点自身
        System.out.println(treeNode.getNodeData());
    }


    /**
     * 后序遍历（栈）
     * 如果当前弹栈的节点A，为栈里边的下一个节点B的左节点，表示左子树已经遍历完，当前节点为B节点的右孩子节点
     * 如果当前弹栈的节点为C，则表示右子树遍历完，当前节点应该为null,触发下一弹栈，弹出B节点
     *
     *==B
     *A   C
     * @param treeNode
     */
    public static void afterOrderTraversalByStack(TreeNode treeNode) {
        Stack<TreeNode> stack = new Stack<>();
        TreeNode node = treeNode;
        TreeNode temp = null;
        while (node != null || !stack.isEmpty()) {
            while (node != null) {
                stack.push(node);
                node = node.getLeftTreeNode();
            }
            while (!stack.isEmpty()) {
                 node = stack.pop();
                System.out.println(node.getNodeData());
                if(!stack.isEmpty()){
                    temp=stack.peek();
                }
                if(temp!=null&&temp.getLeftTreeNode()==node){
                    node=temp.getRightTreeNode();
                }else{
                    node=null;
                }
                temp=null;
            }
        }

    }

    /**
     * 广度优先遍历
     * @param treeNode
     */
    public static void breadthFirstTraversalByQueue(TreeNode treeNode) {
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(treeNode);
        while (!queue.isEmpty()) {
            TreeNode node = queue.poll();
            System.out.println(node.getNodeData());
            if (node.getLeftTreeNode() != null) {
                queue.add(node.getLeftTreeNode());
            }
            if (node.getRightTreeNode() != null) {
                queue.add(node.getRightTreeNode());
            }
        }
    }

}

3、树基于栈的遍历（前，中，后遍历）

/**
     * 后序遍历
     *
     * @param node
     */
    public static void traverseAfterByStack(Node node) {

        Stack<Node> stack = new Stack<>();
        Node node1 = node;

        while (node1 != null || !stack.isEmpty()) {

            while (node1 != null) {
                stack.add(node1);
                node1 = node1.left;
            }

            Node node2 = stack.peek();
            //读出节点是父亲的左孩子节点
            if (node2.parent != null && node2.parent.left == node2) {
                System.out.println(node2.v);
                stack.pop();
                node1 = stack.peek() != null ? stack.peek().right : null;

            } else {
                System.out.println(node2.v);
                stack.pop();
                node1 = null;
            }

        }

    }


    /**
     * 中序遍历
     *
     * @param node
     */
    public static void traverseMindByStack(Node node) {
        Stack<Node> stack = new Stack<>();
        Node node1 = node;

        while (node1 != null || !stack.isEmpty()) {

            while (node1 != null) {
                stack.add(node1);
                node1 = node1.left;
            }


            Node node2 = stack.pop();
            System.out.println(node2.v);
            node1 = node2.right;
        }
    }


    /**
     * 前序遍历基于栈
     *
     * @param node
     */
    public static void traversBeforeByStack(Node node) {
        Stack<Node> stack = new Stack<>();

        Node node1 = node;
        //先打印前序节点,并将节点压入栈中。当节点的left孩子为空时,退出压栈动作
        while (node1 != null || !stack.isEmpty()) {

            //将节点压入栈中
            while (node1 != null) {
                System.out.println(node1.v);
                stack.push(node1);
                node1 = node1.left;
            }


            //从栈中读取数据
            Node node2 = stack.pop();
            node1 = node2.right;

        }

    }

4、二叉树的左视图 和 右视图

 /**
     * 构建一棵树
     *
     * @return
     */
    public static Node buildNode() {
        Node node = new Node("A");
        Node node1 = new Node("B");
        Node node2 = new Node("C");
        Node node3 = new Node("D");
        Node node4 = new Node("E");
        Node node5 = new Node("F");
        Node node6 = new Node("G");
        Node node7 = new Node("H");

        node.left = node1;
        node.right = node2;
        node1.parent = node;
        node2.parent = node;

        node1.left = node3;
        node1.right = node4;
        node3.parent = node1;
        node4.parent = node1;

        node2.left = node5;
        node2.right = node6;
        node5.parent = node2;
        node6.parent = node2;

        node3.left = node7;
        node7.parent = node3;

        return node;
    }


    /**
     * 二叉树的左视图：相等于层序遍历，每一层的第一个节点。
     * 基于两个队列，进行交换，来保存每一层树的节点，从而能读到每层的第一个节点，就是左视图的结果
     *
     * @param node
     * @return
     */
    public static List<String> leftView(Node node) {

        Queue<Node> nodeQueue1 = new LinkedList<>();
        Queue<Node> nodeQueue2 = new LinkedList<>();
        List<String> result = new ArrayList<>();

        nodeQueue1.add(node);
        boolean isFirst = true;
        while (nodeQueue1.size() != 0) {
            Node node1 = nodeQueue1.poll();

            if (isFirst) {
                result.add(node1.v);
                isFirst = false;
            }

            if (node1.left != null) {
                nodeQueue2.add(node1.left);
            }

            if (node1.right != null) {
                nodeQueue2.add(node1.right);
            }



            if (nodeQueue1.isEmpty()) {
                isFirst=true;
                Queue<Node> tmp = nodeQueue1;
                nodeQueue1 = nodeQueue2;
                nodeQueue2 = tmp;
            }
        }
        return result;

    }

    /**
     * 二叉树的右视图：相等于层序遍历，每一层的最后一个节点。
     * 基于两个队列，进行交换，来保存每一层树的节点，从而能读到每层的最后一个节点，就是右视图的结果
     *
     * @param node
     * @return
     */
    public static List<String> rightView(Node node) {

        Queue<Node> nodeQueue1 = new LinkedList<>();
        Queue<Node> nodeQueue2 = new LinkedList<>();
        List<String> result = new ArrayList<>();

        nodeQueue1.add(node);


        while (nodeQueue1.size() != 0) {
            Node node1 = nodeQueue1.poll();

            if (node1.left != null) {
                nodeQueue2.add(node1.left);
            }

            if (node1.right != null) {
                nodeQueue2.add(node1.right);
            }

            if (nodeQueue1.isEmpty()) {
                result.add(node1.v);
                Queue<Node> tmp = nodeQueue1;
                nodeQueue1 = nodeQueue2;
                nodeQueue2 = tmp;
            }
        }
        return result;

    }

5、二叉树的俯视图 和 仰视视图

/**
     * 树的仰视图
     * @param node
     * @return
     */
    public static void upView(Node node,List<String> result){
        if(node==null){
            return ;
        }
        if(node.left==null && node.right==null){
            result.add(node.v);
            return ;
        }
        upView(node.left,result);
        upView(node.right,result);
    }


    /**
     * 树的俯视图
     * @param node
     * @return
     */
    public static List<String> topView(Node node) {

        List<String> result = new ArrayList<>();

        if (node == null) {
            return result;
        }
        //添加根节点
        result.add(node.v);

        Node left = node.left;
        Node right = node.right;

        while (left != null || right != null) {

            if (left != null) {
                result.add(left.v);
                left = left.left;
            }

            if (right != null) {
                result.add(right.v);
                right = right.right;
            }
        }

        return result;

    }

 

二、二叉堆

1、二叉堆的向上调整，向下调整，构建二叉堆

package com.spring.test.service.algorithm.tree;

import java.util.Arrays;

/**
 * 二叉堆的公式：
 * 已知父节点下标,求子节点小标
 * leftChildIndex=parentIndex*2+1
 * rightChildIndex=parentIndex*2+2
 *
 * 已知子节点下标(不分左右),求父亲节点下标
 * parentIndex=(childIndex-1)/2
 *
 *
 * 本示例演练的为最小堆
 *
 * @author shangxiaofei
 * @date 8:09 PM 2019/6/2
 */
public class BinaryTreeHeap {

    /**
     * 节点上浮
     *
     * @param array      待调整的二叉堆
     * @param treeLength 二叉堆的大小
     */
    public static void upAdjust(int[] array, int treeLength) {
        //最后一个子节点的下标
        int childIndex = treeLength - 1;
        //计算它的父节点的下标
        int parentIndex = (childIndex - 1) / 2;
        //赋值需要上浮的节点的值
        int temp = array[childIndex];
        //开始上浮，孩子节点为0,代表已经到了堆顶
        while (childIndex > 0 && array[parentIndex] > temp) {
            //父节点和子节点进行交换
            array[childIndex] = array[parentIndex];
            //赋值新的孩子节点
            childIndex = parentIndex;
            //计算新的父节点
            parentIndex = (childIndex - 1) / 2;
        }
        //将上浮节点赋值给新的孩子节点
        array[childIndex] = temp;
    }

    /**
     * 节点下沉
     *
     * @param array       待调整的二叉堆
     * @param parentIndex 要下沉的父节点的下标
     * @param treeLength  二叉堆的大小
     */
    public static void downAdjust(int[] array, int parentIndex, int treeLength) {
        //先求出该父节点的左孩子节点的下标
        int childIndex = parentIndex * 2 + 1;
        //待调整的数
        int temp = array[parentIndex];
        //开始下沉,当孩子节点的下标小于树的长度时,表示还未到树的最后一个节点
        while (childIndex < treeLength) {
            if (childIndex + 1 < treeLength && array[childIndex] > array[childIndex + 1]) {
                //如果存在右孩子节点，且左孩子节点大于右孩子节点，则待下沉节点应该与右孩子节点进行比较
                childIndex++;
            }
            //如果待调整父节点,大于最小孩子节点,则进行位置替换
            if (temp > array[childIndex]) {
                array[parentIndex] = array[childIndex];
                //更新当前孩子节点为parentIndex
                parentIndex = childIndex;
                //计算最新的parentIndex节点的最新左孩子节点
                childIndex = parentIndex * 2 + 1;
                //继续比较孩子节点
                continue;
            }
            //下沉节点已经找到合适的位置，这个位置均小于左孩子和右孩子
            break;
        }
        array[parentIndex] = temp;
    }

    /**
     * 构建二叉堆
     *
     * @param array 要调整的普通数组，元素是满的
     */
    public static void bulidBinaryHeap(int[] array) {
        for (int i = (array.length - 2) / 2; i >= 0; i--) {
            downAdjust(array, i, array.length);
        }
    }


    public static void main(String[] args) {
        int[] heap = new int[]{7, 9, 4, 5, 8, 9, 10};
        //构建二叉堆
        bulidBinaryHeap(heap);
        System.out.println("待调整后的二叉堆为:" + Arrays.toString(heap));
        //待调整后的二叉堆为:[4, 5, 7, 9, 8, 9, 10]

        int[] heap1 = new int[]{4, 5, 7, 9, 8, 9, 10, 0};
        //向上调整
        upAdjust(heap1, heap1.length);
        System.out.println("向上调整后的堆为:" + Arrays.toString(heap1));
        //向上调整后的堆为:[0, 4, 7, 5, 8, 9, 10, 9]

        int[] heap2 = new int[]{10, 4, 5, 7, 9, 8};
        downAdjust(heap2, 0, heap2.length);
        System.out.println("向下调整后的堆为:" + Arrays.toString(heap2));
        //向下调整后的堆为:[4, 7, 5, 10, 9, 8]

    }
}

2、二叉堆数据结构

package com.sxf.study.interview.tree;

import java.util.PriorityQueue;

/**
 * @date 3:49 PM 2020/2/1
 */
public class BinaryHeapTest {

    /**
     * 二叉堆的公式
     * 已知父亲节点的下标，求子节点下标
     * leftIndex=2*parentIndex+1
     * rightIndex=2*parentIndex+2
     *
     * 已知孩子节点的下标，求父亲节点的下标
     * parentIndex=(childIndex-1)/2
     *
     * 加入一个节点：
     * 加入数组的最后一个元素，向上调整（已知孩子节点坐标，和父亲节点比较）
     *
     * 取出一个节点：
     * 取最顶节点，返回结果。将最尾部的元素放置在数组的头部，向下调整。（已知父亲节点坐标，和孩子元素进行对比）
     *
     * @param args
     */
    public static void main(String[] args) {

        PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();
        priorityQueue.add(1);
        priorityQueue.poll();

    }


}


/**
 * ==========1
 * ======2     3
 * ===4    5 6   7
 */
class BinaryHead {

    private Object[] node = new Object[10];

    private int nodeSize;

    /**
     * 添加一个节点
     *
     * @param data
     */
    public void push(String data) {
        //step1:元素为空，则抛出异常
        if (data == null) {
            throw new IllegalArgumentException("入参异常");
        }
        //step2:如果为第一个元素，则无需排序
        if (nodeSize == 0) {
            node[0] = data;
            nodeSize++;
            return;
        }
        //判断元素的个数>=数组的长度，则需要扩容（本示例不扩容，忽略默认数组长度够用）

        //step3:开始向上调整
        //当前数组最后一个空的下标位置
        int childIndex = nodeSize;
        nodeSize++;
        siftUp(childIndex,data);
    }

    /**
     * 向上调整
     * @param index
     * @param data
     */
    private void siftUp(int index, Object data) {
        Comparable dataComparable = (Comparable) data;
        //获取该位置的孩子节点的父亲节点的位置
        while (index > 0) {
            int parentIndex = (index - 1) / 2;
            Comparable parentData = (Comparable) node[parentIndex];
            //孩子节点大于等于父亲节点，则无需进行调整
            if (dataComparable.compareTo(parentData) >= 0) {
                break;
            }
            //孩子节点的数据小于父亲节点=>父亲节点和孩子节点进行位置替换,
            node[index]=parentData;
            index=parentIndex;
        }
        node[index] = dataComparable;
    }


    /**
     * 弹出1个节点
     *
     * @return
     */
    public String poll() {
        //step1:当个数为0,返回null
        if(nodeSize==0){
            return null;
        }
        //step2:取出最小的元素
        String result= (String) node[0];
        //step3:元素个数减少1个,并得到最后一个元素，将最后一个元素的位置设置为null
        nodeSize--;
        int lastNodeIndex=nodeSize;
        Object lastNode=node[lastNodeIndex];
        node[lastNodeIndex]=null;
        //step4:向下调整
        siftDown(0,lastNode);
        return result;
    }

    /**
     * 向下调整
     * @param index
     * @param data
     */
    private void siftDown(int index,Object data){
        Comparable dataComparable= (Comparable) data;
        //获取最后1个没有孩子下标的元素，最后比较的临界值
        int lastParentIndex=nodeSize/2;
        while (index<lastParentIndex){
            //左孩子节点的位置
            int leftChildIndex=index*2+1;
            //右孩子节点的位置
            int rightChildIndex=leftChildIndex+1;

            //待调整元素和其两个孩子中最小的元素进行比较（最起码有左孩子，但不一定有右孩子）
            int comparableChildIndex=leftChildIndex;
            Comparable comparableChildData= (Comparable) node[leftChildIndex];

            //如果存在右孩子，则在两个孩子中找到最小的那个元素进行比较
            if(rightChildIndex<nodeSize&&comparableChildData.compareTo(node[rightChildIndex])>0){
                //左孩子大于右孩子，则和右孩子进行比较
                comparableChildIndex=rightChildIndex;
                comparableChildData= (Comparable) node[comparableChildIndex];
            }

            if(dataComparable.compareTo(comparableChildData)<=0){
                //如果待调整元素小于其孩子节点
                break;
            }

            //将小的元素上浮
            node[index]=comparableChildData;
            //待比较的位置下沉
            index=comparableChildIndex;
        }
        node[index]=dataComparable;
    }
}

3、将一个数组（数组的每一个下标都存在数据）调整为二叉堆

/**
     * 构建最小堆
     * 将一个普通数组构建成二叉堆
     * 法则：从一个数组中的最后一个父亲节点开始，对每一个父亲节点一次做下沉操作，调整到数组的头节点
     * @param objects
     */
    public static void buildBinaryHeap(Object[] objects){
        int length=objects.length;
        int lastIndex=length-1;
        //最后一个父亲节点
        int lastParentIndex=(lastIndex-1)/2;
        //从最后1个父亲节点依次向下调整，直到调整至数组的头节点，调整完毕，二叉堆就形成了
        for(int i=lastIndex;i>=0;i--){
            siftDownArray(objects,i,length);
        }
    }

    public static void siftDownArray(Object[] objects,int lastParentIndex,int dataSize){
        //要调整的数据
        Comparable comparableData= (Comparable) objects[lastParentIndex];
        //要调整的元素下标小于数组长度
        while (lastParentIndex<dataSize){
            int childIndex=lastParentIndex*2+1;
            Comparable comparableChildData= (Comparable) objects[childIndex];
            int rightChildIndex=childIndex+1;
            if(rightChildIndex<dataSize && comparableChildData.compareTo(objects[rightChildIndex])>0){
                //左右孩子节点比较，找出最小的的子节点
                childIndex=rightChildIndex;
                comparableChildData= (Comparable) objects[childIndex];
            }

            //如果比较的节点小于或等于孩子节点，则终止调整
            if(comparableData.compareTo(comparableChildData)<=0){
                break;
            }
            objects[lastParentIndex]=comparableChildData;
            lastParentIndex=childIndex;
        }
        objects[lastParentIndex]=comparableData;
    }