数据结构与算法（三）

最新推荐文章于 2023-11-27 10:41:18 发布

weixin_42410385

最新推荐文章于 2023-11-27 10:41:18 发布

阅读量231

点赞数

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

本文链接：https://blog.csdn.net/weixin_42410385/article/details/108582222

版权

数据结构与算法同时被 2 个专栏收录

4 篇文章 0 订阅

订阅专栏

数据结构

4 篇文章 0 订阅

订阅专栏

第三章树

1. 树和二叉树

1.1 什么是树

在数据结构中，树的定义如下：
树（tree）是n(>=0)个节点的有限集。当n=0时，称为空树。在任意一个非空树种，有如下特点:
1.有且仅有一个特定的称为根的节点。
2.当n>1时，其余节点可分为m(m>0)个互不相交的有限集，每一个集合本身又是一个树，并称为根的子树。

标准树结构如下图：

在上图中，节点1是根节点（root）,节点5、6、7、8、9是树的末端，没有“孩子”，被称为叶子节点（leaf）。图中的虚线部门是根节点1的其中一个子树。

同时, 树的结构从根节点和叶子节点，分为不同的层级。从一个节点的角度来看，它的上下级和同级节点关系如下：

在上图中，节点4的上一级节点，是节点4的父节点（parent）；从节点4衍生来的节点，是节点4的孩子节点（child）;和节点4同级，由同一个父节点衍生出的节点，是节点4的兄弟节点（sibling）。

树的最大层级数，被称为树的高度或深度。所以上图树的高度是4。

1.2 什么是二叉树

二叉树（binary tree）是树的一种特殊形式。二叉顾名思义这种树的每个节点最多有2个孩子节点。注意是最多有两个，也可能是一个，或者没有孩子节点。

二叉树节点的两个孩子节点，一个被称为左孩子（left child）,一个被称为右孩子（right child）。这两个孩子节点的顺序是固定的，就像人的左手就是左手，右手就是右手，不能够颠倒或混淆。
此外，二叉树还有两种特殊形式，一个叫做满二叉树，另一个叫做完全二叉树。

什么是满二叉树呢？

一个二叉树的所有非叶子节点都存在左右孩子，并且所有叶子节点都在同一层级上，那么这个树就是满二叉树。

简单点说，满二叉树的每一个分支都是满的。

什么又是完全二叉树呢？完全二叉树的定义很有意思。
对一个有n个节点的二叉树，按层级顺序编号，则谁又能节点的编号为充1到n。如果这个树所有节点和同样深度的满二叉树的编号为从1到n的节点位置相同，则这个二叉树为完全二叉树。

在上图中，二叉树编号从1到12的12个节点，和前面满二叉树编号从1到12的节点位置完全应对。因此这个树是完全二叉树。

完全二叉树的条件没有满二叉树那么苛刻，满二叉树要求所有分支都是满的，而完全二叉树只需保证最后一个节点之前的节点都是满的即可。
二叉树可以用哪些物理存储结构来表达呢？
1.链式存储结构

链式存储是二叉树最直观的存储方式。上一章讲过链表，链表是一对一的存储方式，每一个链表节点拥有data变量和一个指向下一节的next指针。而二叉树稍微复杂一些，一个节点最多可以指向左右两个孩子节点，所以二叉树的每一个节点包含三部门。

存储数据的data变量
指向左孩子的left指针
指向右孩子的right指针
2.数组

使用数组存储时，会按照层级顺序把二叉树的节点放到数组中对应的位置上。如果某一个节点的左孩子和右孩子空缺，则数组的相应位置也空出来。

假设一个父节点的下标是parent，那么它的左孩子节点下标就是2 x parent + 1；右孩子节点下标就是2 x parent + 2。
反过来，假设一个左孩子节点的下标是leftChild，，那么它的父节点下标就是（leftChild-1）/2。
假如节点4在数组中的下标是3，节点4是节点2的左孩子，节点2的下标可以直接通过计算得出。节点2的下标 = (3-1) / 2 = 1

1.3 二叉树的应用

