java实现判断是否为二叉搜索树

最新推荐文章于 2024-04-17 10:42:18 发布
最新推荐文章于 2024-04-17 10:42:18 发布
阅读量1.4k 收藏 9
点赞数
分类专栏： # 递归 # 树 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45986454/article/details/109840767
版权
数据结构 同时被 3 个专栏收录
37 篇文章 0 订阅
订阅专栏
树
24 篇文章 0 订阅
订阅专栏
递归
23 篇文章 0 订阅
订阅专栏

标题:java实现判断是否为二叉搜索树

一、分析
1）第一种：
对于二叉搜索树，首先想到的的是中序遍历，得到的是一个有序序列。
所以方法可以是使用中序的递归，非递归进行实现，只要看是否为有序即可。

  • 方法一：中序非递归遍历，保存最小值为long cur = Long.MIN_VALUE;每次遍历得到一个节点的值时，比较是否大于当前最小值cur，满足条件则更新当前最小值。
/**
	 * 使用非递归实现  迭代版的【非递归中序遍历】，简单，容易实现
	 * 执行用时：2 ms, 在所有 Java 提交中击败了31.16% 的用户
内存消耗：37.9 MB, 在所有 Java 提交中击败了94.63% 的用户
	 */
	public boolean isBst02(TreeNode head) {
		if(head == null) {
			return true;
		}
		Deque<TreeNode> s = new LinkedList<>();
		s.push(head);
		long cur = Long.MIN_VALUE;
		
		while(!s.isEmpty()) {
			TreeNode node = s.peek();
			if(node.left != null) {
				s.push(node.left);
			}else {
				node = s.pop();
				System.out.print(node.val + " ");
				//判断node是否 > cur
				if(node.val <= cur) {
					return false;
				}
				cur = node.val;
				
				while(node.right == null && !s.isEmpty()) {
					node = s.pop();
					System.out.print(node.val + " ");
					
					//判断node是否 > cur
					if(node.val <= cur) {
						return false;
					}
					cur = node.val;
				}
				if(node.right != null) {
					s.push(node.right);
				}else {
					break;
				}
			}
		}
		
		return true;
	}
  • 方法二：中序递归遍历：实现一，中序遍历后，将得到的节点存到list中，通过for循环进行遍历list，判断是否为有序的【即总是有后面一个小于前面一个节点的值】
/**
	 * 使用中序遍历 存到list中，再比较  【简单】
	 * 执行用时：2 ms, 在所有 Java 提交中击败了31.16% 的用户
内存消耗：38.2 MB, 在所有 Java 提交中击败了79.34% 的用户
	 */
	public boolean isBst03(TreeNode head, List<Integer> list) {
		for(int i = 1; i < list.size(); i++) {
			if(list.get(i) <= list.get(i - 1)) {
				return false;
			}
		}
		
		return true;
	}
/**
	 * 中序遍历
	 */
	public void inOrder(TreeNode head, List<Integer> list) {
		if(head == null) {
			return ;
		}else {
			this.inOrder(head.left, list);
			System.out.print(head.val + " ");
			list.add(head.val);
			this.inOrder(head.right, list);
		}
	}
  • 实现三：对中序递归遍历的升级版，使用一个对象保存当前已遍历到的节点的最小值【使用一个内部类，创建一个对象 new Cur(Long.MIN_VALUE))】，递归遍历完左边节点回退的时候【中序遍历的思想：递归遍历完左边节点回退时，System.out.print(node.val);】，取得当前节点的值，若小于当前最小值，则更新最小值，否则，说明不是有序的，return false；使用对象保存当前节点的最小值，是因为这样的话，递归回退的时候，最小值不会改变（类似 传递参数时count + 1 【count不会变】 与 count ++【count会改变】的差别）
