数据结构与算法之树

最新推荐文章于 2021-08-25 18:10:51 发布

Happy_Boy_z

最新推荐文章于 2021-08-25 18:10:51 发布

阅读量208

点赞数

分类专栏：数据结构与算法

本文链接：https://blog.csdn.net/Happy_Boy_z/article/details/104080542

版权

数据结构与算法专栏收录该内容

18 篇文章 0 订阅

订阅专栏

树

二叉树的概念
堆排序
- 堆排序基本介绍
- 堆排序的基本思想是：

二叉树的概念

树有很多种，每个节点最多只能有两个子节点的一种形式称为二叉树。
二叉树的子节点分为左节点和右节点。

在这里插入图片描述

如果该二叉树的所有叶子节点都在最后一层，并且结点总数= 2^n -1 , n 为层数，则我们称为满二叉树。
如果该二叉树的所有叶子节点都在最后一层或者倒数第二层，而且最后一层的叶子节点在左边连续，倒数第二层的叶子节点在右边连续，我们称为完全二叉树。

遍历方式

前序遍历: 先输出父节点，再遍历左子树和右子树
中序遍历: 先遍历左子树，再输出父节点，再遍历右子树
后序遍历: 先遍历左子树，再遍历右子树，最后输出父节点
小结: 看输出父节点的顺序，就确定是前序，中序还是后序，其实主要是使用递归的方式

// 前序遍历
public void preOrder() {
    if (this.root != null) {
        this.root.preOrder();
    } else {
        System.out.println("二叉树为空");
    }
}

// 中序遍历
public void infixOrder() {
    if (this.root != null) {
        this.root.infixOrder();
    } else {
        System.out.println("二叉树为空");
    }
}

// 后序遍历
public void postOrder() {
    if (this.root != null) {
        this.root.postOrder();
    } else {
        System.out.println("二叉树为空");
    }
}

删除节点

// 二叉树的方法
// 删除节点
public void delNode(int no) {
    if (root != null) {
        // 如果只有一个root节点，这里需要立即判断root是不是就是要删除的节点
        if (root.getNo() == no) {
            root = null;
        } else {
            // 递归删除
            root.delNode1(no);
        }
    } else {
        System.out.println("空树，不能删除");
    }
}

节点的方法

public void delNode(int no) {
    if (this.left != null && this.left.no == no) {
        this.left = null;
        return;
    }
    if (this.right != null && this.right.no == no) {
        this.right = null;
        return;
    }
    if (this.left != null) {
        this.left.delNode(no);
    }
    if (this.right!=null) {
        this.right.delNode(no);
    }
}
// 该方法也能将非叶子节点去掉
public void delNode1(int no) {
    if (this.left != null && this.left.no == no) {
        if (this.left.left!=null && this.left.right !=null){
            this.left.left.right = this.left.right;
            this.left =this.left.left;
        } else if (this.left.left != null) {
            this.left = this.left.left;
        } else if (this.left.right != null) {
            this.right = this.left.right;
        } else {
            this.left = null;
        }
        return;
    }
    if (this.right != null && this.right.no == no) {
        if (this.right.left!=null && this.right.right !=null){
            this.right.left.right = this.right.right;
            this.right =this.right.left;
        } else if (this.right.left != null) {
            this.right = this.right.left;
        } else if (this.right.right != null) {
            this.right = this.right.right;
        } else {
            this.right = null;
        }
        return;
    }
    if (this.left != null) {
        this.left.delNode(no);
    }
    if (this.right!=null) {
        this.right.delNode(no);
    }
}

顺序存储二叉树

基本说明
从数据存储来看，数组存储方式和树
的存储方式可以相互转换，即数组可
以转换成树，树也可以转换成数组

顺序存储二叉树的特点:
顺序二叉树通常只考虑完全二叉树
第n个元素的左子节点为 2 * n + 1
第n个元素的右子节点为 2 * n + 2
第n个元素的父节点为 (n-1) / 2
代码实现

package tree;

public class ArrBinaryTreeDemo {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7};
        // 创建一个 ArrBinaryTree
        ArrayBinaryTree arrayBinaryTree = new ArrayBinaryTree(arr);
        arrayBinaryTree.preOrder(0);
    }
}

// 编写一个ArrayBinaryTree 实现顺序存储二叉树遍历
class ArrayBinaryTree {
    private int[] arr;  // 存储数据节点的数组

    public ArrayBinaryTree(int[] arr) {
        this.arr = arr;
    }

    // 编写一个方法，完成顺序存储二叉树的前序遍历

    /**
     * @param index 数组的下标
     */
    public void preOrder(int index) {
        // 如果数组为空，或者 arr.length = 0
        if (arr == null || arr.length == 0) {
            System.out.println("数组为空，不能按照二叉树的前序遍历");
        }
        System.out.println(arr[index]);
        // 向左递归遍历
        if ((index * 2 + 1) < arr.length) {
            preOrder(2 * index + 1);
        }
        // 向右递归遍历
        if ((index * 2 + 2) < arr.length) {
            preOrder(2 * index + 2);
        }

    }
}