二叉树包含许多特殊的形式，每一种形式都有自己的作用，但是其最主要的应用还在于进行查找操作和维持相对顺序这两个方面。
1. 查找
这里我们介绍一种特殊的二叉树：二叉查找树(binary search tree),这种二叉树的主要作用就是进行查找操作。
二叉查找树在二叉树的基础上增加了一下几个条件。

如果左子树不为空，则左子树上所有节点的值均小于根节点的值
如果右子树不为空，则右子树上所有节点的值均大于根节点的值
左、右子树也都是二叉查找树
下图就是一个标准的二叉查找树

对于一个节点分布相对均衡的二叉查找树来说，如果节点总数是n，那么搜索节点的时间复杂度就是O(logn),和树的深度是一样的。

2. 维持相对顺序
二叉查找树要求左子树小于父节点，右子树大于父节点，正是这样保证了二叉树的有序性。因此二叉查找树还有另一个名字——二叉排序树(binary sort tree)。
除二叉查找树以外，二叉堆也维持着相对的顺序。不过二叉堆的条件要宽松一些，只要求父节点比它的左右孩子都大，详解请看后面章节。

2.二叉树的遍历

在计算机程序中，遍历本身是一个线性操作。所以遍历同样具有线性结构的数组或者链表，是一件轻易而举的事情。反观二叉树，是典型的非线性数据结构，遍历时需要把非线性关联的节点转化成一个线性的序列，以不同的方式来遍历，遍历出的序列顺序也不同。
从节点之间位置关系的角度来看，二叉树的遍历分为4种。
1. 前序遍历。
2. 中序遍历。
3. 后序遍历。
4. 层序遍历。
从更宏观的角度来看，二叉树的遍历归结为两大类。
1. 深度优先遍历（前序遍历、中序遍历、后序遍历）。
2. 广度优先遍历（层序遍历）。

2.2 深度优先遍历

深度优先和广度优先这两个概念不止局限于二叉树，它们更是一种抽象的算法思想，决定了访问某些复杂数据结构的顺序。在访问树、图或者其他一些复杂数据结构时，这两个概念常常被使用到。
所谓深度优先，顾名思义就是偏向于纵深‘一头扎到底’的访问方式。可能这种这种说法有些抽象，下面就是通过二叉树的前序遍历、中序遍历、后序遍历。
1. 前序遍历
二叉树的前序遍历，输出顺序是根节点、左子树、右子树。

上图就是一个二叉树的前序遍历，每个节点左侧的序号代表该节点的输出顺序，详细步骤如下：

1. 首先输出的是根节点1。
2. 由于根节点1存在左孩子，输出左孩子节点2。
3. 由于节点2也存在左孩子，输出左孩子节点4。
4. 节点4既没有左孩子，也没有右孩子，那么回到节点2，输出节点2的右孩子节点5。
5. 节点5既没有左孩子，也没有右孩子，那么回到节点1，节点1的右孩子节点3。
6. 节点3没有左孩子，但是有右孩子，因此输出节点3的右孩子节点6。

2. 中序遍历
二叉树的中序遍历，输出顺序是左子树、根节点、右子树。

上图就是一个二叉树的中序遍历，每个节点左侧的序号代表该节点的输出顺序，详细步骤如下：
1. 首先访问根节点的左孩子，如果这个左孩子还拥有左孩子，则继续深入访问下去，一直找到不再有左孩子的节点，并输出该节点。显然，第一个没有左孩子的节点是节点4。
2. 依照中序遍历的次序，接下来输出节点4的父节点2。
3. 再输出节点2的右孩子节点5。
4. 以节点2为根的左子树已经输出完毕，这时在输出整个二叉树的根节点1。
5. 由于节点3没有左孩子，所以直接输出根节点1的右孩子节点3。
6. 最后输出节点3的右孩子节点6。

2. 后序遍历
二叉树的后序遍历，输出顺序是左子树、右子树、根节点。

上图就是一个二叉树的后序遍历，每个节点左侧的序号代表该节点的输出顺序。由于二叉树的后序遍历和前序遍历、中序遍历的思想大致相同，这里就不再列举细节了。直接上代码

/**
 * 二叉树
 * @author: fancg
 * @create: 2020-09-15
 */
public class TreeDemo {

    private static int a = 14;