class Cur{
		long cur;
		public Cur(long cur) {
			this.cur = cur;
		}
	}
	/**
	 * 因为二叉搜索树，中序遍历得到的是有序序列，
	 * 所以 使用中序遍历，每次比较node节点之间的最小值  与 node，即：cur min【保存node节点之前的最小值】 < node  
	 * 执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户
内存消耗：38.1 MB, 在所有 Java 提交中击败了84.19% 的用户
	 * @param head
	 * @param cur_min
	 * @return
	 */
	public boolean isBst(TreeNode head, Cur cur_min) {
		if(head == null) {
			return true;
		}else {
			boolean b1 = this.isBst(head.left, cur_min);
			if(!b1) {
				return false;
			}
			if(head.val <= cur_min.cur) {
				return false;
			}
			cur_min.cur = head.val;
			boolean b2 = this.isBst(head.right, cur_min);
			if(!b1 || !b2) {
				return false;
			}
			
			return true;
		}
	}
  • 实现四：使用一个成员变量指向当前最小值的节点，思想和上面的实现二 一样，使得递归回退的时候，最小值不会改变。
/**
	 * 参考
	 * 注意TreeNode p;为一个成员变量
	 * 这样下面的程序才可以改变p
	 * 执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户
内存消耗：38 MB, 在所有 Java 提交中击败了89.36% 的用户
	 * @param head
	 * @param cur_min
	 * @return
	 */
	TreeNode p;  //将这个p设置为成员遍历才行，这样下面的程序才可以改变p，不然随着函数的退回，p的值又回到了原来，所以这个的p不能作为形参，而是成员变量
	public boolean isBst011(TreeNode head) {
		if(head == null) {
			return true;
		}else {
			boolean b1 = this.isBst011(head.left);
			if(!b1) {
				return false;
			}
			if(p != null && head.val <= p.val) {
				return false;
			}
			p = head;
			boolean b2 = this.isBst011(head.right);
			if(!b1 || !b2) {
				return false;
			}
			
			return true;
		}
		
	}

2）第二种：
使用先序递归遍历：每次遍历的时候，使得 XXX < node.val < YYY

  • 实现一：每次遍历节点的时候，要求node满足 left最大值 < node.val < right最小值
/**
	 * 方法二：  【可以看看对称（镜像）二叉树的思想】
	 * 使用递归求解
	 * 执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户
	内存消耗：38.2 MB, 在所有 Java 提交中击败了87.07% 的用户
	 */
	public boolean isBst03(TreeNode node) {
		if(node == null) {
			return true;
		}else {					//理论上 why：因为后面的多次重复过程，											
			if(node.left != null) {
				int max = this.rightMax(node.left);//左边节点的理论上（node.left一直向右）的最大值 < 该节点
				if(max >= node.val) {
					return false;
				}
			}
			if(node.right != null) {
				int min = this.leftMin(node.right);右边节点的理论上（node.right一直向左）的最小值 > 该节点
				if(min <= node.val) {
					return false;
				}
			}
			boolean res1 = this.isBst03(node.left);
			boolean res2 = this.isBst03(node.right);
			
			return res1 && res2;
		}
		
	}
	/**
	 * 寻找node节点理论上的最大值  找到node节点的最右边的值
	 * @param node
	 * @return
	 */
	public int rightMax(TreeNode node) {
		while(node.right != null) {
			node = node.right;
		}
		return node.val;
	}
	/**
	 * 寻找node节点理论上的最小值  找到node节点的最左边的值
	 * @param node
	 * @return
	 */
	public int leftMin(TreeNode node) {
		while(node.left != null) {
			node = node.left;
		}
		return node.val;
	}
  • 实现二：每次遍历节点的时候，要求node满足 node.left.val < node.val < node.right.val 同时 node.left.val > min && node.right.val < max
