二叉树

最新推荐文章于 2022-07-09 13:48:50 发布
最新推荐文章于 2022-07-09 13:48:50 发布
阅读量146 收藏
点赞数 1
分类专栏： 数据结构与算法分析 文章标签： 二叉树 数据结构 算法 队列 stack
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-NC-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dreaming_coder/article/details/115365859
版权

1. 二叉树的概念

二叉树是另一种树形结构，其特点是每个结点至多只有两棵子树，并且二叉树的子树有左右之分，其次序不能任意颠倒.

二叉树使用递归的方式定义，二叉树是 n n n ( n ≥ 0 ) (n\ge 0) (n≥0) 个结点的有限集合：

  • 或者为空二叉树，即 n = 0 n=0 n=0
  • 或者由一个根节点和两个互不相交的被称为根的左子树和右子树组成. 左子树和右子树又分别是一棵二叉树.

二叉树是有序树，若将其左、右子树颠倒，则构成另一棵不同的二叉树.

二叉树可以使用顺序存储结构和链式存储结构，一般主要使用链式存储，其结点定义为：

public class Node<E> {
    E data;
    Node<E> lchild;
    Node<E> rchild;

    public Node(E data) {
        this(data, null, null);
    }

    public Node(E data, Node lchild, Node rchild) {
        this.data = data;
        this.lchild = lchild;
        this.rchild = rchild;
    }

    @Override
    public String toString() {
        return new StringJoiner(", ", Node.class.getSimpleName() + "[", "]")
            .add("data=" + data)
            .toString();
    }
}

2. 完全二叉树的性质

对完全二叉树从上到下、从左到右的顺序依次编号 1 , 2 , ⋯   , n 1,2,\cdots,n 1,2,⋯,n，则有以下关系：

  1. 当 i > 1 i>1 i>1 时，结点 i i i 的双亲编号为 ⌊ i 2 ⌋ \displaystyle\lfloor \frac{i}{2}\rfloor ⌊2i​⌋，即当 i i i 为偶数时，其双亲的编号为 i 2 \displaystyle\frac{i}{2} 2i​，它是双亲的左孩子，当 i i i 为奇数时其双亲的编号为 i − 1 2 \displaystyle\frac{i-1}{2} 2i−1​，它是双亲的右孩子
  2. 当 2 i ≤ n 2i\le n 2i≤n 时，结点 i i i 的左孩子编号为 2 i 2i 2i，否则无左孩子
  3. 当 2 i + 1 ≤ n 2i+1\le n 2i+1≤n 时，结点 i i i 的右孩子编号为 2 i + 1 2i+1 2i+1，否则无右孩子
  4. 结点 i i i 所在层次（深度）为 ⌊ log ⁡ 2 i ⌋ + 1 \displaystyle\lfloor \log_2i\rfloor+1 ⌊log2​i⌋+1

所以在使用顺序存储结构时，下标最好从 1 1 1 开始，这样和上面的规律能匹配.

3. 二叉树的遍历

3.1 辅助数据结构

3.1.1 栈

import java.util.StringJoiner;

@SuppressWarnings("unchecked")
public class Stack<E> {
    private Object[] data;
    private final int length;
    private int top;

    public Stack() {
        this(10);
    }

    public Stack(int length) {
        this.top = -1;
        this.length = length;
        this.data = new Object[length];
    }

    public void clear() {
        this.top = -1;
    }

    public boolean isEmpty() {
        return this.top == -1;
    }

    public boolean isFull() {
        return this.top == this.length - 1;
    }

    public boolean push(E e) {
        if (isFull()) {
            return false;
        }
        this.data[++this.top] = e;
        return true;
    }

    public E pop() {
        if (isEmpty()) {
            return null;
        }
        E e = (E) this.data[this.top];
        this.top--;
        return e;
    }

    public E peek() {
        if (isEmpty()) {
            return null;
        }
        return (E) this.data[this.top];
    }

