[java] 树基础

最新推荐文章于 2024-10-29 23:05:08 发布
原创 最新推荐文章于 2024-10-29 23:05:08 发布 · 289 阅读 · 1 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#二叉树

这篇文章就是对树的知识做一个整理，主要以二叉树为例

1、定义

	public class TreeNode {
	   int val;
	   TreeNode left;
	   TreeNode right;
	   TreeNode(int x) { val = x; }
	}

2、遍历

2.1、先序遍历

递归实现

    public void preOrder(TreeNode root) {
        if(root!=null){
			System.out.print(root.val);
			preOrder(root.left);
			preOrder(root.right);
		}
    }

非递归实现

    public void preOrder(TreeNode root){
        Stack<TreeNode> stack=new Stack<TreeNode>();
        while(true){
            while(root!=null){
                System.out.print(root.val);
                stack.push(root);
                root=root.left;
            }
            if(stack.isEmpty()) break;
            root=stack.pop();
            root=root.right;
        }
    }

2.2、中序遍历

递归实现

    public void inOrder(TreeNode root) {
        if(root!=null){
			inOrder(root.left);
			System.out.print(root.val);
			inOrder(root.right);
		}
    }

非递归实现

    public void inOrder(TreeNode root){
        Stack<TreeNode> stack=new Stack<TreeNode>();
        while(true){
            while(root!=null){
                stack.push(root);
                root=root.left;
            }
            if(stack.isEmpty())break;
            root=stack.pop();
            System.out.print(root.val);
            root=root.right;
        }
    }

2.3、后序遍历

递归实现

    public void postOrder(TreeNode root) {
        if(root!=null){
			postOrder(root.left);
			postOrder(root.right);
			System.out.print(root.val);
		}
    }

非递归实现

    public void postOrder(TreeNode root){
        Stack<TreeNode> stack=new Stack<TreeNode>();
        while(true){
            if(root!=null){
                stack.push(root);
                root=root.left;
            }else{
                if(stack.isEmpty()) return;

                if(null==stack.peek().right){
                    root=stack.pop();
                    System.out.print(root.val);
                    while(root==stack.peek().right){
                        System.out.print(stack.peek().val);
                        root=stack.pop();
                        if(stack.isEmpty()){
                            break;
                        }
                    }
                }
                if(!stack.isEmpty())
                    root=stack.peek().right;
                else
                    root=null;
            }
        }
    }

tips: 妙用前序遍历的非递归可以实现后序遍历的非递归实现，这里需要注意几点改变：后序时，先遍历右，再遍历左，最后将得到的结果反向就好了。

2.4、层序遍历

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

3、树的构造（一维数组转二叉树）

在这里插入图片描述
基本方法，二叉树里面的空节点全部用null代替

	Integer[] array=new Integer[]{2,null,4,null,null,9,8,null,null,null,null,null,null,4};
    TreeNode root = createTreeNode(array, 1);
	// 因为数组中含有null，所以必须用Integer类型，如果是完全二叉树，则可以用int
    private static TreeNode createTreeNode(int[] array, int index) {
        if(index > array.length){
            return null;
        }
        int value = array[index - 1];
        if(value == null){
            return null;
        }
        TreeNode node = new TreeNode(value);
        node.left = createTreeNode(array, index * 2);
        node.right = createTreeNode(array, index * 2 + 1);
        return node;
    }

上述算法同样适用于完全二叉树，但是在非完全二叉树时，大部分情况下使用的是下面的优化的一维数组

	Integer[] array=new Integer[]{2,null,4,9,8,null,null,4};
	TreeNode root = arrayToTreeNode(array);
	
    public static TreeNode arrayToTreeNode(Integer[] array){
        if(array.length == 0){
            return null;
        }
        TreeNode root = new TreeNode(array[0]);
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        boolean isLeft = true;
        for(int i = 1; i < array.length; i++){
            TreeNode node = queue.peek();
            if(isLeft){
                if(array[i] != null){
                    node.left = new TreeNode(array[i]);
                    queue.offer(node.left);
                }
                isLeft = false;
            }else {
                if(array[i] != null){
                    node.right = new TreeNode(array[i]);
                    queue.offer(node.right);
                }
                queue.poll();
                isLeft = true;
            }
        }
        return root;
    }

4、树的深度

	public static int deep(TreeNode root){
		if(root == null)
			return 0;
		return 1+Math.max(deep(root.left),deep(root.right));
	}

5、二叉搜索树