/**
	 * 注意：这个题目可以补全二叉树来做，得到 头结点上面的     min，max
	 * min < left < node.val < right < max
	 * 使用[先序遍历]
	 * 每次使node.val > left && node.val < right
	 * 同时left > min && right < max
	 * 
	 * 递归
	 */
	public boolean isBst03(TreeNode head, long max, long min) {
		if(head == null) {
			return true;
		}else {
			if(head.left != null) {//节点head 左边的值 < head.val ,  同时要 > min
				if(head.left.val >= head.val || head.left.val <= min) {
//					System.out.println("left:");
//					System.out.println(" head.val:" + head.val + " head.left.val:" + head.left.val + " min:" + min);					
					return false;
				}
			}
			if(head.right != null) { //节点head 右边的值 > head.val, 同时要 < max
				if(head.right.val <= head.val || head.right.val >= max) {
//					System.out.println("right;");
//					System.out.println(" head.val:" + head.val + " head.right.val:" + head.right.val + " max:" + max);
					return false;
				}
			}
			boolean b1 = this.isBst03(head.left, head.val, min);  //head.val
			min = head.val;
			boolean b2 = this.isBst03(head.right, max, min);
			
			return b1 && b2;
		}
		
	}
	
	/**
	 * 上面的简化
	 * 执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户
内存消耗：37.9 MB, 在所有 Java 提交中击败了94.21% 的用户
	 * @param head
	 * @return
	 */
	public boolean isValidBST02(TreeNode head) {
        return this.isBst03(head, Long.MAX_VALUE, Long.MIN_VALUE);
    }
  • 实现三：类似实现二的简化版，每次遍历节点的时候，要求node满足 min < node.val < max
/**
	 * 使用参考 思想，类似上面的
	 * 使用先序遍历
	 * min < node.val < max
	 * 执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户
		内存消耗：38.2 MB, 在所有 Java 提交中击败了77.43% 的用户
	 */
	public boolean isBst04(TreeNode head, long max, long min) {
		if(head == null) {
			return true;
		}else {
			if(head.val >= max || head.val <= min) {
				return false;
			}
			
			boolean b1 = this.isBst04(head.left, head.val, min);
			boolean b2 = this.isBst04(head.right, max, head.val);
			
			return b1 && b2;
			
		}
	}
	public boolean isValidBST03(TreeNode head) {
        return this.isBst04(head, Long.MAX_VALUE, Long.MIN_VALUE);
    }

那么实现二，实现三的min, max怎么确定呢？，见下图

  • 补全二叉树，找到min,max的规律【可以看看几个节点，进而确定】

在这里插入图片描述

完整实例代码如下；

/**
 * 判断是否为二叉搜索树：
 * 重点：其一：补全了二叉树的图，得到head的  max, min
 * 其二：可以使用成员遍历，及时保存最新的 最小值，不需要传递参数了  
 * --> 我之前的做法是使用一个内部类，传递参数实现  【一个对象】
 * 
 * @author dell
 *
 */
public class TestIsBst {
	
	class Cur{
		long cur;
		public Cur(long cur) {
			this.cur = cur;
		}
	}
	/**
	 * 因为二叉搜索树，中序遍历得到的是有序序列，
	 * 所以 使用中序遍历，每次比较node节点之间的最小值  与 node，即：cur min【保存node节点之前的最小值】 < node  
	 * 执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户
内存消耗：38.1 MB, 在所有 Java 提交中击败了84.19% 的用户
	 * @param head
	 * @param cur_min
	 * @return
	 */
	public boolean isBst(TreeNode head, Cur cur_min) {
		if(head == null) {
			return true;
		}else {
			boolean b1 = this.isBst(head.left, cur_min);
			if(!b1) {
				return false;
			}
			if(head.val <= cur_min.cur) {
				return false;
			}
			cur_min.cur = head.val;
			boolean b2 = this.isBst(head.right, cur_min);
			if(!b1 || !b2) {
				return false;
			}
			
			return true;
		}
	}
	
	/**
	 * 参考
	 * 注意TreeNode p;为一个成员变量
	 * 这样下面的程序才可以改变p
	 * 执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户
内存消耗：38 MB, 在所有 Java 提交中击败了89.36% 的用户
	 * @param head
	 * @param cur_min
	 * @return
	 */
	TreeNode p;  //将这个p设置为成员遍历才行，这样下面的程序才可以改变p，不然随着函数的退回，p的值又回到了原来，所以这个的p不能作为形参，而是成员变量
	public boolean isBst011(TreeNode head) {
		if(head == null) {
			return true;
		}else {
			boolean b1 = this.isBst011(head.left);
			if(!b1) {
				return false;
			}
			if(p != null && head.val <= p.val) {
				return false;
			}
			p = head;
			boolean b2 = this.isBst011(head.right);
			if(!b1 || !b2) {
				return false;
			}
			
			return true;
		}
		
	}
	