    /**
     * @Description: 二叉树以链表存储
     * @Author: fancg
     * @Date: 2020/9/15
     **/
    private static class TreeNode {
        int data;
        TreeNode leftNode;
        TreeNode rightNode;
        TreeNode(int data){
            this.data = data;
        }
    }

    /**
     * @Description: 根据数组创建二叉树
     * @Author: fancg
     * @Date: 2020/9/15
     **/
    public static TreeNode createBinaryTree(Integer[] array, int b) {
        TreeNode node = null;
        System.out.println("下标："+b+" 值："+array[b]);
        if (array[b] == null) {
            return null;
        } else {
            node = new TreeNode(array[b]);
            if ((b*2+1) <= array.length-1) {
                node.leftNode = createBinaryTree(array,b*2+1);
            }
            if ((b*2+2) <= array.length-1) {
                node.rightNode = createBinaryTree(array,b*2+2);
            }
        }
        return node;
    }

    /**
     * @Description: 前序遍历
     * @Author: fancg
     * @Date: 2020/9/15
     **/
    public static void preOrderTraversal(TreeNode node) {
        if (null == node) {
            return;
        }
        System.out.print(node.data + "  ");
        preOrderTraversal(node.leftNode);
        preOrderTraversal(node.rightNode);
    }

    public static void inOrderTraversal(TreeNode node){
        if (node == null) return;
        inOrderTraversal(node.leftNode);
        System.out.print(node.data + "  ");
        inOrderTraversal(node.rightNode);
    }

    public static void postOrderTraversal(TreeNode node) {
        if (node == null) return;
        postOrderTraversal(node.leftNode);
        postOrderTraversal(node.rightNode);
        System.out.print(node.data + "  ");
    }

    public static void main(String[] args) {
        Integer[] integers = {6, 3, 8, 2, 4, 7, 9, 1, null, null, 5, null, null, null, 10};
        TreeNode binaryTree = createBinaryTree(integers, 0);
        System.out.println("前序遍历");
        preOrderTraversal(binaryTree);
        System.out.println();
        System.out.println("中序遍历");
        inOrderTraversal(binaryTree);
        System.out.println();
        System.out.println("后序遍历");
        postOrderTraversal(binaryTree);
    }
}

二叉树用递归方式来实现前序、中序、后序遍历，是最为自然的方式，因此代码也非常简单。这三种遍历方式的区别，仅仅是输出的执行位置不同；前序遍历的输出在前，中序遍历的输出在中间，后序遍历的输出在最后。代码中值得注意的一点是二叉树的构建。二叉树的构建方法有很多，这里把一个线性的链表转化成非线性的二叉树，链表节点的顺序恰恰是二叉树前序遍历的顺序。链表中的空值，代表二叉树节点的左孩子或者右孩子为空的情况。
绝大多数可以用递归解决的问题，其实都可以用另一种数据结构来解决，这种数据结构就是栈。因为递归和栈都有回溯的特性。直接上代码

  /**
     * @Description: 用栈 前序遍历
     * @Author: fancg
     * @Date: 2020/9/16
     **/
    public static void preOrderTraversalWithStack(TreeNode node) {
        Stack<TreeNode> stack = new Stack<>();
        TreeNode treeNode = node;
        while (treeNode != null || !stack.isEmpty()) {
            while (treeNode != null) {
                System.out.print(treeNode.data + "  ");
                stack.push(treeNode);
                treeNode = treeNode.leftNode;
            }
            if (!stack.isEmpty()) {
                treeNode = stack.pop();
                treeNode = treeNode.rightNode;
            }
        }
    }

    /**
     * @Description: 用栈 中序遍历
     * @Author: fancg
     * @Date: 2020/9/16
     **/
    public static void inOrderTraversalWithStack(TreeNode node) {
        Stack<TreeNode> stack = new Stack<>();
        TreeNode treeNode = node;
        while (treeNode != null || !stack.isEmpty()) {
            while (treeNode != null) {
                stack.push(treeNode);
                treeNode = treeNode.leftNode;
            }
            if (!stack.isEmpty()) {
                treeNode = stack.pop();
                System.out.print(treeNode.data + "  ");
                treeNode = treeNode.rightNode;
            }
        }
    }

    /**
     * @Description: 用栈 后序遍历
     * @Author: fancg
     * @Date: 2020/9/16
     **/
    public static void postOrderTraversalWithStack(TreeNode node) {
        Stack<TreeNode> oneStack = new Stack<>();//先按照中左右遍历插入
        Stack<TreeNode> twoStack = new Stack<>();//根据后序遍历 先中再右后左的顺序插入 倒序输出
        oneStack.push(node);
        while (!oneStack.isEmpty()) {
            node = oneStack.pop();//遍历顺序是先取中 塞入2 下一次取出右 塞入2 最后取出左塞入2
            twoStack.push(node);//先中再右后左
            if (node.leftNode != null) {
                oneStack.push(node.leftNode);
            }
            if (node.rightNode != null) {
                oneStack.push(node.rightNode);
            }
        }
        while (!twoStack.isEmpty()) {
            System.out.print(twoStack.pop().data + "  ");
        }
    }