    @Override
    public String toString() {
        StringJoiner s = new StringJoiner("\n\t", Stack.class.getSimpleName() + "{\n\t", "\n}");
        int point = top;
        while (point >= 0) {
            s.add("[" + point + "] = " + data[point--]);
        }

        return s.toString();
    }

}

3.1.2 队列

import java.util.StringJoiner;

@SuppressWarnings("unchecked")
public class Queue<E> {

    private Node front;
    private Node rear;

    private class Node {
        Object data;
        Node next;

        public Node(Object data) {
            this(data, null);
        }

        public Node(Object data, Node next) {
            this.data = data;
            this.next = next;
        }

        @Override
        public String toString() {
            return new StringJoiner(", ", Node.class.getSimpleName() + "[", "]")
                    .add("data=" + data)
                    .toString();
        }
    }

    public Queue() {
        this("head");
    }

    public Queue(String name) {
        this.front = new Node(name);
        this.rear = this.front;
    }

    public void clear() {
        front.next = null;
        rear = front;
    }

    public boolean isEmpty() {
        return front == rear;
    }

    public void offer(E e) {
        Node node = new Node(e);
        rear.next = node;
        rear = node;
    }

    public E poll() {
        if (isEmpty()) {
            return null;
        }
        Node node = front.next;

        if (rear == node) {
            rear = front;
            front.next = null;
        } else {
            front.next = node.next;
        }
        return (E) node.data;
    }

    public E peek() {
        if (isEmpty()) {
            return null;
        }
        return (E) front.next;
    }


    @Override
    public String toString() {
        StringJoiner s = new StringJoiner(",\n\t", this.front.data.toString() + "{\n\t", "\n}");
        Node node = front.next;
        while (node != null) {
            s.add(node.toString());
            node = node.next;
        }
        return s.toString();
    }

}

3.2 先序遍历

先序遍历的过程是：

  1. 访问根节点
  2. 先序遍历左子树
  3. 先序遍历右子树

最直接的代码实现就是递归的方式：

public void preOrder(Node<T> root) {
    if (root != null) {
        root.print();
        preOrder(root.lchild);
        preOrder(root.rchild);
    }
}

其迭代算法如下所示：

public void preOrder(Node<T> root) {
    if (root == null) {
        return;
    }
    Stack<Node<T>> stack = new Stack<>();
    Node<T> r = root;
    while (r != null || !stack.isEmpty()) {
        if (r != null) {
            visit(r);
            stack.push(r);
            r = r.lchild;
        } else {
            r = stack.pop();
            r = r.rchild;
        }
    }
}

3.3 中序遍历

中序遍历的过程是：

  1. 中序遍历左子树
  2. 访问根节点
  3. 中序遍历右子树

最直接的代码实现就是递归的方式：

public void inOrder(Node<T> root) {
    if (root != null) {
        inOrder(root.lchild);
        visit(root);
        inOrder(root.rchild);
    }
}

其迭代算法如下所示：

public void inOrder(Node<T> root) {
    if (root == null) {
        return;
    }
    Node<T> node = root;
    Stack<Node<T>> stack = new Stack<>(20);
    while (node != null || !stack.isEmpty()) {
        while (node != null) {
            stack.push(node);
            node = node.lchild;
        }
        node = stack.pop();
        visit(node);
        node = node.rchild;
    }
}

3.4 后序遍历

后序遍历的过程是：

  1. 后序遍历左子树
  2. 后序遍历右子树
  3. 访问根节点

最直接的代码实现就是递归的方式：

public void postOrder(Node<T> root){
    if (root!=null){
        postOrder(root.lchild);
        postOrder(root.rchild);
        visit(root);
    }
}

其迭代算法如下所示：