线索化二叉树

线索二叉树基本介绍

n个结点的二叉链表中含有n+1 【公式 2n-(n-1)=n+1】个空指针域。利用二叉链表中的空指针域，存放指向该结点在某种遍历次序下的前驱和后继结点的指针（这种附加的指针称为"线索"）
这种加上了线索的二叉链表称为线索链表，相应的二叉树称为线索二叉树(Threaded BinaryTree)。根据线索性质的不同，线索二叉树可分为前序线索二叉树、中序线索二叉树和后序线索二叉树三种
一个结点的前一个结点，称为前驱结点
一个结点的后一个结点，称为后继结点

线索二叉树应用案例

思路分析: 中序遍历的结果：{8, 3, 10, 1, 14, 6}
在这里插入图片描述
说明: 当线索化二叉树后，Node节点的属性 left 和 right ，有如下情况:

left 指向的是左子树，也可能是指向的前驱节点. 比如 ① 节点 left 指向的左子树, 而 ⑩ 节点的 left 指向的就是前驱节点.
right指向的是右子树，也可能是指向后继节点，比如 ① 节点right 指向的是右子树，而⑩ 节点的right 指向的是后继节点.
代码实现

package tree;

public class test {
    public static void main(String[] args) {
        // 先需要创建一颗二叉树
        BinaryTree1 binaryTree = new BinaryTree1();
        // 创建需要的节点
        HeroNode1 root = new HeroNode1(1, "松江");
        HeroNode1 node2 = new HeroNode1(2, "吴用");
        HeroNode1 node3 = new HeroNode1(3, "卢俊义");
        HeroNode1 node4 = new HeroNode1(4, "林冲");
        HeroNode1 node5 = new HeroNode1(5,"关胜");

        root.setLeft(node2);
        root.setRight(node3);
        node3.setLeft(node5);
        node3.setRight(node4);
        binaryTree.setRoot(root);

        // 测试
        System.out.println("前序遍历");
        binaryTree.preOrder();
    }
}

class BinaryTree1{
    private HeroNode1 root;

    public void setRoot(HeroNode1 root) {
        this.root = root;
    }

    public void preOrder(){
        if (this.root != null) {
            this.root.preOrder();
        }else {
            System.out.println("二叉树为空");
        }
    }
}


class HeroNode1 {
    private int id;
    private String name;
    private HeroNode1 left;
    private HeroNode1 right;

    public HeroNode1(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public HeroNode1 getLeft() {
        return left;
    }

    public void setLeft(HeroNode1 left) {
        this.left = left;
    }

    public HeroNode1 getRight() {
        return right;
    }

    public void setRight(HeroNode1 right) {
        this.right = right;
    }

    @Override
    public String toString() {
        return "HeroNode1{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }

    public void preOrder() {
        System.out.println(this);
        if (this.left!=null){
            this.left.preOrder();
        }
        if (this.right!=null) {
            this.right.preOrder();
        }
    }
}

堆排序

堆排序基本介绍

堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好，平均时间复杂度均为O(nlogn)，它也是不稳定排序。
堆是具有以下性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆, 注意 : 没有要求结点的左孩子的值和右孩子的值的大小关系。
每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆

在这里插入图片描述

大顶堆特点：arr[i] >= arr[2i+1] && arr[i] >= arr[2i+2] // i 对应第几个节点，i从0开始编号

堆排序的基本思想是：

将待排序序列构造成一个大顶堆
此时，整个序列的最大值就是堆顶的根节点。
将其与末尾元素进行交换，此时末尾就为最大值。
然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了。
代码实现

package tree;

import java.util.Arrays;

public class Heapdemo {
    public static void main(String[] args) {
        int[] arr = {4,6,8,5,9};
        heapSort(arr);
    }

    public static void heapSort(int arr[]) {
        int temp = 0;
        for (int i = arr.length/2-1; i >=0; i--) {
            adjustHeap(arr,i,arr.length);
        }
        System.out.println("数组" + Arrays.toString(arr));
        for (int j = arr.length-1; j > 0; j--) {
            temp = arr[j];
            arr[j] = arr[0];
            arr[0] = temp;
            System.out.println("数组换之前" + Arrays.toString(arr));
            adjustHeap(arr,0,j);
            System.out.println("数组" + Arrays.toString(arr));
        }
    }

    public static void adjustHeap(int arr[],int i,int length){
        int temp = arr[i];
        for (int k = i*2+1; k < length; k=k*2+1) {
            if (k+1<length && arr[k]<arr[k+1]) {
                k++;
            }
            if (arr[k]>temp) {
                arr[i] = arr[k];
                i=k;
            } else {
                break;
            }
        }
        arr[i] = temp;
    }
}