2.3 广度优先遍历

如果说深度优先遍历是在一个方向上‘一头扎到底’，那么广度优先遍历则恰恰相反，先在各个方向上各走出1步，再在各个方向上走出第2步、第3步…一直到各个方向全部走完。我们可以通过二叉树的层序遍历来看下，层序遍历顾明思议就是二叉树按照从根节点到叶子节点的层次关系，一层一层横向遍历各个节点。

上图就是一个二叉树的层序遍历，每个节点左侧的序号代表该节点的输出顺序。

public static void levelOrderTraversal(TreeNode node) {
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(node);
        while (!queue.isEmpty()) {
            TreeNode treeNode = queue.poll();
            System.out.print(treeNode.data + "  ");
            if (treeNode.leftNode != null) {
                queue.add(treeNode.leftNode);
            }
            if (treeNode.rightNode != null) {
                queue.add(treeNode.rightNode);
            }
        }
    }

3.什么是二叉堆

3.1 什么是二叉堆？

二叉堆本质上是一种完全二叉树，它分为两个类型。
1. 最大堆。
什么是最大堆呢？最大堆的任何一个父节点的值都大于或者等于它左右孩子节点的值。

2. 最小堆。
什么是最小堆呢？最小堆的任何一个父节点的值都小于或等于它左右孩子节点的值。

二叉堆的根节点叫做堆顶。最大堆和最小堆的特点决定了，最大堆的堆顶是整个堆中的最大元素，最小堆的堆顶是整个堆中的最小元素。

3.2 二叉堆的自我调整

对于二叉堆，有如下几种操作。

插入节点。
删除节点。
构建二叉堆。
这几种操作都基于堆的自我调整。所谓堆的自我调整，就是把一个不符合堆性质的完全二叉树，调整成一个堆。下面以最小堆为例，看一看二叉堆是如何进行自我调整的。
1.插入节点
当二叉堆擦插入节点时，插入位置是完全二叉树的最后一个位置。列如插入一个新节点值是0。

这时，新节点的父节点5比0大，显然不符合最小堆的性质。于是让新节点”上浮“和父节点交换位置。

继续用节点0和父节点3作比较，因为0小于3，则让新节点继续”上浮“。
继续比较，最终新节点0”上浮“到了堆顶位置。

2. 删除节点
二叉堆删除节点的过程和插入节点过程正好相反，所删除的是处于堆顶的节点。例如删除最小堆的堆顶节点1。

这时，为了继续维持完全二叉树的结构，我们把堆的最后一个节点10临时补到原本堆顶的位置。
接下来，让暂处堆顶位置的节点10和它的左、右孩子进行比较，如果左右孩子节点中最小的一个（显然是节点2）比节点10小，那么让节点10“下沉”。
继续让节点10和它的左、右孩子中最小的是节点7，由于10大于7，让节点10继续“下沉”。
这样一来，二叉堆重新得到了调整。

3. 构建二叉堆
构建二叉堆，也就是把一个无序的完全二叉树调整为二叉堆，本质就是让所有非叶子节点依次“下沉”。
下面举一个无序完全二叉树的例子，如下图所示。

