堆

一： 理论基础

y一棵二叉树共 n 个结点， 按1 —— n编号， 如果一个结点序号为 i 有左孩子， 那么左孩子序号为 2 * i, 如果有右孩子， 右孩子序号为2 * i + 1

 

 

二：三种二叉树遍历

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode() {
    }

    TreeNode(int val) {
        this.val = val;
    }

    TreeNode(int val, TreeNode left, TreeNode right) {
        this.val = val;
        this.left = left;
        this.right = right;
    }
}

public static void main(String[] args) {
      TreeNode node1 = new TreeNode(1);
      TreeNode node2 = new TreeNode(2);
      TreeNode node3 = new TreeNode(3);
      TreeNode node4 = new TreeNode(4);
      TreeNode node5 = new TreeNode(5);
      TreeNode node6 = new TreeNode(6);
      TreeNode node7 = new TreeNode(7);

      node1.left = node2;
      node1.right = node3;
      node2.left = node4;
      node2.right = node5;
      node3.left = node6;
      node3.right = node7;

//      mediumTraver(node1);
        backOrderTraver(node1);
    }


public static void mediumTraver(TreeNode node){
        if (node == null) return;
        if (node.left != null) mediumTraver(node.left);
        System.out.println(node.val);
        if (node.right != null) mediumTraver(node.right);
    }
    public static void inOrderTraver(TreeNode node){
        if (node == null) return;
        System.out.println(node.val);
        if (node.left != null) inOrderTraver(node.left);
        if (node.right != null) inOrderTraver(node.right);
    }
    public static void backOrderTraver(TreeNode node){
        if (node == null) return;
        if (node.left != null) backOrderTraver(node.left);
        if (node.right != null) backOrderTraver(node.right);
        System.out.println(node.val);
    }

 

三：层次遍历

利用一个队列

public static void levelOrderTraver(TreeNode node) {
        Queue<TreeNode> queue = new LinkedList<>();
        if (node != null){
            System.out.println(node.val);
            queue.add(node);
        }

        while (!queue.isEmpty()) {
            TreeNode temp = queue.poll();
            if (temp.left != null) {
                System.out.println(temp.left.val);
                queue.add(temp.left);
            }
            if (temp.right != null) {
                System.out.println(temp.right.val);
                queue.add(temp.right);
            }
        }
    }

 

四：堆排序

堆的分类

小顶堆：结点值小于或等于其左右结点值， 其左右结点值哪个大哪个小关我屁事。

大顶堆：结点值大于或等于其左右结点值， 其左右结点值哪个大哪个小关我屁事。

堆排序

public static void heapSort(int[] arr) {
        int length = arr.length;
        makeHeap(arr);
        while(length >= 1) {
            swap(arr, 1, length);
            length--;
            shiftDown(arr, 1, length);
        }
    }


    //大顶堆
    public static void makeHeap(int[] arr) {
        int length = arr.length;
        for (int i = length / 2; i >= 1; i--) {//因为叶子结点已经是堆，倒数第一个非叶子结点开始
            shiftDown(arr, i, length);
        }
    }

    public static void shiftDown(int[] arr, int current, int length) {
        //current以下标1为基准
        while (current <= length / 2) {//还没向下调整到叶子结点
            int leftIndex = current * 2;
            int rightIndex = current * 2 + 1;
            if (rightIndex <= length && arr[rightIndex - 1] > arr[leftIndex - 1])
                leftIndex = rightIndex;//if have right child and right child > left child
            if (arr[current - 1] >= arr[leftIndex - 1]) return;
            swap(arr, current, leftIndex);
            current = leftIndex;
        }
    }

    public static void swap(int[] arr, int i, int j) {
        //i 和 j以1为下标开始基准
        int temp = arr[i - 1];
        arr[i - 1] = arr[j - 1];
        arr[j - 1] = temp;
    }