数据结构-二叉树

最新推荐文章于 2024-10-31 21:04:10 发布

gywl

最新推荐文章于 2024-10-31 21:04:10 发布

阅读量1k

点赞数 31

分类专栏：数据结构（Java语言版）文章标签：数据结构

本文链接：https://blog.csdn.net/2301_80141037/article/details/142652364

版权

数据结构（Java语言版）专栏收录该内容

13 篇文章 0 订阅

订阅专栏

树型结构

概念

二叉树

两种特殊的二叉树

满二叉树：每一个节点都有两个度。

完全二叉树：从上到下从左到右依次存放。

要注意的是满二叉树是一种特殊的完全二叉树。

二叉树的性质

性质一

性质二

性质三

度为0的节点会比度为2的节点多一个

某二叉树共有 399 个结点，其中有 199 个度为 2 的结点，则该二叉树中的叶子结点数为（）

A 不存在这样的二叉树

B 200

C 198

D 199

在具有 2n 个结点的完全二叉树中，叶子结点个数为（）

A n B n+1 C n-1 D n/2

性质四

一棵完全二叉树的节点数为531个，那么这棵树的高度为（）
A 11 B 10 C 8 D 12

性质五

对于具有n个结点的完全二叉树，如果按照从上至下从左至右的顺序对所有节点从0开始编号，则对于序号为i的结点有：

若i>0，双亲序号：(i-1)/2；i=0，i为根结点编号，无双亲结点（已知孩子节点下标是i，求父亲节点下标）同样，如果如果父亲节点下标是i，则左孩子节点为2*i+1，右孩子节点为2*i+2

若2i+1<n，左孩子序号：2i+1，否则无左孩子

若2i+2<n，右孩子序号：2i+2，否则无右孩子

二叉树的遍历

前中后序遍历

NLR：前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点--->根的左子树--->根的右子树。

LNR：中序遍历(Inorder Traversal)——根的左子树--->根节点--->根的右子树。

LRN：后序遍历(Postorder Traversal)——根的左子树--->根的右子树--->根节点。

前序遍历结果：1 2 3 4 5 6

中序遍历结果：3 2 1 5 4 6

后序遍历结果：3 1 5 6 4 1

层序遍历

自上而下，自左至右逐层访问树的结点的过程就是层序遍历。

1.某完全二叉树按层次输出（同一层从左到右）的序列为 ABCDEFGH 。该完全二叉树的前序序列为() A: ABDHECFG B: ABCDEFGH C: HDBEAFCG D: HDEBFGCA

2.二叉树的先序遍历和中序遍历如下：先序遍历：EFHIGJK;中序遍历：HFIEJKG.则二叉树根结点为()

A: E B: F C: G D: H

先通过前序遍历确定根的位置E

再根据中序遍历确定根的左子树和右子树

3.设一课二叉树的中序遍历序列：badce，后序遍历序列：bdeca，则二叉树前序遍历序列为()A: adbce B: decab C: debac D: abcde

先根据后序遍历确定根的位置A

再根据中序遍历确定左右子树

4.某二叉树的后序遍历序列与中序遍历序列相同，均为 ABCDEF ，则按层次输出(同一层从左到右)的序列为()

A: FEDCBA B: CBAFED C: DEFCBA D: ABCDEF

根据前序遍历和后序遍历无法创建一棵二叉树因为只能确定根的位置无法确定左右子树的位置。

二叉树的实现（类似于链表的链式存储）

二叉树的创建（简单粗暴法）

public class TestBinaryTree {
    static class TreeNode {
        public char val;
        public TreeNode left;
        public TreeNode right;

        public TreeNode(char val) {
            this.val = val;
        }
    }

    public TreeNode createTree() {
        TreeNode A = new TreeNode('A');
        TreeNode B = new TreeNode('B');
        TreeNode C = new TreeNode('C');
        TreeNode D = new TreeNode('D');
        TreeNode E = new TreeNode('E');
        TreeNode F = new TreeNode('F');
        TreeNode G = new TreeNode('G');
        TreeNode H = new TreeNode('H');

        A.left = B;
        A.right = C;
        B.left = D;
        B.right = E;
        C.left = F;
        C.right = G;
        E.right = H;

        return A;
    }
}

public class Test {
    public static void main(String[] args) {
        TestBinaryTree testBinaryTree = new TestBinaryTree();
        TestBinaryTree.TreeNode root = testBinaryTree.createTree();
    }
}

前序遍历

void preOrder(TreeNode root) {
    if (root == null) {
        return;
    }
    System.out.print(root.val + " ");
    //递归遍历左子树
    preOrder(root.left);
    //递归遍历右子树
    preOrder(root.right);
}

中序遍历

void inOrder(TreeNode root) {
    if (root == null) {
        return;
    }
    inOrder(root.left);
    System.out.print(root.val + " ");
    inOrder(root.right);
}

后序遍历

void postOrder(TreeNode root) {
    if (root == null) {
        return;
    }
    postOrder(root.left);
    postOrder(root.right);
    System.out.print(root.val + " ");
}

获取树中节点的个数

左子树的节点个数+右子树的节点个数+1=整棵树的节点个数

public int size(TreeNode root) {
    if (root == null) {
        return 0;
    }
    int ret = size(root.left) + size(root.right) + 1;
    return ret;
}

获取叶子节点的个数

整棵树的叶子节点个数=左子树的叶子节点+右子树的叶子节点

public int getLeafNodeCount(TreeNode root) {
    if (root == null) {
        return 0;
    }
    if (root.left == null && root.right == null) {
        return 1;
    }
    return getLeafNodeCount(root.left) + getLeafNodeCount(root.right);
}

获取第K层节点的个数

public int getKLevelNodeCount(TreeNode root, int k) {
    if (root == null) {
        return 0;
    }
    if (k == 1) {
        return 1;
    }
    return getKLevelNodeCount(root.left, k - 1) + getKLevelNodeCount(root.right, k - 1);
}

获取二叉树的高度

整棵树的高度=Math.max(左树高度和右树高度)+1

public int getHeight(TreeNode root) {
    if (root == null) {
        return 0;
    }
    int leftHeight = getHeight(root.left);
    int rightHeight = getHeight(root.right);
    return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
}

检测值为value的元素是否存在

TreeNode find(TreeNode root, int val) {
    if (root == null) {
        return null;
    }
    if (root.val == val) {
        return root;
    }
    TreeNode ret = find(root.left, val);
    if (ret != null) {
        return ret;
    }
    ret = find(root.right, val);
    if (ret != null) {
        return ret;
    }
    return null;
}

层序遍历

void levelOrder(TreeNode root) {
    Queue<TreeNode> queue = new LinkedList<>();
    if (root == null) {
        return;
    }
    queue.offer(root);
    while (!queue.isEmpty()) {
        TreeNode cur = queue.poll();
        System.out.print(cur.val + " ");
        if (cur.left != null) {
            queue.offer(cur.left);
        }
        if (cur.right != null) {
            queue.offer(cur.right);
        }
    }
    System.out.println();
}

判断一棵树是不是完全二叉树

boolean isCompleteTree(TreeNode root) {
    Queue<TreeNode> queue = new LinkedList<>();
    if (root == null) return true;
    queue.offer(root);
 
    while (!queue.isEmpty()) {
        TreeNode cur = queue.poll();
        if (cur == null) {
            break;
        }
        queue.offer(cur.left);
        queue.offer(cur.right);
    }
    while (!queue.isEmpty()) {
        TreeNode node = queue.peek();
        if (node != null) {
            return false;
        } else {
            queue.poll();
        }
    }
    return true;
}