首先从最后一个非叶子节点开始，也就是从节点10开始。如果节点10大于它左、右孩子节点中最小的一个，则节点10“下沉”。
接下来轮到节点3，如果节点3大于它左、右孩子节点中最小的一个，则节点3“下沉”。
然后轮到节点1，如果节点1大于它左、右孩子中最小的一个，则节点1“下沉”。事实上节点1小于它的左、右孩子，所以不用改变。
接下来轮到节点7，如果节点7大于它左、右孩子节点中最小的一个，则节点7“下沉”。
节点7继续比较，继续下沉。

经过上述几轮比较和下沉操作，最终每一个节点都小于它的左、右孩子节点，一个无序的完全二叉树就被构建成了一个最小堆。

3.3 二叉树的代码实现

二叉堆虽然是一个完全二叉树，但是它的存储方式并不是链式存储，而是顺序存储。换句话说，二叉堆的所有节点都存储在数组中。

/**
 * @author: fancg
 * @create: 2020-09-17
 */
public class AdjustDemo {

    /**
     * @Description: 上浮 调整
     * @Author: fancg
     * @Date: 2020/9/17
     **/
    public static void upAdjust(int[] array) {
        int childIndex = array.length - 1;
        int parentIndex = (childIndex - 1) / 2;
        //temp 保存插入的叶子节点值，用于最后赋值
        int temp = array[childIndex];
        while (childIndex > 0 && temp < array[parentIndex]) {
            //无须真正交换，单向赋值即可
            array[childIndex] = array[parentIndex];
            childIndex = parentIndex;
            parentIndex = (parentIndex-1) / 2;
        }
        array[childIndex] = temp;
    }

    /**
     * @Description: 下沉 调整
     * @Author: fancg 
     * @Date: 2020/9/17
     *
     **/
    public static void downAdjust(int[] array,int parentIndex, int length) {
        //temp 保存父节点值，用于最后的赋值
        int temp = array[parentIndex];
        int childIndex = 2 * parentIndex + 1;
        while (childIndex < length) {
            //如果有右孩子，且右孩子小于左孩子的值，则定位到右孩子
            if (childIndex + 1 < length && array[childIndex+1] < array[childIndex]) {
                childIndex++;
            }
            //如果父节点小于任何一个孩子的值，则直接跳出
            if (temp < array[childIndex]) {
                break;
            }
            //无须真正交换，单向赋值即可
            array[parentIndex] = array[childIndex];
            parentIndex = childIndex;
            childIndex = 2 * childIndex + 1;
        }
        array[parentIndex] = temp;
    }

    public static void buildHeap(int[] array) {
        //从最后一个非叶子节点开始，依次做下沉调整
        for (int i = (array.length - 2)/2; i >= 0; i--) {
            downAdjust(array, i, array.length);
        }
    }

    public static void main(String[] args) {
        int[] array = new int[]{1,3,2,6,5,7,8,9,10,0};
        upAdjust(array);
        System.out.println(Arrays.toString(array));
        
        array = new int[]{7,1,3,10,5,2,8,9,6};
        buildHeap(array);
        System.out.println(Arrays.toString(array));
    }
}

代码中有个优化的点，就是在父节点和孩子节点做连续交换是，并不一定要真的交换，只需要先把交换一方的值存入temp变量，做单向覆盖，循环结束后，再把temp的值存入交换后的最终位置即可。
二叉堆是实现堆排序及优先队列的基础。

4. 什么是优先队列

4.1 优先队列的特点

之前的章节中已经讲过，队列的特点是先进先出。

优先队列不再遵循先入先出的原则，而是分为两种情况。

最大优先队列，无论入队顺序如何，都是当前最大的元素优先出队
最小优先队列，无论入队顺序如何，都是当前最小的元素优先出队

4.2 优先队列的实现

回顾一下二叉堆的特性。
1. 最大堆的堆顶是整个堆中的最大元素。
2. 最小堆的堆顶是整个堆中的最小元素。
因此，可以用最大堆来实现最大优先队列，这样的话，每一次入队操作就是堆的插入操作，每一次队列操作就是删除堆顶节点。
入队操作具体步骤如下。

1. 插入新节点5。

2. 新节点5上浮适合位置。

出队操作具体步骤如下。

1. 让原堆顶节点10出队。