5.1、插入节点

	int[] array=new int[]{2,1,5,3,4,6,9,7,8};
    TreeNode root=null;
    for(int a:array){
        root=insert(a,root);
    }
    
    public TreeNode insert(int key,TreeNode root){    
        TreeNode p=new TreeNode(); 
        p.val=key;
        if(root==null) return p;
        TreeNode parent=root;
        while(true){
            if(key>parent.val){
                if(parent.right==null){
                    parent.right=p;
                    break;
                }
                else parent=parent.right;
            }
            else{
                if(parent.left==null){
                    parent.left=p;
                    break;
                }
                else parent=parent.left;
            }
        }
        return root;
    }

5.2、查找节点

5.2.1、查找某个值

    public TreeNode find(int key){
        TreeNode cur = root;
        while (cur.val != key){
            if (key > cur.val)
                cur = cur.right;
            else
                cur = cur.left;
            if (cur == null) return null;
        }
        return current;
    }

5.2.2、查找前驱节点

前驱节点代表的是中序遍历序列的前一个节点。先取当前节点的左节点，然后取该节点的右节点，直到右节点为空，则最后指向的节点为前驱节点。

    public TreeNode getPre(TreeNode root) {
		root = root.left;
		while (root.right != null) root = root.right;
		return root;
    }

5.2.3、查找后继节点

后继节点代表的是中序遍历序列的下一个节点。先取当前节点的右节点，然后一直取该节点的左节点，直到左节点为空，则最后指向的节点为后继节点。

    public TreeNode getNext(TreeNode root) {
        root = root.right;
        while (root.left != null) root = root.left;
        return root;
    }

5.3、删除节点（难点）

删除节点复杂一点，主要可以分为三种情况：

  1. 删除的节点是叶子节点：删除节点23
  2. 删除的节点有一个孩子：删除节点24
  3. 删除的节点有两个孩子（这个里面包含两种情况）
    • 后继节点为删除节点的右孩子：删除节点30
    • 后继节点为删除节点的右孩子的左子树：删除节点24

在这里插入图片描述
非递归实现

    public TreeNode delete(int key,TreeNode root){
        TreeNode cur = root;
        TreeNode parent = new TreeNode();
        boolean isRightChild = true;
        while (cur.val!= key){
            parent = cur;
            if (key > cur.val){
                cur = cur.right;
                isRightChild = true;
            }
            else{
                cur = cur.left;
                isRightChild = false;
            }
            if (cur == null) return root; // 没有找到要删除的结点
        }

        // 要删除结点为叶子结点
        if (cur.right == null && cur.left == null){
            if (cur == root) root = null;
            else{
                if (isRightChild) parent.right = null;
                else parent.left = null;
            }
        }

        //要删除结点有一个子结点
        else if(cur.left==null){
            if(cur==root) root=cur.right;
            else if(isRightChild) parent.right=cur.right;
            else parent.left=cur.right;
        }
        else if(cur.right==null){
            if(cur==root) root=cur.left;
            else if(isRightChild) parent.right=cur.left;
            else parent.left=cur.left;
        }

        //要删除结点有两个子结点
        else{
            TreeNode next=getNext(cur);    //找到要删除结点的后继结点
            // 树的预处理
            if(next!=cur.right)
                cur.right.left=next.right;
                next.right=cur.right;
            
            if(cur==root)
                root=next;
            else if(isRightChild)
                parent.right=next;
            else
                parent.left=next;
                
            next.left=cur.left;   
        }
        return root;
    }

递归实现

  • 如果 key > root.val，说明要删除的节点在右子树，root.right = delete(root.right, key)。
  • 如果 key < root.val，说明要删除的节点在左子树，root.left = delete(root.left, key)。
  • 如果key == root.val，则该节点就是我们要删除的节点，则：
    • 如果该节点是叶子节点，则直接删除它：root = null。
    • 如果该节点不是叶子节点且有右节点，则用它的后继节点的值替代 root.val = next.val，然后删除后继节点。
    • 如果该节点不是叶子节点且只有左节点，则用它的前驱节点的值替代 root.val = pre.val，然后删除前驱节点。
  • 返回 root。

递归实现和非递归实现不一样，在非递归中，删除的就是需要删除的节点，其他节点的位置会跟着变化，但是在递归中，节点位置本身没变，只是节点中的值在变化，所以这个里面的前驱结点和后继结点的函数返回的是节点的值而不是节点

	public TreeNode delete(TreeNode root, int key) {
	    if (root == null) return null;
	    if (key > root.val) root.right = delete(root.right, key);
	    else if (key < root.val) root.left = delete(root.left, key);
	    else {
	      if (root.left == null && root.right == null) root = null;
	      else if (root.right != null) {
	        root.val = getNext(root);
	        root.right = delete(root.right, root.val);
	      }
	      else {
	        root.val = getPre(root);
	        root.left = delete(root.left, root.val);
	      }
	    }
	    return root;
	}

6、平衡二叉搜索树

6.1、有序数组转平衡二叉搜索树

