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

最新推荐文章于 2023-08-28 15:47:21 发布
最新推荐文章于 2023-08-28 15:47:21 发布
阅读量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)
LrvingTc的博客
03-16 3888
题目描述 给定一个二叉树，判断它是否是一个有效的二叉搜索树(BST)。 假设BST定义如下: 节点的左子树只包含键值小于节点键值的节点。 节点的右子树只包含键值大于节点键值的节点。 左子树和右子树也必须是二叉搜索树。 解决 代码： public boolean isValidBST(TreeNode root) { if (root == null) return true; St...
LeetCode98. 验证二叉搜索树(java)
inferno_devil的博客
04-22 626
题目： 给定一个二叉树，判断其是否是一个有效的二叉搜索树。 假设一个二叉搜索树具有如下特征： 节点的左子树只包含小于当前节点的数。 节点的右子树只包含大于当前节点的数。 所有左子树和右子树自身必须也是二叉搜索树。 示例： 代码： 解法一 /** * Definition for a binary tree node. * public class TreeNode { * in...
判断是否是完全二叉树(JAVA)
Yves_J的博客
11-04 6383
判断完全二叉树-JAVA 判断一个树是否属于完全二叉树可以从以下2个条件来判断： -层次遍历二叉树 1 任何一个结点如果右孩子不为空，左孩子却是空，则一定不是完全二叉树 2 当一个结点出现右孩子为空时候，判断该结点的层次遍历后继结点是否为叶子节点，如果全部都是叶子节点，则是完全二叉树，如果存在任何一个结点不是叶节点，则一定不是完全二叉树。 class Tree{ int value; Tr...
java数据结构与算法之判断是否是二叉搜索树
wenpan的博客
05-11 553
一、什么是二叉搜索树 一棵二叉树中，对于所有的子树，他的左边节点一定比他小，右边节点一定比他大。这样的树就叫做二叉搜索树。 如何判断一棵树是否是二叉搜索树？ 方式一：直接通过树的中序遍历，搜索二叉树使用中序遍历出来的结果一定是升序的。 方式二：可以根据二叉树的通用求解方法来求解。 每个节点都可以向他的左右孩子要结果。 一棵二叉搜索树的每个节点形成的子树都应该满足二叉搜索树的定义。所以我们对于每个子树都向他的左右孩子要结果，当所有的子树都是二叉搜索树时，整棵树就是二叉搜索树。 二、解法 方式一、通过中序遍
给定一个二叉树，判断其是否是一个有效的二叉搜索树。Java实现
我的梦境传说
06-24 1301
import java.util.LinkedList; import java.util.Stack; /** * 验证一个二叉树是否是二叉搜索树 */ public class ValidateBinarySearchTree { /** * 根据中序遍历的结果来判断是否是二叉搜索树 * @param list * @return */ public static boolean isValidate(LinkedList<Inte.
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实现 二叉搜索树功能
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分别判断一颗二叉树是否为搜索二叉树和完全二叉树
luzhensmart的专栏
01-14 542
题目描述 给定一棵二叉树，已经其中没有重复值的节点，请判断该二叉树是否为搜索二叉树和完全二叉树。 示例1 输入 {2,1,3} 返回值 [true,true] import java.util.*; /* * public class TreeNode { * int val = 0; * TreeNode left = null; * TreeNode right = null; * } */ public class Solution { /*
java判断一颗树是不是完全二叉树
baixian110的博客
06-02 170
给定一个二叉树的头结点TreeNode root，要求返回true或者false。完全二叉树的定义就不说了，那么我们如何判断一颗树是普通树还是完全二叉树呢。实际就是用层序遍历的思想。
判断二叉树是否为二叉搜索树（C语言）
最新发布
sskdspdl的博客
08-28 800
C语言判断树是否为二叉搜索树
Java实现判断一棵树是否为BST二叉搜索树
weixin_45986454的博客
12-06 952
标题：Java实现判断一棵树是否为BST二叉搜索树 题目：判断是否为二叉搜索树 98. 验证二叉搜索树 给定一个二叉树，判断其是否是一个有效的二叉搜索树。 假设一个二叉搜索树具有如下特征： 节点的左子树只包含小于当前节点的数。 节点的右子树只包含大于当前节点的数。 所有左子树和右子树自身必须也是二叉搜索树。 示例 1: 输入: 2 / \ 1 3 输出: true 示例 2: 输入: 5 / \ 1 4 / \
搜索二叉树的判断（java）
weixin_51713937的博客
01-24 853
1、特点 1、搜索树——左结点的value都是小于头结点的，右结点的value都是大于头结点的。 2、搜索树——中序遍历是升序排序的。 2、方法主体 1、中序遍历时——中间是打印，如今可以换成判定条件 2、判定条件——因为中序遍历时是升序的，所以，当前节点的value值是大于上一个节点的value值的——所以只用判断这两个节点值即可。 3、比较方法——这时我们可以定义一个全局变量保存上一个节点值——因为递归函数没每次都会从头出发——所以应该定义一个在方法外的变量来保存上一个节点值。 4、判断结果——当
检查一颗二叉树是否为二叉查找树BST（Java实现）
qq_39155901的博客
07-09 511
给一个二叉树的root结点，判断该结点是否是BST。即要判断该树的所有结点是否满足以下性质：所有结点的左孩子都比它小，右孩子都比它大。遍历所有结点，判断是否满足左小右大的性质即可。 3.2 递归实现 3.2.1 代码逻辑 判断一个结点的左结点是否比它小，右结点是否比它大，如果均符合要求，那么继续判断左结点的左右结点、右结点的左右结点…直到结点为叶子结点。 3.3 循环实现 3.3.1 代码逻辑 核心逻辑与递归实现一样，但是循环实现过程比递归要复杂一点，需要通过一个栈结构来完成树的遍历。栈结构遍历树的具体过程
Java 验证二叉搜索树
weixin_53545457的博客
02-09 427
验证二叉搜索树中等给你一个二叉树的根节点root，判断其是否是一个有效的二叉搜索树。有效二叉搜索树定义如下：节点的左子树只包含小于当前节点的数。节点的右子树只包含大于当前节点的数。所有左子树和右子树自身必须也是二叉搜索树。示例 1：输入：输出：true示例 2：输入：输出：false解释：根节点的值是 5 ，但是右子节点的值是 4。
java实现二叉搜索树
weixin_43510522的博客
04-22 251
二、二叉搜素树 二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。 构建二叉树 class Node{ int key; int valu...
Java实现：二叉搜索树与单链表算法解析
本文将深入探讨树形动态规划和单链表算法，特别是如何判断一棵树是否为二叉搜索树（BST）以及如何对单链表进行快速排序（QuickSort）。 首先，我们来看树形动态规划。动态规划是一种将复杂问题分解为子问题并存储子...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值