2. 把最后一个节点1替换到堆顶位置。
3. 节点1下沉，节点9成为新堆顶。
二叉堆节点上浮和下沉的时间复杂度都是O(logn),所以优先队列入队和出队的时间复杂度也是O(logn)。

/**
 * @author: fancg
 * @create: 2020-09-17
 */
public class PriorityQueueDemo {
    private int[] array;
    private int size;
    public PriorityQueueDemo(){
        array = new int[32];
    }

    /**
     * @Description: 入队
     * @Author: fancg
     * @Date: 2020/9/17
     * @param key 入队元素
     **/
    public void enQueue(int key) {
        if (size >= array.length) {
            resize();;
        }
        array[size++] = key;
        upAdjust();
    }

    /**
     * @Description: 上浮调整
     * @Author: fancg
     * @Date: 2020/9/17
     **/
    private void upAdjust(){
        int childIndex = size - 1;
        int parentIndex = (childIndex - 1) / 2;
        int temp = array[childIndex];
        while (childIndex > 0 && temp > array[parentIndex]) {
            array[childIndex] = array[parentIndex];
            childIndex = parentIndex;
            parentIndex = parentIndex/2;
        }
        array[childIndex] = temp;
    }

    public Integer deQueue() {
        if (size <= 0) {
            return null;
        }
        int head = array[0];
        array[0] = array[--size];
        downAdjust();
        return head;
    }

    /**
     * @Description: 下沉 调整
     * @Author: fancg
     * @Date: 2020/9/17
     **/
    private void downAdjust() {
        //temp 保存父节点的值，用于最后的赋值
        int parentIndex = 0;
        int temp = array[parentIndex];
        int childIndex = 1;
        while (childIndex < size) {
            if (childIndex + 1 < size && array[childIndex + 1] > array[childIndex]) {
                childIndex++;
            }
            if (temp >= array[childIndex]){
                break;
            }
            array[parentIndex] = array[childIndex];
            parentIndex = childIndex;
            childIndex = 2 * childIndex + 1;
        }
        array[parentIndex] = temp;
    }

    /**
     * @Description: 队列扩容
     * @Author: fancg
     * @Date: 2020/9/17
     **/
    private void resize(){
        //队列容量翻倍
        int newSize = size * 2;
        this.array = Arrays.copyOf(this.array, newSize);
    }

    private void outPut() {
        for (int a : array) {
            System.out.print(a+ " ");
        }
    }

    public static void main(String[] args) {
        PriorityQueueDemo priorityQueueDemo = new PriorityQueueDemo();
        priorityQueueDemo.enQueue(3);
        priorityQueueDemo.enQueue(5);
        priorityQueueDemo.enQueue(10);
        priorityQueueDemo.enQueue(2);
        priorityQueueDemo.enQueue(7);
        priorityQueueDemo.outPut();
        Integer integer = priorityQueueDemo.deQueue();
        System.out.println("输出：" + integer);
        priorityQueueDemo.outPut();
    }
}

上述代码采用数组来存储二叉堆的元素，因此当元素数量超过数组长度是要进行扩容来扩大数组长度。

小结

什么是树
树是n个节点的有限集，有且仅有一个特定的称为根的节点。当n>1时，其余节点可分为m个互不相交的有限集，每一个集合本身又是一个树，并称为根的子树。
什么是二叉树
二叉树是树的一种特殊形式，每一个节点最多有两个孩子节点。二叉树包含完全二叉树和满二叉树两种特殊形式。
二叉树的遍历方式有几种
根据遍历节点之间的关系，可以分为前序遍历、中序遍历、后序遍历、层序遍历这4种方式；从更宏观的角度划分，可以分为深度优先遍历和广度优先遍历两个类。
什么是二叉堆
二叉堆是一种特殊的完全二叉树，分为最大堆和最小堆。
在最大堆中，任何一个父节点的值，都大于或等于它左、右孩子节点的值。
在最小堆中，任何一个父节点的值，都小于或等于它左、右孩子节点的值。
什么是优先队列
优先队列为最大优先队列和最小优先队列。
在最大优先队列中，无论入队顺序如何，当前最大的元素都会优先出队，这是基于最大堆实现的。
在最小优先队列中，无论是入队顺序如何，当前最小的元素都会优先出队，这是基于最小堆实现的