选择中点作为根节点，根节点左侧的作为左子树，右侧的作为右子树即可

    public TreeNode sortedArrayToBST(int[] nums) {
        TreeNode root=creat(nums,0,nums.length-1);
        return root;
    }
    public TreeNode creat(int[] nums,int low,int high){
        if(low>high) return null;
        int mid=(low+high)/2;
        TreeNode p=new TreeNode(nums[mid]);
        p.left=creat(nums,low,mid-1);
        p.right=creat(nums,mid+1,high);
        return p;
    }

6.2、二叉搜索树转平衡二叉搜索树

先中序遍历为有序数组再构建二叉搜索树，代码略

Java实现 蓝桥杯VIP 基础练习 Huffuman树
南 墙
06-15 1万+
基础练习 Huffuman树 问题描述 　　Huffman树在编码中有着广泛的应用。在这里，我们只关心Huffman树的构造过程。 　　给出一列数{pi}={p0, p1, …, pn-1}，用这列数构造Huffman树的过程如下： 　　1. 找到{pi}中最小的两个数，设为pa和pb，将pa和pb从{pi}中删除掉，然后将它们的和加入到{pi}中。这个过程的费用记为pa +pb。 　　2. 重复...
二叉树(三)| 二叉树的高级操作(求高度、深度)(java实现)
KevinBrain的博客
07-10 1982
二叉树节点的存储结构 public class TreeNode { int val; TreeNode left; TreeNode right; TreeNode(int x) { val = x; } } 获取树的深度 树的深度是指从根节点到叶子节点的最长路径。 当前节点的深度示意图 1、递归实现获取树的深度 //(递归方式)获取以root为根节点的子树的深度:从叶子节点到达根节点的最长路径 public int
redis分布式锁SET实现 ，避免出现SETNX死锁
彦楠的博客
09-27 1万+
SET SET key value [EX seconds] [PX milliseconds] [NX|XX] 将字符串值 value 关联到 key 。 如果 key 已经持有其他值， SET 就覆写旧值，无视类型。 对于某个原本带有生存时间（TTL）的键来说， 当 SET 命令成功在这个键上执行时， 这个键原有的 TTL 将被清除。 可选参数 从 Redis 2.6.12 版本开始， SET...
Redis的SETNX的使用
lss0555的博客
12-06 5万+
一.介绍 在 Redis 里，所谓 SETNX，是「SET if Not eXists」的缩写，也就是只有不存在的时候才设置，可以利用它来实现锁的效果。 SETNX key value 将 key 的值设为 value ，当且仅当 key 不存在。 若给定的 key 已经存在，则 SETNX 不做任何动作。 二.选项命令 在SET命令中，有很多选项可用来修改命令的行为。 以下是SET命令可用选项的...
Redis中set、setex、setnx的用法和区别
李酒酒的博客
07-03 3万+
SET key value 含义： 将字符串值 value 关联到 key 。 如果 key 已经持有其他值， SET 就覆写旧值，无视类型。 SETEX key seconds value 该命令相当于将下面两行操作合并为一个原子操作 SET key value EXPIRE key seconds # 设置生存时间 含义（setex = set expire）： 将值 value 关联到 key ，并将 key 的生存时间...
Redis分布式锁/Redis的setnx命令如何设置key的失效时间（同时操作setnx和expire）
热门推荐
p7+的博客
05-30 6万+
Redis的setnx命令是当key不存在时设置key，但setnx不能同时完成expire设置失效时长，即不能保证setnx和expire的原子性。我们可以使用set命令完成setnx和expire的操作，并且这种操作是原子操作。 下面是set命令的可选项： set key value [EX seconds] [PX milliseconds] [NX|XX] EX seconds：设置失效时...
java中的树
weixin_38549608的博客
10-28 3041
参考资料：https://blog.csdn.net/u014106644/article/details/90174332； https://blog.csdn.net/qq_40722604/article/details/107792636； https://blog.csdn.net/a519640026/article/details/106940115； https://blog.csdn.net/qq_40722604/article/details/107792636； https:
【Java数据结构】树
最新发布
2303_77535762的博客
10-29 901
java集合框架：树
B树详细图解与Java完整实现
寂寞的博客
09-16 1万+
本文的目的是从B树的起源讲起，再到多种语言的实现，以达到对B树有一个全面的认识，如果你是一个正常的程序员，那么看完就应该可以实现一个B-Tree了（如果你已经会了，那么也不会看完）。 B树的起源 在1970年，Bayer＆McCreight发表的论文《ORGANIZATION AND MAINTENANCE OF LARGE ORDERED INDICES 》（大型有序索引的组织和维护）中提出...
B树的java实现
qq_29864971的博客
03-19 1555
1. B树基本概念      关于B树的基本概念、定义可以参考这篇博客：http://blog.csdn.net/kalikrick/article/details/27980007，本文侧重于B树的java代码实现。1.1 B树性质B树T有如下性质：      1. 每个节点x有如下属性：x.n表示节点当前key的个数。x中key满足：x.key1 &lt;= x.key2&lt;= x.key...
Redis中set、setnx、setex区别
梦想不会灭
04-06 1万+
Redis中set、setnx、setex区别1、SET2、SETEX3、SETNX4、GETSET 1、SET SET key value 含义： 将字符串值 value 关联到 key 。 如果 key 已经持有其他值， SET 就覆写旧值，无视类型。 2、SETEX SETEX key seconds value 含义： 将值 value 关联到 key ，并将 key 的生存时间设为 seconds (以秒为单位)。 如果 key 已经存在， SETEX 命令将覆写旧值。 返回值： 设置成功
java node类_【LeetCode】TreeNode类实现解析（java实现）
weixin_28848317的博客
02-12 1667
在LeetCode中，TreeNode是经常用到的一个结构体，表示数据结构树(Tree)中的一个节点。其官方定义如下：public class TreeNode {int val;TreeNode left;TreeNode right;TreeNode(int x) { val = x; }}123456在Tree的题目中，常会给出一些测试用例，用一些特定的格式来表示一棵树，如[3,9,20,n...
redis的过期时间
sjkcko的博客
05-26 2386
reids的过期时间设置
redis 失效时间单位是秒还是毫秒_redis设置过期时间
weixin_39685392的博客
12-20 1万+
一般主要包括4种处理过期方，其中expire都是以秒为单位，pexpire都是以毫秒为单位的。1 EXPIRE key seconds　　//将key的生存时间设置为ttl秒2 PEXPIRE key milliseconds　　//将key的生成时间设置为ttl毫秒3 EXPIREAT key timestamp　　//将key的过期时间设置为timestamp所代表的的秒数的时间戳4 PEXP...
redis分布式锁的这些坑，我怀疑你是假的开发
华为云官方博客
02-05 3832
摘要：用锁遇到过哪些问题？ 一、白话分布式 什么是分布式，用最简单的话来说，就是为了较低单个服务器的压力，将功能分布在不同的机器上面；就比如： 本来一个程序员可以完成一个项目：需求->设计->编码->测试 但是项目多的时候，一个人也扛不住，这就需要不同的人进行分工合作了 这就是一个简单的分布式协同工作了； 二、分布式锁 首先看一个问题，如果说某个环节被终止或者别侵占，就会发生不可知的事情 这就会出现，设计好的或者设计的半成品会被破坏，导致后面环节出错； 这时候
java学习笔记-二叉树的遍历
Blog
05-07 183
二叉树的遍历 前中后序遍历，层序遍历，广度优先，深度优先…… 递归方式、迭代方式实现…… 前序遍历-迭代实现 利用栈先进后出的特点，对每一个结点进行根左右顺序的访问。 栈对每个结点的操作是，将要操作的结点压栈，然后弹出时检查该结点是否有左右子结点，按照先右后左的顺序将子结点压栈，这样弹出的顺序就是根左右，右子结点在左子结点在前入栈。 PreOrder.java import java.util.Stack; /** * @Description: 根左右顺序遍历二叉树 * @author: Hardy
关于redis涉及的知识点，C语言如何操作redis
m0_37322399的博客
09-17 995
关于redis涉及的知识点，C语言如何操作redis
这可能是最中肯的Redis规范了
程序员小乐
09-30 960
点击上方 "程序员小乐"关注,星标或置顶一起成长每天凌晨00点00分,第一时间与你相约每日英文Smile can be given to anyone. Bu...
redisson锁相关源码
qq_25582465的博客
10-27 590
1、redisson加锁源码理解 ​   redisson先获取RLock对象，调用lock、tryLock方法来完成加锁的功能 ​   lock方法是直接加锁，如果锁已被占用，则直接线程阻塞，进行等待，直到锁被占用方释放。   tryLock方法则是设定了waitTime（等待时间），在这个等待时间没到前，也是线程阻塞并反复去获取锁，直到取到锁或等待时间超时，则返回false 2、加锁    1、LOCK加锁 /** * 加锁操作 （设置锁的有效时间） * @param lockName 锁名称
list转换成string字符串_Redis五大基本数据类型之String
weixin_39609071的博客
12-03 551
Redis五大基本Value数据结构类型: String，List，Hash，Set，ZSet1:String String 是Redis 里面最简单的一种数据结构。在Redis中，所有的Key都是字符串，存储对象时也是需要进行序列化操作，但是不同的key对应的value则具备不同的数据结构，我们所说的五种不同的数据结构主要指的时value 的数据类型不同Redis 中的字符串时动态字...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值