算法 （十四）二叉树：判断一颗二叉树是不是平衡/搜索二叉树

1、判断一颗二叉树是不是平衡/搜索/完全二叉树

平衡二叉树： 它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

搜索二叉树：它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；

判断是是否平衡二叉树：用递归，遍历每一个节点，自定义一个返回类型，包括是不是平衡树和数的高度

1. 如果左子树不是平衡二叉树，直接返false
2. 如果右子树不是平衡二叉树，直接返false
3. 如果左右子树都是平衡二叉树，单数左右字数高度大于1，返false
4. 其他，返回true

package cn.nupt;

/**
 * @Description: 判断一个二叉树是否是平衡二叉树 平衡二叉树：是一
 *               棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树
 * @author PizAn
 * @Email [email protected]
 * @date 2019年3月4日 下午6:15:48
 * 
 */
public class IsBalancedTree {

	// 我们这里用递归做，每一个点都递归到，每一个点作为头节点返回它是不是平衡二叉树和它的高度，这里自定义一个返回类型

	// 定义二叉树
	public static class Node {
		private Node left;
		private Node right;
		private Integer value;

		public Node(Integer value) {
			this.value = value;
		}
	}

	// 这里我们定义一个返回类型的自建类
	public static class ReturnType {

		private boolean isBalance; // 是否是平衡二叉树
		private int height; // 以这棵树为头节点的二叉树的高度

		public ReturnType(boolean isBalance, int height) {
			this.isBalance = isBalance;
			this.height = height;
		}

	}

	public static ReturnType isBalanceTree(Node head) {
		if (head == null) {
			return new ReturnType(true, 0);
		}

		Node left = head.left;
		Node right = head.right;

		ReturnType returnLeft = isBalanceTree(left);
		// 如果左子树不是平衡二叉树，直接返空
		if (!returnLeft.isBalance) {
			return new ReturnType(false, 0);
		}

		ReturnType returnRight = isBalanceTree(right);
		// 如果右子树不是平衡二叉树，直接返空
		if (!returnRight.isBalance) {
			return new ReturnType(false, 0);
		}

		// 如果左右子树都是平衡二叉树，单数左右字数高度大于1，返空
		if (Math.abs(returnLeft.height - returnRight.height) > 1) {
			return new ReturnType(false, 0);
		}

		return new ReturnType(true, Math.max(returnLeft.height, returnRight.height) + 1);
	}
	
	
	public static void main(String[] args) {
		Node head = new Node(1);
		head.left = new Node(2);
		head.right = new Node(3);
		head.left.left = new Node(4);
		head.left.right = new Node(5);
		head.right.left = new Node(6);
		head.right.right = new Node(7);
		head.right.right.right = new Node(8);
		head.right.right.right.right = new Node(9);
	
		System.out.println(isBalanceTree(head).isBalance);

	}

}

判断是否为搜索二叉树：改一下中序遍历，存储前一个节点的值，在打印的地方和前面的节点比较一下，一旦大于，直接返false

package cn.nupt;

import java.util.LinkedList;
import java.util.Stack;

import cn.nupt.IsBSTAndCBT.Node;

/**
 * @Description: 判断二叉树是否是搜索二叉树
 *
 * @author PizAn
 * @Email [email protected]
 * @date 2019年3月4日 下午10:14:46
 * 
 */
public class isBST {

	public static class Node {
		public int value;
		public Node left;
		public Node right;

		public Node(int data) {
			this.value = data;
		}
	}

	// 搜索二叉树：中序遍历是左中右，而搜索二叉树就是 左 < 中 < 右，稍加改动，将弹出的值用一个变量保存（可以初始化为系统最小值），比较大小
	public static boolean isBST (Node head) {
		if (head == null) {
			return true;
		}

		Stack<Node> stack = new Stack<Node>();
		int pre = Integer.MIN_VALUE;// 这里定义一个系统最小数，用于下面的和前面的数比较
		while (!stack.isEmpty() || head != null) {
			if (head != null) {
				stack.push(head);
				head = head.left;
			} else {
				head = stack.pop();
				// --------这里本来是中序遍历打印节点的地方，这里改成和前面的节点值比较，如果大于，直接返回false，否则迭代------------
				if (head.value < pre) { // 搜索二叉树默认节点不相等，若相等，就会变成同一个节点
					return false;
				} else {
					pre = head.value;
				}
				// -------------------------------------------
				head = head.right;
			}

		}

		return true;
	}
	
	//测试
	public static void main(String[] args) {
		Node head = new Node(4);
		head.left = new Node(7);
		head.right = new Node(6);
		head.left.left = new Node(1);
		head.left.right = new Node(3);
		head.right.left = new Node(5);

		System.out.println(isBST (head));