public void postOrder(Node<T> root) {
    if (root == null) {
        return;
    }
    Node<T> pre = null;
    Node<T> node = root;
    Stack<Node<T>> stack = new Stack<>(20);
    while (node != null || !stack.isEmpty()) {
        while (node != null) { // 后序遍历仍然要先遍历左子树，所以如果有左子树，则当前结点先入栈，等待访问
            stack.push(node);
            node = node.lchild;
        }
        node = stack.peek(); // 不能直接出栈，因为如果右子树存在且没被遍历，还要先遍历右子树
        if (node.rchild != null && node.rchild != pre) { // 如果右子树存在且没有被遍历过时
            node = node.rchild; // 先遍历右子树，也需要经过一开始的操作
        } else {
            node = stack.pop(); // 确认确实该遍历它了才出栈
            visit(node);
            pre = node; // 遍历之后对于下一个结点它就是前结点，记录一下
            node = null; // 后序遍历出站的结点是子树的根结点，其左右子树已经遍历完成，所以应该重置为 null，避免重复遍历
        }
    }
}

这种思想是比较直接的迭代算法，其实还有一种比较巧妙的后序遍历算法，它将问题转化为先序遍历的问题，但这种方法是以空间换简单，需要用到 2 个栈：

  • 我们首先需要将要遍历的二叉树翻转，左右子树地位交换
  • 对翻转过的二叉树按照先序遍历的顺序将所有结点进栈
  • 挨个出栈访问，访问的顺序就是元二叉树后序遍历的顺序
public void postOrder(Node<T> root) {
    if (root == null) {
        return;
    }
    Node<T> r = root;
    Stack<Node<T>> stack1 = new Stack<>(20);
    Stack<Node<T>> stack2 = new Stack<>(20);
    while (r != null || !stack1.isEmpty()) {
        if (r != null) {
            stack2.push(r);
            stack1.push(r);
            r = r.rchild;
        } else {
            r = stack1.pop();
            r = r.lchild;
        }
    }
    while (!stack2.isEmpty()) {
        visit(stack2.pop());
    }
}

3.5 层次遍历

这需要借助队列进行遍历了，我们访问的结点必须是从队列里取出来的

public void levelOrder(Node<T> root) {
    if (root == null) {
        return;
    }
    Queue<Node<T>> queue = new Queue<>();
    Node<T> r = root;
    queue.offer(r);
    while (!queue.isEmpty()) {
        r = queue.poll();
        visit(r);
        if (r.lchild != null) {
            queue.offer(r.lchild);
        }
        if (r.rchild != null) {
            queue.offer(r.rchild);
        }
    }
}

4. 二叉排序树

4.1 二叉排序树的定义

二叉排序树或者是一棵空树，或者是具有下列特性的二叉树：

  • 若左子树非空，则左子树上所有结点的值均小于根结点的值
  • 若右子树非空，则右子树上所有结点的值均大于根结点的值
  • 左右子树也分别是一棵二叉排序树

所以对二叉树进行中序遍历，可以得到一个递增的一个有序序列

4.2 二叉排序树的查找

就是在这种结构中查询某个元素是否在其中，递归算法比较简单，这里给出迭代算法

public T bstSearch(Node<T> root, T key) {
    Node<T> target = new Node<>(key);
    while (root != null && root != target) {  // 这里注意要实现 Comparable 接口定义比较规则，这里简单写成这个样子了
        if (key < root) {
			root = root.lchild;
        }else{
            root = root.rchild;
        }
    }
    return root;
}

4.3 二叉排序树的插入

这个是动态创建的

public bool bstInsert(Node<T> root, T key) {
    if (root == null){
        Node<T> root = new Node<>(key);
        return true;
    }else if (root.data = key){
        return false;
    }else if (key < root.data){
        bstInsert(root.lchild, key);
    }else{
        bstInsert(root.rchild, key);
    }
}

4.4 二叉排序树的构造

给定数组序列构造 BST

public Node<T> BST(T[] data){ // 其实不允许泛型数组的，这里为了示意清楚
    root= null;
    for (T e: data){
        bstInsert(root, e);
    }
}