	/**
	 * 使用非递归实现  迭代版的【非递归中序遍历】，简单，容易实现
	 * 执行用时：2 ms, 在所有 Java 提交中击败了31.16% 的用户
内存消耗：37.9 MB, 在所有 Java 提交中击败了94.63% 的用户
	 */
	public boolean isBst02(TreeNode head) {
		if(head == null) {
			return true;
		}
		Deque<TreeNode> s = new LinkedList<>();
		s.push(head);
		long cur = Long.MIN_VALUE;
		
		while(!s.isEmpty()) {
			TreeNode node = s.peek();
			if(node.left != null) {
				s.push(node.left);
			}else {
				node = s.pop();
				System.out.print(node.val + " ");
				//判断node是否 > cur
				if(node.val <= cur) {
					return false;
				}
				cur = node.val;
				
				while(node.right == null && !s.isEmpty()) {
					node = s.pop();
					System.out.print(node.val + " ");
					
					//判断node是否 > cur
					if(node.val <= cur) {
						return false;
					}
					cur = node.val;
				}
				if(node.right != null) {
					s.push(node.right);
				}else {
					break;
				}
			}
		}
		
		return true;
	}
	
	/**
	 * 使用中序遍历 存到list中，再比较  【简单】
	 * 执行用时：2 ms, 在所有 Java 提交中击败了31.16% 的用户
内存消耗：38.2 MB, 在所有 Java 提交中击败了79.34% 的用户
	 */
	public boolean isBst03(TreeNode head, List<Integer> list) {
		for(int i = 1; i < list.size(); i++) {
			if(list.get(i) <= list.get(i - 1)) {
				return false;
			}
		}
		
		return true;
	}
	
	/**
	 * 注意：这个题目可以补全二叉树来做，得到 头结点上面的     min，max
	 * min < left < node.val < right < max
	 * 使用[先序遍历]
	 * 每次使node.val > left && node.val < right
	 * 同时left > min && right < max
	 * 
	 * 递归
	 */
	public boolean isBst03(TreeNode head, long max, long min) {
		if(head == null) {
			return true;
		}else {
			if(head.left != null) {//节点head 左边的值 < head.val ,  同时要 > min
				if(head.left.val >= head.val || head.left.val <= min) {
//					System.out.println("left:");
//					System.out.println(" head.val:" + head.val + " head.left.val:" + head.left.val + " min:" + min);					
					return false;
				}
			}
			if(head.right != null) { //节点head 右边的值 > head.val, 同时要 < max
				if(head.right.val <= head.val || head.right.val >= max) {
//					System.out.println("right;");
//					System.out.println(" head.val:" + head.val + " head.right.val:" + head.right.val + " max:" + max);
					return false;
				}
			}
			boolean b1 = this.isBst03(head.left, head.val, min);  //head.val
			min = head.val;
			boolean b2 = this.isBst03(head.right, max, min);
			
			return b1 && b2;
		}
		
	}
	/**调用上面
	 * 执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户
内存消耗：38 MB, 在所有 Java 提交中击败了87.61% 的用户
	 * @param head
	 * @return
	 */
	public boolean isValidBST(TreeNode head) {
        if(head == null) {
			return true;
		}

        if(head.left != null && head.left.val >= head.val) {			
                return false;
            }
        if(head.right != null && head.right.val <= head.val) {
                return false;
        }

        //得到最小值
        long min = -1;
        TreeNode p = head;
        while(p.left != null){
            p = p.left;
        }
        min = p.val - 1L;  //注意是 -1L
//        System.out.println("min:" + (min + 1));
        return this.isBst03(head, Long.MAX_VALUE, min);
    }
	
