• 数据结构07 二叉树


    这篇文章开始总结 树和二叉树。

    什么是树呢?

    1、树的定义

    (1)有且仅有一个特定的称为根(root) 的节点。

    (2)当 n>1 时,其余节点可分为 m(m>0) 个互不相交的集合。其中每个集合本身又是一个棵树,并称为根的子树。

    2、树的表示方法

    最常见的是 树形表示法 和 广义表表示法,下面是树形表示法,如图所示。

    上图的 广义表表示法为:(A(B(D,E),C(F,G)))   

    3、常见的术语

      (1)父节点,孩子节点,兄弟节点。以上图为例,A是B和C的父节点,B和C是A的孩子节点,B和C之间互为兄弟节点。

      (2)节点的度和树的度。节点的度即节点有几个分支,比如节点A有两个分支B和C,那么节点A的度就是2,树的度即为一棵树中节点的最大度数,所以上图的树的度也是2。

      (3)有序树和无序树。如果将树中节点的子树看成是从左至右依次有序且不能交换,则称该树为有序树,否则称为无序树。

      (4)森林。在上图中,如果将根节点A拿掉,那么B子树和C子树合并就是森林了。

      (5)二叉树。二叉树是一种特殊的树。它的每个节点最多只有两棵子树。

    4、二叉树的常见性质

      性质1:在二叉树的第 i 层上最多有 2i-1 个节点 (i>=1)

      性质2:深度为 k 的二叉树最多有 2k-1 个节点 (k>=1)

      性质3:满二叉树:一棵深度为 k 且有 2k-1 个节点的二叉树称为 满二叉树。

           完全二叉树:一棵深度为 k 的二叉树,其前 k-1 层是一棵满二叉树,而最下面一层(即第k层) 上的节点都集中在该层最左边的若干位置上。这样的二叉树称为 完全二叉树。

    满二叉树一定是完全二叉树,但完全二叉树不一定是满二叉树。

    下面是 满二叉树 和 完全二叉树 的图示:

    5、二叉树的两种存储结构

    5-1:顺序存储 

    对于完全二叉树而言,可以使用顺序存储结构。但对于一般的二叉树而言,使用顺序存储结构会有两个缺点:一、如果不是完全二叉树,则必须将其转化为完全二叉树;二、增加了很多虚节点,浪费资源空间。

    5-2:链式存储

    链式存储是最常用的一种二叉树存储结构。每个节点设置三个域,分别是值域、左指针域和右指针域,用 data 表示值域,lchild 和 rchild 分别表示指向左子树、右子树的指针域。如下图: 

    6、二叉树的常见操作

    6-1:插入节点

    思路:首先找到要插入节点的父节点,然后确定插入到父节点的左边还是右边,最后将节点插入。

    6-2:查找节点

    思路:运用递归查找。

    6-3:计算树的深度

    思路:分别递归左子树和右子树,取长度较大的那一个作为整个树的深度。

    6-4:遍历之 先序遍历

    思路:先访问根节点,然后遍历左子树,再遍历右子树

    6-5:遍历之 中序遍历

    思路:先遍历左子树,再访问根节点,最后遍历右子树

    6-6:遍历之 后序遍历

    思路:先遍历左子树,再遍历右子树,最后访问根节点

    6-7:遍历之 按层遍历

    思路:从上到下,从左到右遍历节点

    7、二叉树的常见操作的代码实现

    代码如下:

    节点类Node.java 

    public class Node {
        public int data; // 数据域
        public Node left; // 左孩子
        public Node right; // 右孩子
    }

    BinTree.java

    import java.util.Scanner;
    
    public class BinTree {
        // 按层遍历的存储空间长度
        public static int length;
    
        /**
         * 生成根节点
         */
        public static Node createRoot() {
            Node root = new Node();
            System.out.println("请输入根节点,以便生成树:");
            root.data = new Scanner(System.in).nextInt();
            System.out.println("根节点生成成功");
            return root;
        }
    
        /**
         * 插入节点
         *
         * @param root 二叉树的根节点
         * @return 返回二叉树的根节点
         * @throws Exception
         */
        public static Node insert(Node root) throws Exception {
            while (true) {
                System.out.println("请输入待插入节点的数据:");
                Node node = new Node();
                node.data = new Scanner(System.in).nextInt();
    
                // 获取父节点数据
                System.out.println("请输入它(待插入节点) 的父节点:");
                int parentNodeData = new Scanner(System.in).nextInt();
    
                // 确定插入方向
                System.out.println("请确定要插入到父节点的:1 左侧, 2 右侧");
                int direction = new Scanner(System.in).nextInt();
    
                // 插入节点
                root = insertNode(root, node, parentNodeData, direction);
    
                if (root == null) {
                    System.out.println("未找到父节点,请重新输入!");
                    continue;
                }
                System.out.println("插入成功,是否继续? 1继续,2退出");
    
                if (new Scanner(System.in).nextInt() == 1)
                    continue;
                else
                    break; // 退出循环
            }
            return root;
        }
    
        /**
         * 从insert()方法抽取出来的需要递归的部分
         *
         * @param root           二叉树的根节点
         * @param node           待插入节点
         * @param parentNodeData 待插入节点的父节点
         * @param direction      插入到左边还是右边
         * @return 返回二叉树的根节点
         * @throws Exception
         */
        public static Node insertNode(Node root, Node node, int parentNodeData, int direction) throws Exception {
            if (root == null)
                return null;
    
            // 找到父节点
            if (root.data == parentNodeData) {
                switch (direction) {
                    case 1:
                        if (root.left != null)
                            throw new Exception("左节点已存在,不能插入!");
                        else
                            root.left = node;
                        break;
                    case 2:
                        if (root.right != null)
                            throw new Exception("右节点已存在,不能插入!");
                        else
                            root.right = node;
                        break;
                }
            }
    
            // 向左子树查找父节点(递归)
            insertNode(root.left, node, parentNodeData, direction);
            // 向右子树查找父节点(递归)
            insertNode(root.right, node, parentNodeData, direction);
    
            return root;
        }
    
        /**
         * 查找节点
         */
        public static boolean getNode(Node root, int data) {
            if (root == null)
                return false;
    
            // 查找成功
            if (root.data == data)
                return true;
    
            // 递归查找
            boolean result1 = getNode(root.left, data);
            boolean result2 = getNode(root.right, data);
            return result1 || result2;
        }
    
        /**
         * 获取二叉树的深度
         * 思路:分别递归左子树和右子树,取长度较大的那一个作为整个树的深度
         *
         * @param root 二叉树的根节点
         * @return
         */
        public static int getLength(Node root) {
            if (root == null)
                return 0;
            int leftLength, rightLength;
    
            // 递归左子树的深度
            leftLength = getLength(root.left);
            // 递归右子树的深度
            rightLength = getLength(root.right);
    
            if (leftLength > rightLength)
                return leftLength + 1;
            else
                return rightLength + 1;
        }
    
        /**
         * 先序遍历
         * 思路:先访问根节点,然后遍历左子树,再遍历右子树
         *
         * @param root 根节点
         */
        public static void DLR(Node root) {
            if (root == null)
                return;
    
            // 输出节点的值
            System.out.print(root.data + " ");
    
            // 递归遍历左子树
            DLR(root.left);
    
            // 递归遍历右子树
            DLR(root.right);
        }
    
        /**
         * 中序遍历
         * 思路:先遍历左子树,再访问根节点,最后遍历右子树
         *
         * @param root 根节点
         */
        public static void LDR(Node root) {
            if (root == null)
                return;
    
            // 遍历左子树
            LDR(root.left);
    
            // 输出节点的值
            System.out.print(root.data + " ");
    
            // 遍历右子树
            LDR(root.right);
        }
    
        /**
         * 后序遍历
         * 思路:先遍历左子树,再遍历右子树,最后访问根节点
         *
         * @param root 根节点
         */
        public static void LRD(Node root) {
            if (root == null)
                return;
    
            // 遍历左子树
            LRD(root.left);
    
            // 遍历右子树
            LRD(root.right);
    
            // 输出节点的值
            System.out.print(root.data + " ");
        }
    
        /**
         * 按层遍历
         * 思路:从上到下,从左到右遍历节点
         *
         * @param root 根节点
         */
        public static void traversalLevel(Node root) {
            if (root == null)
                return;
    
            int head = 0;
            int tail = 0;
    
            // 申请保存空间
            Node[] nodeList = new Node[length];
    
            // 将当前二叉树保存到数组中
            nodeList[tail] = root;
    
            // 计算tail的位置
            tail = (tail + 1) % length; // 除留余数法
    
            while (head != tail) {
                Node tempNode = nodeList[head];
    
                // 计算head的位置
                head = (head + 1) % length;
    
                // 输出节点的值
                System.out.print(tempNode.data + " ");
    
                // 如果左子树不为空,则将左子树保存到数组的tail位置
                if (tempNode.left != null) {
                    nodeList[tail] = tempNode.left;
                    // 重新计算tail的位置
                    tail = (tail + 1) % length;
                }
    
                // 如果右子树不为空,则将右子树保存到数组的tail位置
                if (tempNode.right != null) {
                    nodeList[tail] = tempNode.right;
                    // 重新计算tail的位置
                    tail = (tail + 1) % length;
                }
            }
        }
    }

    BinTreeTest.java

    public class BinTreeTest {
        public static void main(String[] args) throws Exception {
            System.out.println("*******链式存储的二叉树*******");
            // 创建根节点
            Node root = BinTree.createRoot();
    
            // 1、插入节点
            System.out.println("********插入节点*******");
            BinTree.insert(root);
    
            // 2、查找节点
            System.out.print("查找data为2的节点是否存在:");
            boolean result = BinTree.getNode(root, 2);
            System.out.println(result);
    
            // 3、获取二叉树的深度
            System.out.println("当前二叉树的深度为:" + BinTree.getLength(root));
    
            // 4、先序遍历
            System.out.print("先序遍历:");
            BinTree.DLR(root);
            System.out.println("");
    
            // 5、中序遍历
            System.out.print("中序遍历:");
            BinTree.LDR(root);
            System.out.println("");
    
            // 6、后序遍历
            System.out.print("后序遍历:");
            BinTree.LRD(root);
            System.out.println("");
    
            // 7、按层遍历
            System.out.print("按层遍历:");
            BinTree.length = 100;
            BinTree.traversalLevel(root);
            System.out.println("");
        }
    }

    运行结果:

    欢迎转载,但请保留文章原始出处

    本文地址:http://www.cnblogs.com/nnngu/p/8308220.html 

  • 相关阅读:
    OnContextMenu事件
    wireshark教程
    常见的算法题:逆行单一列表
    GPIO
    USB OTG简要
    软测验点---平衡二叉树
    SSL工作原理
    CFileDialog 使用简单介绍
    eclipse在maven项目交付svn忽略简介
    四个漂亮CSS样式表
  • 原文地址:https://www.cnblogs.com/nnngu/p/8308220.html
Copyright © 2020-2023  润新知