堆

最新推荐文章于 2024-10-05 03:11:36 发布

灵剑山真人

最新推荐文章于 2024-10-05 03:11:36 发布

阅读量54

点赞数

文章标签：队列 cisco dalvik glassfish sdl

本文链接：https://blog.csdn.net/weixin_45850939/article/details/121848042

版权

本文介绍了二叉树的基本性质，包括节点编号规则，并详细讲解了三种二叉树遍历方法：中序、前序和后序遍历。接着，通过实例展示了层次遍历的实现，利用队列进行节点的逐层打印。最后，探讨了堆排序的概念，区分了小顶堆与大顶堆，并提供了完整的堆排序算法实现。

摘要由CSDN通过智能技术生成

一：理论基础

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;
    }