java树结构的基础部分

小咪咪 2024-03-27 13:29 51阅读 0赞

1.二叉树

为什么需要树这种数据结构

1.  数组存储方式的分析

优点：通过下标方式访问元素，速度快。对于有序数组，还可使用二分查找提高检索速度。

缺点：如果要检索具体某个值，或者插入值(按一定顺序)会整体移动，效率较低 \[示意图\]  
画出操作示意图：  
![在这里插入图片描述][045be197cee144a28885d01525fe7809.png]

1.  链式存储方式的分析

优点：在一定程度上对数组存储方式有优化(比如：插入一个数值节点，只需要将插入节点，链接到链表中即可，  
删除效率也很好)。

缺点：在进行检索时，效率仍然较低，比如(检索某个值，需要从头节点开始遍历) 【示意图】  
操作示意图：

![在这里插入图片描述][68a5fe37dbe94ac4be827224cf3ebd09.png]

1.  树存储方式的分析  
    能提高数据存储，读取的效率, 比如利用 二叉排序树(Binary Sort Tree)，既可以保证数据的检索速度，同时也  
    可以保证数据的插入，删除，修改的速度。【示意图,后面详讲】

案例: \[7, 3, 10, 1, 5, 9, 12\]

![在这里插入图片描述][392b48e5b59e4f3995c2dd9bab6f8246.png]

2.树示意图

![在这里插入图片描述][64ee0e45bc054bfba0e6a04e9e0bc612.png]

树的常用术语(结合示意图理解):

1.  节点
2.  根节点
3.  父节点
4.  子节点
5.  叶子节点 (没有子节点的节点)
6.  节点的权(节点值)
7.  路径(从 root 节点找到该节点的路线)
8.  层
9.  子树
10. 树的高度(最大层数)
11. 森林 :多颗子树构成森林

3.二叉树的概念

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

![在这里插入图片描述][0463d0cb9c204081a39d3dce24a22db8.png]

1.  如果该二叉树的所有叶子节点都在最后一层，  
    并且结点总数= 2^n -1 , n 为层数，则我们称为满二叉树。

![在这里插入图片描述][64428df693974040bacab522f1882dc2.png]

1.  如果该二叉树的所有叶子节点都在最后一层或者倒数第二层，而且最后一层的叶子节点在左边连续，倒数第二  
    层的叶子节点在右边连续，我们称为完全二叉树

![在这里插入图片描述][8e3e9a304b4c46b1bd40ceb77b731df9.png]

4.二叉树遍历的说明

使用前序，中序和后序对下面的二叉树进行遍历.

1.  前序遍历: 先输出父节点，再遍历左子树和右子树
2.  中序遍历: 先遍历左子树，再输出父节点，再遍历右子树
3.  后序遍历: 先遍历左子树，再遍历右子树，最后输出父节点
4.  小结: 看输出父节点的顺序，就确定是前序，中序还是后序

5.二叉树遍历应用实例(前序,中序,后序)

应用实例的说明和思路

![在这里插入图片描述][e56cf5c04f3745e382904f14ee61daec.png]

public class BinaryTreeDemo {
        
    
    	public static void main(String[] args) {
        
    		// 先需要创建一颗二叉树
    		BinaryTree binaryTree = new BinaryTree();
    		// 创建需要的节点
    		HeroNode root = new HeroNode(1, "宋江");
    		HeroNode node2 = new HeroNode(2, "吴用");
    		HeroNode node3 = new HeroNode(3, "卢俊义");
    		HeroNode node4 = new HeroNode(4, "林冲");
    
    		// 说明，我们先手动创建该二叉树，后面我们学习递归的方式创建二叉树
    		root.setLeft(node2);
    		root.setRight(node3);
    		node3.setRight(node4);
    		binaryTree.setRoot(root);
    
    		// 测试
    		System.out.println("前序遍历");// 1，2，3，4
    		binaryTree.preOrder();
    
    		// 测试
    		System.out.println("中序遍历");
    		binaryTree.infixOrder();
    
    		// 测试
    		System.out.println("后序遍历");// 1，2，3，4
    		binaryTree.postOrder();
    	}
    
    }
    
    //定义BinaryTree二叉树
    class BinaryTree {
        
    	private HeroNode root;
    
    	public void setRoot(HeroNode root) {
        
    		this.root = root;
    	}
    
    	// 前序遍历
    	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("二叉树为空，无法遍历");
    		}
    	}
    }
    
    //先创建HeroNode结点
    class HeroNode {
        
    	private int no;
    	private String name;
    	private HeroNode left;// 默认null
    	private HeroNode right;// 默认null
    
    	public HeroNode(int no, String name) {
        
    		this.no = no;
    		this.name = name;
    	}
    
    	public int getNo() {
        
    		return no;
    	}
    
    	public void setNo(int no) {
        
    		this.no = no;
    	}
    
    	public String getName() {
        
    		return name;
    	}
    
    	public void setName(String name) {
        
    		this.name = name;
    	}
    
    	public HeroNode getLeft() {
        
    		return left;
    	}
    
    	public void setLeft(HeroNode left) {
        
    		this.left = left;
    	}
    
    	public HeroNode getRight() {
        
    		return right;
    	}
    
    	public void setRight(HeroNode right) {
        
    		this.right = right;
    	}
    
    	@Override
    	public String toString() {
        
    		return "HeroNode [no=" + no + ", name=" + name + "]";
    	}
    
    	// 编写前序遍历方法
    	public void preOrder() {
        
    		System.out.println(this);// 先输出父节点
    		// 递归向左子树前序遍历
    		if (this.left != null) {
        
    			this.left.preOrder();
    		}
    		// 递归向右子树前序遍历
    		if (this.right != null) {
        
    			this.right.preOrder();
    		}
    
    	}
    
    	// 中序遍历
    	public void infixOrder() {
        
    		// 递归向左子树前序遍历
    		if (this.left != null) {
        
    			this.left.infixOrder();
    		}
    		System.out.println(this);// 输出父节点
    		// 递归向右子树前序遍历
    		if (this.right != null) {
        
    			this.right.infixOrder();
    		}
    	}
    
    	// 后序遍历
    	public void postOrder() {
        
    
    		// 递归向左子树前序遍历
    		if (this.left != null) {
        
    			this.left.postOrder();
    		}
    		// 递归向右子树前序遍历
    		if (this.right != null) {
        
    			this.right.postOrder();
    		}
    		System.out.println(this);// 输出父节点
    	}
    }

[045be197cee144a28885d01525fe7809.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/8954a1972f7746f7986f029334a9b107.png
[68a5fe37dbe94ac4be827224cf3ebd09.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/138c2348037c42c58006f76f53ba98a2.png
[392b48e5b59e4f3995c2dd9bab6f8246.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/ec5fe050232441129daa2712116592c8.png
[64ee0e45bc054bfba0e6a04e9e0bc612.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/52ac866a91974a0fb5ed67e56a32b7fb.png
[0463d0cb9c204081a39d3dce24a22db8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/01abc8af336f412295f72d5ec2c4e82a.png
[64428df693974040bacab522f1882dc2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/e6687613d3c7449b929065bd484c3c1d.png
[8e3e9a304b4c46b1bd40ceb77b731df9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/4c68e565ec5443378b84fe70e606f4ed.png
[e56cf5c04f3745e382904f14ee61daec.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/593597c32bb74e8e9126301b5f4309d3.png