	/**
	 * 上面的简化
	 * 执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户
内存消耗：37.9 MB, 在所有 Java 提交中击败了94.21% 的用户
	 * @param head
	 * @return
	 */
	public boolean isValidBST02(TreeNode head) {
        return this.isBst03(head, Long.MAX_VALUE, Long.MIN_VALUE);
    }
	
	/**
	 * 使用参考 思想，类似上面的
	 * 使用先序遍历
	 * min < node.val < max
	 * 执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户
		内存消耗：38.2 MB, 在所有 Java 提交中击败了77.43% 的用户
	 */
	public boolean isBst04(TreeNode head, long max, long min) {
		if(head == null) {
			return true;
		}else {
			if(head.val >= max || head.val <= min) {
				return false;
			}
			
			boolean b1 = this.isBst04(head.left, head.val, min);
			boolean b2 = this.isBst04(head.right, max, head.val);
			
			return b1 && b2;
			
		}
	}
	public boolean isValidBST03(TreeNode head) {
        return this.isBst04(head, Long.MAX_VALUE, Long.MIN_VALUE);
    }
	
	
	/**
	 * 初始化一个tree
	 * 类广度遍历
	 * @param a
	 * @return
	 */
	public TreeNode initTree(Integer[] a) {
		if(a == null || a.length == 0) {
			return null;
		}
		
		int t = 0;
		TreeNode p = new TreeNode(a[t]);  //至少有一个元素
		Queue<TreeNode> q = new LinkedList<>();
		q.offer(p);
		
		while(!q.isEmpty()) {
			TreeNode node = q.poll();
			if(t + 1 == a.length) {  //先判断数组中是否还有下一个元素
				return p;
			}else {
				t++;
				if(a[t] == null) {  //若下一个元素为null，则不需要创建新的节点
					node.left = null;
				}else {
					node.left = new TreeNode(a[t]);
					q.offer(node.left);
				}
			}
			if(t + 1 == a.length) {
				return p;
			}else {
				t++;
				if(a[t] != null){  //上面的简写，a[t] == null，不需要再赋值
					node.right = new TreeNode(a[t]);
					q.offer(node.right);
				}
			}
		}
		
		return p;
	}
	