4.5 二叉排序树的删除

被删除的结点有三种情况：

  • 若被删除的结点是叶结点，则直接删除
  • 若被删除的结点只有一颗左子树或右子树，则将它的子树的根结点直接移动到被删除结点的位置
  • 若被删除的节点有两个子树，则用它的直接后继（或前驱）替代它，并将替代的结点删除

具体参照示例如下图所示：

在这里插入图片描述

5. 平衡二叉树

5.1 平衡二叉树的定义

为了避免树的高度增长过快，降低二叉排序树的性能，规定在插入和删除二叉树节点时，要保证任意结点的左、右子树高度差的绝对值不超过 1，将这样的二叉树称为平衡二叉树.

定义结点左子树与右子树的高度差为该节点的平衡因子.

  • 为了简单起见，假定 AVL 树的高度是 h h h， N ( h ) N(h) N(h) 表示高度为 h h h 的 AVL 树的节点数

  • 为了得到高度为 h h h 的 AVL 树的最小节点数，应该尽可能用最少的节点数来填充这棵树

  • 即假定填充左子树的高度为 h − 1 h−1 h−1，那么右子树的高度只能填充到 h − 2 h−2 h−2，这样，高度为 h h h 的 AVL 树的最小节点数为（假定只有根节点高度为 1 1 1）： N ( h ) = N ( h − 1 ) + N ( h − 2 ) + 1 N(h)=N(h-1)+N(h-2)+1 N(h)=N(h−1)+N(h−2)+1， N ( 1 ) = 1 , N ( 0 ) = 0 N(1)=1,N(0)=0 N(1)=1,N(0)=0

  • 最大结点数： N ( h ) = 2 N ( h − 1 ) + 1 N(h)=2N(h-1)+1 N(h)=2N(h−1)+1， N ( 1 ) = 1 , N ( 0 ) = 0 N(1)=1,N(0)=0 N(1)=1,N(0)=0，即满二叉树

5.2 平衡二叉树的旋转

平衡二叉树最大特点就是在插入或删除时的特殊操作，我们称之为旋转，我们先研究旋转是怎么实现的

当平衡二叉树进行插入（或删除）一个结点时，将会导致子树的高度加 1 1 1 或减 1 1 1，有可能造成平衡性的破坏，这时就要通过旋转来保证 AVL 树的平衡性，假设平衡性在 A \mathcal{A} A 结点开始破坏，即 A \mathcal{A} A 左右子树高度差为 2 2 2，主要有以下 4 4 4 中情况：

  • 在结点 A \mathcal{A} A 的左孩子的左子树中插入元素——LL 旋转
  • 在结点 A \mathcal{A} A 的左孩子的右子树中插入元素——LR 旋转
  • 在结点 A \mathcal{A} A 的右孩子的左子树中插入元素——RL 旋转
  • 在结点 A \mathcal{A} A 的右孩子的右子树中插入元素——RR 旋转

5.2.1 LL 旋转

A 的左孩子 B 绕着 A 顺时针旋转，B 的右孩子变为 A 的左孩子

在这里插入图片描述

5.2.2 RR 旋转

A 的右孩子 B 绕着 A 逆时针旋转，B 的左孩子变为 A 的右孩子

在这里插入图片描述

5.2.3 LR 旋转

先对 B 进行 RR 旋转，再对 A 进行 LL 旋转

在这里插入图片描述

5.2.4 RL 旋转

先对 B 进行 LL 旋转，再对 A 进行 RR 旋转

在这里插入图片描述

5.3 平衡二叉树的插入

这里偷懒了，用了以前 C++ 写的代码

AVLTree AVLInsert(AVLTree & r, int k) {
    if (r == NULL) {
        r = new AVLNode;
        r->data = k; r->height = 1;
        r->lchild = NULL;
        r->rchild = NULL;
    }else {
        if (k < r->data) {
            r->lchild = AVLInsert(r->lchild, k);
            if (r->lchild->height - r->rchild->height == 2) {
                if (k < r->lchild->data) {
                    r = LL(r);
                }else {
                    r = LR(r);
                }
            }
        }else if (k > r->data) {
            r->rchild = AVLInsert(r->rchild, k);
            if (r->rchild->height - r->lchild->height == 2) {
                if (k < r->rchild->data) {
                    r = RL(r);
                }else {
                    r = RR(r);
                }
            }
        }
        r->height = (r->lchild->height > r->rchild->height ? r->lchild->height : r->rchild->height) + 1;
    }
    return r;
}
ツぃ☆ve芜情
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
摩尔斯电码_摩尔斯电码二叉树和baader meinhof现象
weixin_26729165的博客
10-10 2885
摩尔斯电码The other night I was watching some videos by 2 Youtube channels I really like. The first one was Tom Scott’s video on why the Prime Meridian isn’t exactly at 0 degrees. I noticed that he happene...
数据结构——二叉树先序、中序、后序及层次四种遍历（C语言版）
热门推荐
正弦定理的博客
12-09 35万+
数据结构——二叉树先序、中序、后序三种遍历二叉树先序、中序、后序三种遍历三、代码展示： 二叉树先序、中序、后序三种遍历 先序遍历：3 2 2 3 8 6 5 4 中序遍历：2 2 3 3 4 5 6 8 后序遍历: 2 3 2 4 5 6 8 3 三种遍历不同之处在，输出数据放在不同之处 三、代码展示： #include<stdio.h> #include<stdlib.h> typedef struct Tree{ int
二叉树：层次遍历算法（自上而下，从左到右）
花间半盘棋
11-15 1万+
分析：层次遍历（LeverlOrder）就是一层一层遍历，层次遍历需要借助队列来完成，队列：先进先出（FIFO）。 如图有一棵二叉树，按照层次遍历最终的结果就是ABCDEFG，首先将根结点A入队列。 然后根结点出队，并访问A结点，发现A结点既有左孩子也有右孩子，那么就分别将左右孩子入队，此时队列中有BC。 A的左右孩子都入队了，然后将队头结点B出队并访问，此时序列为AB，B有左右孩子，所以将B的左右孩子DE入队，队中此时有CDE。 然后队头结点C出队并访问，C有左右孩子，所以将C的左右孩子FG入队。此时
二叉树详解
weixin_59371851的博客
07-09 5万+
目录前言一、树的概念和结构1、树的概念2、树的表示 3、树在实际中的应用（表示文件系统的目录树结构）二、二叉树概念及结构1.概念 2、特殊的二叉树3、二叉树的性质4、二叉树的存储4.1顺序存储4.2链状存储 三、二叉树的顺序结构和实现1、二叉树的顺序结构2、堆的概念及结构3、堆的实现3.1堆的代码框架3.2堆的插入3.3堆的删除3.4堆的建立 3.5建堆的时间复杂度 4、堆的应用4.1堆排序 4.2TOP-K问题四、二叉树链式结构的实现 1、建二叉树2、二叉树的遍历2.1前序、中序以及后序遍历2.2层序遍历
python二叉树
惊鸿的博客
03-12 5600
二叉树特征定义 特征 树是一种 非线性的数据结构，，直观的看，他是数据元素（在树中称为结点）按分支关系组织起来的结构，很像自然界中的树那样，树结构在客观世界中广泛存在，如人类社会的族谱和各种社会组织机构都可以用树形象来表示。还有比如在编译程序的时候，它可以用来表示源程序的语法结构，又或者在数据库中，树型结构也是信息的重要组织形式之一。 总之：一切具有层次关系的问题都可以用树来描述。 定义 树（Tree）是n（≥0）个节点的有限集。在任意一棵树中： 1、有且仅有一个称为根（Root）的结点 2、当n&g
二叉树的基本操作
Daioo 随笔
04-21 12万+
一、实验目的 1、掌握二叉树的定义； 2、掌握二叉树的基本操作，如二叉树的建立、遍历、结点个数统计、树的深度计算等。 二、实验内容 （一）用递归的方法实现以下算法： 1、以二叉链表表示二叉树，建立一棵二叉树（算法5.3）； 2、输出二叉树的中序遍历结果（算法5.1）； 3、输出二叉树的前序遍历结果（见讲稿）； 4、输出二叉树的后序遍历结果（见讲稿）； 5、计算二叉树的深度（算法5.
【数据结构】——二叉树详解
atwdy的博客
07-28 5万+
二叉树(Binary Tree)是由n个结点构成的有限集(n≥0)，n=0时为空树，n>0时为非空树。对于非空树TTT有且仅有一个根结点；除根结点外的其余结点又可分为两个不相交的子集TLT_LTL​和TRT_RTR​，分别称为TTT的左子树和右子树，且TLT_LTL​和TRT_RTR​本身又都是二叉树。很明显该定义属于递归定义，所以有关二叉树的操作使用递归往往更容易理解和实现。从定义也可以看出二叉树与一般树的区别主要是两点，一是每个结点的度最多为2；
树、森林与二叉树的转换
CSDN
12-30 14万+
树、森林与二叉树的转换 1、树转换为二叉树 由于二叉树是有序的，为了避免混淆，对于无序树，我们约定树中的每个结点的孩子结点按从左到右的顺序进行编号。 将树转换成二叉树的步骤是： （1）加线。就是在所有兄弟结点之间加一条连线； （2）抹线。就是对树中的每个结点，只保留他与第一个孩子结点之间的连线，删除它与其它孩子结点之间的连线； （3）旋转。就是以树的根结点为轴心，将整棵树顺时针旋转一定...
平衡二叉树
清风
05-01 4万+
1.定义 平衡二叉树，又称AVL树，用于解决二叉排序树高度不确定的情况，如果二叉排序树的子树间的高度相差太大，就会让二叉排序树操作的时间复杂度升级为O(n)，为了避免这一情况，为最坏的情况做准备，就出现了平衡二叉树，使树的高度尽可能的小，其本质还是一棵二叉搜索树。 平衡二叉树的性质： 左子树和右子树的高度之差的绝对值小于等于1 左子树和右子树也是平衡二叉树 为了方便起见，给树上的每个结点附加一个数字，给出该结点左子树与右子树的高度差，这个数字称为结点的平衡因子（BF） 平衡因子=结点左子树的高度-
二叉树_二叉树遍历_
10-04
1.二叉树的基本操作实现【问题描述】建立一棵二叉树，用递归方法实现二叉树的如下基本操作：（1）按先序序列构造一棵二叉链表表示的二叉树T；（2）对这棵二叉树进行遍历：先序、中序、后序以及层次遍历，分别输出...
二叉树 基础
03-08
在计算机科学中，二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。 二叉树的每个结点至多只有二棵子树...
将满二叉树转化为求和二叉树_二叉树_
09-30
在IT领域，特别是数据结构和算法的学习中，二叉树是一种重要的抽象数据类型。满二叉树是一种特殊的二叉树，其中每一层都是完全填充的，除了可能的最后一层，且最后一层的所有节点都尽可能地向左靠拢。而将满二叉树...
线索二叉树
04-10
通过前序序列创建线索二叉树 1:中序遍历 2:查找节点前驱后继 3:插入节点 4:删除节点 0:退出
分治策略
七秒钟的记忆
02-27 1500
分治算法
贪心策略
七秒钟的记忆
03-03 930
贪心策略简介
二叉树基础
七秒钟的记忆
02-24 834
简单介绍二叉树必会的基础知识
二叉搜索树
七秒钟的记忆
02-24 700
二叉搜索树相关内容

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值