	@Test
	public void test() {
//		Integer[] a = new Integer[] {1, 2, 3, 4, 5, 9, 10, null, 6, 7, 8, null, null, null, 11};
//		Integer[] a = new Integer[] {3, 9, 20, 16, 17, 15, 7, null, null, null, 18, null, null, null, null, 19, null};
//		Integer[] a = new Integer[] {6, 2, 8, 0, 4, 7, 9, null, null,3, 5};
		Integer[] a = new Integer[] {1, 1};
//		Integer[] a = new Integer[] {10,5,15,null,null,6,20};
//		Integer[] a = new Integer[] {3, 1, 5, 0, 2, 4, 6};
//		Integer[] a = new Integer[] {2147483647,-2147483648};
		
		TreeNode head = this.initTree(a);
		
		System.out.println("输出中序遍历：");
		List<Integer> list = new ArrayList<>();
		this.inOrder(head, list);
		System.out.println();
		
		System.out.println("使用递归实现");
		System.out.println(this.isBst(head, new Cur(Long.MIN_VALUE)));
		
		System.out.println("使用迭代实现，中序遍历非递归：");
		System.out.println(this.isBst02(head));
		
		System.out.println("使用中序遍历，将值存到list中");
		System.out.println(this.isBst03(head, list));
		
		System.out.println("递归： min < left < node.val < right < max：");
		System.out.println(this.isValidBST(head));
		
		System.out.println("递归：min < node.val < max：");
		System.out.println(this.isValidBST03(head));
		
		System.out.println("递归：参考：");
		System.out.println(this.isBst011(head));
		
		
	}
	/**
	 * 中序遍历
	 */
	public void inOrder(TreeNode head, List<Integer> list) {
		if(head == null) {
			return ;
		}else {
			this.inOrder(head.left, list);
			System.out.print(head.val + " ");
			list.add(head.val);
			this.inOrder(head.right, list);
		}
	}
jay编程
关注
  • 0
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
搜索二叉树的判断（java）
weixin_51713937的博客
01-24 853
1、特点 1、搜索树——左结点的value都是小于头结点的，右结点的value都是大于头结点的。 2、搜索树——中序遍历是升序排序的。 2、方法主体 1、中序遍历时——中间是打印，如今可以换成判定条件 2、判定条件——因为中序遍历时是升序的，所以，当前节点的value值是大于上一个节点的value值的——所以只用判断这两个节点值即可。 3、比较方法——这时我们可以定义一个全局变量保存上一个节点值——因为递归函数没每次都会从头出发——所以应该定义一个在方法外的变量来保存上一个节点值。 4、判断结果——当
检查一颗二叉树是否为二叉查找树BST（Java实现）
qq_39155901的博客
07-09 509
给一个二叉树的root结点，判断该结点是否是BST。即要判断该树的所有结点是否满足以下性质：所有结点的左孩子都比它小，右孩子都比它大。遍历所有结点，判断是否满足左小右大的性质即可。 3.2 递归实现 3.2.1 代码逻辑 判断一个结点的左结点是否比它小，右结点是否比它大，如果均符合要求，那么继续判断左结点的左右结点、右结点的左右结点…直到结点为叶子结点。 3.3 循环实现 3.3.1 代码逻辑 核心逻辑与递归实现一样，但是循环实现过程比递归要复杂一点，需要通过一个栈结构来完成树的遍历。栈结构遍历树的具体过程
Java实现二叉搜索树
最新发布
枫飘长安的博客
04-17 605
Java实现二叉搜索树
Java 验证二叉搜索树
weixin_53545457的博客
02-09 425
验证二叉搜索树中等给你一个二叉树的根节点root，判断其是否是一个有效的二叉搜索树。有效二叉搜索树定义如下：节点的左子树只包含小于当前节点的数。节点的右子树只包含大于当前节点的数。所有左子树和右子树自身必须也是二叉搜索树。示例 1：输入：输出：true示例 2：输入：输出：false解释：根节点的值是 5 ，但是右子节点的值是 4。
java实现二叉搜索树
weixin_43510522的博客
04-22 249
二、二叉搜素树 二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。 构建二叉树 class Node{ int key; int valu...
笔试面试算法经典--判断二叉树是否是平衡二叉树（Java）
onway_goahead的博客
01-21 1481
平衡二叉树（Balanced Binary Tree）又被称为AVL树，且具有以下性质：它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。如下面的三棵树：只有中间才是平衡二叉树。  解法：  思路1：从根节点开始，求出根的左右子树的高度，如果根的左右子树的高度差大于1，返回FALSE，否则递归的判断根的左子树和右子树是否满足条件。 class Tr...
java实现 二叉搜索树功能
08-27
Java 实现二叉搜索树功能 二叉搜索树是一种特殊的二叉树，它的每个节点都含有一个Comparable的键值，且所有的键值都是唯一的，节点的键值也可以是基本类型，如int、long等，也可以是自定义的对象类型，只要实现了...
Java删除二叉搜索树最大元素和最小元素的方法详解
08-19
Java删除二叉搜索树最大元素和最小元素的方法详解主要介绍了Java删除二叉搜索树最大元素和最小元素的方法，结合实例形式详细分析了java针对二叉搜索树的基本遍历、查找、判断、删除等相关操作技巧。 一、查询操作 ...
Java实现二叉排序树
09-02
二叉排序树（Binary Sort Tree，BST），也称为二叉搜索树，是一种特殊的二叉树数据结构，它的每个节点都包含一个键（key）、一个关联的值、一个指向左子节点的指针和一个指向右子节点的指针。在二叉排序树中，对于...
JAVA判断二叉树是否是二叉平衡树
04-15
在本篇博客中，我们将深入探讨如何判断一个给定的二叉树是否为二叉平衡树，以及通过`BinaryTree.java`文件来实现这一功能。 首先，我们需要理解二叉树的基本概念。二叉树是由节点构成的，每个节点最多有两个子节点...
Java基于二叉查找树实现排序功能示例
08-29
Java基于二叉查找树实现排序功能示例 本文主要介绍了Java基于二叉查找树实现排序功能的示例，通过实例形式分析了Java二叉查找树的定义、遍历及排序等相关操作技巧。下面将对这些知识点进行详细的解释和分析。 一、...
判断一个二叉树是否是对称二叉树（ Java）
一滴水，一缕光
08-30 3999
请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。 思路：首先根节点以及其左右子树，左子树的左子树和右子树的右子树相同，左子树的右子树和右子树的左子树相同即可，采用递归，另外非递归也可，采用栈或队列存取各级子树根节点。 方法一 package lastfifteen; public class treeSymmetrical {...
Java 判断是否为二叉搜索树，完全二叉树！
weixin_44340573的博客
10-25 300
二叉搜索树 public boolean isSearchTree(TreeNode root,int min, int max){ if(root == null){ return true; } if(root.val <= min || root.val >= max){ return false; }else{ return isSearchTree.
Java二叉查找树最简单实现
日积月累，天道酬勤
04-12 1068
什么是二叉树 简单来说，二叉树首先是一棵树，然后有以下条件 每个节点最多有2个孩子节点 二叉树有 一个根节点 一个左子树(可能为空) 一个右子树(可能为空) 特例 完全二叉树 叶节点只能出现在最下层和次下层，并且最下面一层的结点都集中在该层最左边的若干位置的二叉树 满二叉树 一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树...
Java---判断一棵树是否为二叉查找树BST
shall潇の菜园
03-04 500
Java—判断一棵树是否为二叉查找树BST 思路：对于一棵二叉树，最简单的方法就是中序遍历，看是不是一个递增数列，如果是，则是一棵二叉搜索树，如果不是，则不是二叉搜索树。在这里用一个lastVisit去记录上一次搜索的节点。这个过程就是先找到最左下角的节点，更新lastVisit为这个节点的值，然后按照中序遍历依次更新即可。 代码实现： /** * @Author shall潇 * @Date 2021/3/4 * @Description */ public class BinaryTree {
java实现，二叉搜索树(过程非常详细)
fengxiandada的博客
03-25 3362
java实现二叉搜索树
java 判断一颗二叉树是否是搜索二叉树和完全二叉树
白纸
01-23 449
牛客链接 1. 题目考点 搜索二叉树定义 搜素二叉树的判定（性质） 二叉树的中序遍历 完全二叉树定义 完全二叉树的判定（性质） 二叉树的层次遍历 2. 考点解析 搜索二叉树（又叫二叉排序树、二叉查找树、二叉搜索树）的定义： 空树是搜索二叉树 若左子树不为空，左子树的根节点关键字 < 根节点关键字 若右子树不为空，右子树的根节点关键字 > 根节点关键字 左右子树是搜锁二叉树 搜索二叉树的判定：中序遍历搜索二叉树是一个升序序列 public boolean inOrder(TreeNo
判断一颗树是否为二叉搜索树
njuptsxd的专栏
05-22 2375
10 / \ 5 15 -------- binary tree (1) / \ 6 20
判断给定的二叉树是否为二叉排序树
热门推荐
fguihbfg的博客
11-12 2万+
判断给定的二叉树是否为二叉排序树
二叉搜索树的后续遍历序列java
08-05
在给定的代码中，使用了递归的方式来判断一个给定的序列是否是二叉搜索树的后续遍历序列。判断的过程如下： 1. 首先判断序列的长度，如果长度为0，则返回false；如果长度为1，则返回true。 2. 获取序列的最后一个元素作为根节点。 3.从序列的开头开始遍历，找到第一个大于等于根节点的元素的位置i，那么i左侧的元素是根节点的左子树，i右侧的元素是根节点的右子树。 4. 判断右子树中是否有小于根节点的元素，如果有，则返回false；否则，递归判断左子树和右子树是否分别是二叉搜索树的后续遍历序列。 5. 如果左子树和右子树都是二叉搜索树的后续遍历序列，则返回true；否则，返回false。 所以，可以根据给定的代码来判断一个给定的序列是否是二叉搜索树的后续遍历序列。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值