二叉搜索树（BST）

存在的需求

又称二叉查找树，二叉搜索树

• 任意一个节点的值都大于其左子树的所有节点的值
• 任意一个节点的值都小于其右子树的所有节点的值
• 它的左右子树也是二插搜索树
• 使用时存的数必须具备可比性，int，double类型。若是自定义类型，需要指定比较方式，不允许为null

接口设计

与之前线性表而言，没有索引的概念

添加元素

传进去数组时的添加

若是第一个元素，他就是根节点
先与根节点做比较，如果大于根节点，就把它作为根节点的右孩子；如果小于根节点，作为根节点的u左孩子。
然后再找到他的父节点。
比如插入12,12先与7根节点比较，得到应放在7的右边；再与父节点9比较，应放在9的右边；再与父节点11比较，应放在11的右边

public class Node<E> {//内部节点类，数据存储在节点中
		E element; // 元素值
		Node<E> left; // 左节点
		Node<E> right; // 右节点
		Node<E> parent; // 父节点

		public Node(E element, Node<E> parent) {//构造函数，创建完一个节点必有父节点，左右孩子是否存在不知道
			this.element = element;
			this.parent = parent;
		}
	}
/**
 * 添加元素——传的是element
 * 1.找到父节点parent
 * 2.创建新节点
 * 3.新节点放的位置
 */
public void add(E element) {
	elementNotNullCheck(element); // 不能传入空节点
	// 传入第一个节点
	if(root == null){
		root = new Node<>(element, null);
		size++;
		return;
	}
	Node<E> node = root;//假设node是根节点
	Node<E> parent = null;
	int cmp = 0;
	while(node != null){//while循环是为了找到父节点，直到node无左或无右孩子跳出循环
		parent = node; // 父节点保存起来
		cmp = compare(element,node.element); // 传进去的元素与父节点的元素比较
		if(cmp >0){//新节点-父节点>0，那么父节点的右孩子就是这个新节点，本次循环后这个新节点又可以作为父节点进行比较
			node = node.right;
		}else if(cmp < 0){//说明新节点比父节点小
			node = node.left;
		}else{ // 相等，最好是覆盖掉，否则自定义对象增加时会不更新
			node.element = element;
			return;
		}
	}
	Node<E> newNode = new Node<>(element, parent);
	//看看插入父节点的哪一边
	if(cmp < 0){
		parent.left = newNode;
	}else{
		parent.right = newNode;
	}
	size++;
}

private int compare(E e1,E e2) {
		//通过比较返回1或-1或0，因为是参数e1，e2是泛型，这里不可以直接运算比较
	}
//main函数测试
public static void main(String[] args) {	
			Integer data[]=new Integer[] {17,15,456,2,3,68,9,4,5,6};
			BinarySearchTree<Integer> b=new BinarySearchTree<>();

			for(int i=0;i<data.length;i++) {
				b.add(data[i]);
			}
			System.out.println(b);
}

自定义打印输出

传进去对象时的添加

引入接口自定义对象比较的属性

上面的操作只对整数有效，若传进去的是个对象，该如何进行比较呢？
1.设置一个比较接口，让传进去的元素继承这个接口，接口必须要实现，即传进去的对象一定会要有可比的地方。


2.在要传进去的类里单独实现要比较的内容，返回值依然是正数，负数，0

BinarySearchtree里的方法

private int compare(E e1,E e2) {
		return e1.compareTo(e2);//e1是传进去的元素，e2是原来存在的父节点的元素
}

Integer数据类型也是继承自comparable接口，比较的就是数字的大小

引入构造器自定义比较排序规则

如果要把年龄大的person放在父节点的右边，把年龄小的放在左边呢？把二叉树的规则反过来。如何自定义规则
通过传入一个比较器comparator，允许外界传入一个 Comparator 自定义比较方案
如果没有传入 Comparator，强制认定元素实现了 Comparable 接口，这样binarysearch就不用继承comparable接口了。

如果参数有传入比较器，就比较按规则他们谁大谁小

不用继承comparable接口，后面会强制转换。

没传比较器，元素内部必须自行实现了 Comparable 接口

也可以在main函数里调用匿名类定义比较规则

java官方有comparable接口和比较器comparator

找到前驱节点

private Node<E> predecessor(Node<E> node) {
		if(node == null) return null;
		//1.左孩子不为空
		// 前驱节点在左子树中(left.right.right.right....)
		if(node.left != null ){ // 左子树不为空,则找到它的最右节点
			Node<E> p = node.left;	
			while(node.right != null){
				p = p.right;
			}
			return p;//不能再往右了，就返回
		}
		// 2.能来到这里说明左子树为空，且这个节点是父节点的左孩子
		//前驱节点在祖父节点当中
		// 当父节点不为空，则顺着父节点找，直到找到【该结点为父节点的右节点】时
		while(node.parent != null && node.parent.left==node){
			node = node.parent;
		}
		
		//3.父节点为空或该节点为根结点的右节点，直接返回
		// node.parent == null	无前驱，直接返回空
		// node.parent.right == node 该节点为根结点的右节点，直接返回父节点
		return node.parent;
	}

找到后继节点

private Node<E> successor(Node<E> node) {
		if(node == null) return null;
		
		if(node.right != null){ // 存在右节点
			Node<E> p = node.right;
			while(p.left != null){
				p = p.left;
			}
			return p;
		}
		
		while(node.parent!=null && node.parent.right==node){
			node = node.parent;
		}
		
		// node.parent == null且 node.parent.left == node 如没有右子树的根节点
		return node.parent;
	}

删除

删除叶子节点

删除度为1的节点

如果删除的根节点
root=child
child.parent=null（加上比较严谨）

删除度为2的节点

若要继续删除4，可从左边找到最大值3，赋值，最后删除度为1的节点3；也可从右边找最小值6.赋值，最后删除度为1的节点6。
如果一个节点的度为2，那么它的前驱和后继节点的度只可能是0或1

如上图，根节点4的度为2，它的前驱就是3。怎么找呢？先找他的左孩子，然后一直找他左孩子的右孩子，直到右孩子为null。那找到的最后一个右孩子，只可能度为1（只有左孩子），或度为0（叶子节点），绝对不可能有右孩子。
想要得到4的后继节点，图中为6。先找他的右孩子，然后一直找它右孩子的左孩子，直到左孩子为空。

删除度为2的节点，真正被删除的是他的前驱或后继节点，只不过是把他的前驱或后继节点的元素赋值到了要删除的度为2的节点，以保持二叉树的左右特性，实际删除的还是度为0或度为1的节点

代码实现

外部调用时只认识节点中的值，而在内部时，我们要删除整个节点，因为值存在于节点中

/**
	 * 在外部，根据传入的节点中的值删除元素
	 */
	public void remove(E element) {
		remove(node(element));
	}
	//通过值，找到节点
	private Node<E> node(E element) {
		elementNotNullCheck(element);
		//从根节点开始找
		Node<E> node = root;
		while(node != null){
			int cmp = compare(element, node.element);
			if(cmp < 0){
				node = node.left;
			}else if (cmp > 0){
				node = node.right;
			}else{ // cmp == 0
				return node;
			}
		}
		return null;
	}
	// 私有方法，在内部根据节点删除元素
	private void remove(Node<E> node) {
		if (node == null) return;
		
		size--;
		
		if (node.hasTwoChildren()) { // 度为2的节点
			// 找到后继节点
			Node<E> s = successor(node);
			// 用后继节点的值覆盖度为2的节点的值
			node.element = s.element;
			// 删除后继节点，传的参数的node，把删除node的操作转化为删除后继节点s的操作
			node = s;
		}
		
		// 删除node节点（node的度必然是1或者0，若要删除的节点度为2，则此时node是原来要删除元素的后继节点）
		//删除节点的左孩子不为空，就用左边，若左孩子为空，就用右孩子
		Node<E> replacement = node.left != null ? node.left : node.right;
		
		if (replacement != null) { // node是度为1的节点，删除度为1，用子节点代替原节点的方法
			// 更改parent
			replacement.parent = node.parent;
			// 更改parent的left、right的指向
			if (node.parent == null) { // node是度为1的节点并且是根节点
				root = replacement;
			} else if (node == node.parent.left) {//要用 要删除节点的父节点的指向（删除节点是父的左还是右）去连接代替的节点
				node.parent.left = replacement;//如果删除的元素是父元素的左孩子，那代替的元素就是父元素的左孩子
			} else { // node == node.parent.right
				node.parent.right = replacement;
			}
		} else if (node.parent == null) { // node是叶子节点并且是根节点
			root = null;
		} else { // node是叶子节点，但不是根节点
			if (node == node.parent.left) {
				node.parent.left = null;
			} else { // node == node.parent.right
				node.parent.right = null;
			}
		}
	}

在节点类里设置两个方法判断节点的度数

测试

删除度为0

删除度为1

删除度为2

删除根节点

传一个值检查该节点是否包含这个值

/**
 * 是否包含某元素
 */
public boolean contains(E element) {
	return node(element) != null;
}

遍历

先根遍历：先从根节点开始找，再找左节点，最后是右节点
中根遍历：先找左孩子，再找根，最后找右孩子，实际就是顺序输出了
后根遍历：先找左孩子，再找右孩子，最后找根节点

// 前序遍历 先根后左再右
private void preOrderTraversal(Node<E> node){
	if(node == null) return;
	System.out.print(node.element + " ");
	preOrderTraversal(node.left);
	preOrderTraversal(node.right);
}
//以后调用这个方法，传入一个根节点，先序的话就从根节点开始，依次递归找根，一开始是根节点的一大部分的左孩子，直到叶子节点，再一层一层的返回到根节点，再递归找根的右边的根
public void preOrderTraversal(){
	preOrderTraversal(root);
}
// 中序遍历
private void inorderTraversal(Node<E> node){	
	if(node == null) return;
	inorderTraversal(node.left);
	System.out.print(node.element + " ");
	inorderTraversal(node.right);
}
public void inorderTraversal(){
	inorderTraversal(root);
}
// 后序遍历
private void postorderTraversal(Node<E> node){	
	if(node == null) return;
	postorderTraversal(node.left);
	postorderTraversal(node.right);
	System.out.print(node.element + " ");
}
public void postorderTraversal(){
	postorderTraversal(root);
}

层序遍历
从上到下，从左到右访问每一个节点
前面先访问谁，后面几先访问他的子树

• 1.将根节点入队
• 2.循环执行以下操作，直到队列为空
• 将对头节点A出队，进行访问
• 再将A的左子节点入队，将A的右子节点入队
  

一个是7入队，7出队，把4,9依次入队，那么队列里就是9,4。
4出队，把2,5依次入队的，队列里就是5,2，9

// 层次遍历
	public void levelOrderTraversal(){	
		if(root == null) return; 
		Queue<Node<E>> queue = new LinkedList<>();
		queue.add(root);
		
		while(!queue.isEmpty()){
			Node<E> node = queue.poll();//出队
			System.out.print(node.element + " ");
			if(node.left != null) queue.offer(node.left);//入队
			if(node.right!= null) queue.offer(node.right);
		}
	}

访问器的遍历

允许外界遍历二叉树的元素

/**
 * 访问器接口 ——> 访问器抽象类
 * 增强遍历接口
 */
public static interface Visitor<E>{
	void visit(E element);
}

// 层次遍历
	public void levelOrder(Visitor<E> visitor){
		if(root == null || visitor == null) return;
		Queue<Node<E>> queue = new LinkedList<>(); // 队列
		queue.offer(root);
		
		while(!queue.isEmpty()){
			Node<E> node = queue.poll();
			//调用visitor接口的visit方法，由他决定具体的操作逻辑
			//将结点的内容传给visit方法
			visitor.visit(node.element);
			if(node.left != null) queue.offer(node.left);
			if(node.right != null) queue.offer(node.right);
		}
	}
	// 前序遍历
	public void preOrderTraversal(Node<E> node, Visitor<E> visitor){
		if(node == null || visitor == null) return;
		visitor.visit(node.element);
		preOrderTraversal(node.left, visitor);
		preOrderTraversal(node.right, visitor);
	}
	public void preOrderTraversal(Visitor<E> visitor){
		preOrderTraversal(root, visitor);
	}
	// 中序遍历
	public void inorderTraversal(Node<E> node, Visitor<E> visitor){
		if(node == null || visitor == null) return;
		inorderTraversal(node.left, visitor);
		visitor.visit(node.element);
		inorderTraversal(node.right, visitor);
	}
	public void inorderTraversal(Visitor<E> visitor){
		inorderTraversal(root, visitor);
	}
	// 后序遍历
	public void postorderTraversal(Node<E> node, Visitor<E> visitor){
		if(node == null || visitor == null) return;
		postorderTraversal(node.left, visitor);
		postorderTraversal(node.right, visitor);
		visitor.visit(node.element);
	}
	public void postorderTraversal(Visitor<E> visitor){
		postorderTraversal(root, visitor);
	}

main函数里

Integer date[] = new Integer[] { 7, 4, 9, 2, 5, 8, 11, 3, 12, 1};
		BinarySearchTree<Integer> bst = new BinarySearchTree<>();
		for (int i = 0; i < date.length; i++) {
			bst.add(date[i]);
		}
		BinaryTrees.println(bst);
		
		System.out.print("层次遍历：");
		bst.levelOrder(new Visitor<Integer>() {
			@Override
			public void visit(Integer element) {
				System.out.print("_" + element + "_ ");
			}
		});

		System.out.println();
		System.out.print("前序遍历：");
		bst.preOrderTraversal(new Visitor<Integer>() {
			@Override
			public void visit(Integer element) {
				System.out.print("_" + element + "_ ");
			}
		});
		System.out.println();
		System.out.print("中序遍历：");
		bst.inorderTraversal(new Visitor<Integer>() {
			@Override
			public void visit(Integer element) {
				System.out.print("_" + element + "_ ");
			}
		});
		System.out.println();
		System.out.print("后序遍历：");
		bst.postorderTraversal(new Visitor<Integer>() {
			@Override
			public void visit(Integer element) {
				System.out.print("+" + element + "+ ");
			}
		});

结果

遍历的应用

前序遍历，树状打印二叉树

@Override
	public String toString()
	{
		StringBuilder sb=new StringBuilder();
		toString(root,sb,"");
		return sb.toString();
	}
	
	private void toString(Node<E> node ,StringBuilder sb,String prefix) {
		if(node==null)return ;
		
		sb.append(prefix).append(node.element).append("\n");//先访问自己
		toString(node.left,sb,prefix+"L--");//在原来的前缀的基础上+
		toString(node.right,sb,prefix+"R--");
	} 
	

中序遍历按升序和降序处理节点
后续遍历适用先子后用
层序遍历：计算二叉树的高度；判断是否为完全二叉树

计算二叉树的高度

递归求高度。
一个节点的高度等于他左右子树最大的高度+1

//获取某个节点的高度
	private int height1(Node<E> node){
		if(node == null) return 0;
		return 1 + Math.max(height1(node.left), height1(node.right));
	}
	public int height1(){
		return height1(root);
	}

迭代求高度
当每一层的最后一个元素访问完之后，队列的size就是下一层元素的个数。画个队列看看就明白了

public int height(){
	if(root == null) return 0;
	int levelSize = 1; // 存储每一层的元素数量	
	int height = 0; // 树的高度
	Queue<Node<E>> queue = new LinkedList<>();
	queue.offer(root);
	
	while(!queue.isEmpty()){	
		Node<E> node = queue.poll();
		levelSize--;//没出一个就-1，直到0说明这一层元素没了
		if(node.left != null) {
			queue.offer(node.left);
		}
		if(node. != null) {
			queue.offer(node.right);
		}
		if(levelSize == 0){ // 即将要访问下一层
			levelSize = queue.size();//此时队列的size就是下一层要访问的个数
			height++;
		}
	}
	return height;
}

判断是否为完全二叉树

树不为空就层序遍历（用队列）

public boolean isComplete(){
		if(root == null) return false;
		Queue<Node<E>> queue = new LinkedList<>();
		queue.offer(root);
		boolean leaf = false;
		while(!queue.isEmpty()){
			Node<E> node = queue.poll();
			if(leaf && !node.isLeaf()){要求是叶子，但是你不是叶子节点
				return false;
			}
			if(node.hasTwoChildren()) { // 左不为空且右不为空就正常入队
				queue.offer(node.left);
				queue.offer(node.right);
			}else if(node.left==null && node.right!=null){//左为空，右孩子不为空
				return false;
			}else{//后面遍历的都是叶子节点
				leaf = true;
				if(node.left!=null) {//左不为空就入队
					queue.offer(node.left);
				}
			}
		}
		return true;



public boolean isLeaf(){ // 是否叶子节点
			return left==null && right==null;
		}
public boolean hasTwoChildren(){ // 是否有两个子节点
		return left!=null && right!=null;
	}

测试（自己构建二叉搜索树测试，先写根节点）

方法二

public boolean isComplete2(){
		if(root == null){
			return false;
		}
		Queue<Node<E>> queue = new LinkedList<>();
		queue.offer(root);
		
		boolean leaf = false;
		while(!queue.isEmpty()){
			Node<E> node = queue.poll();
			if(leaf && !node.isLeaf()){ // 要求是叶子结点，但是当前节点不是叶子结点
				return false;
			}
			//左右分开遍历
			if(node.left != null){
				queue.offer(node.left);
			}else if(node.right != null){// node.left==null && node.right!=null
				return false;
			}
			
			if(node.right != null){
				queue.offer(node.right);
			}else{
				// node.left==null && node.right==null
				// node.left!=null && node.right==null
				leaf = true; // 要求后面都是叶子节点
			}
		}
		return true;
	}

翻转二叉树

将所有节点的左右子树调换顺序，大的在左边，小的在右边

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
 利用前序遍历
class Solution {
    public TreeNode invertTree(TreeNode root) {
		 if(root ==null) return root;
            TreeNode tmp=root.left;
            root.left=root.right;
            root.right=tmp;
            
            invertTree(root.left);
            invertTree(root.right);
            return root;
    }
}
利用中序遍历
class Solution {
    public TreeNode invertTree(TreeNode root) {
            if (root == null) return null;
            invertTree(root.left); // 递归找到左节点
            TreeNode rightNode= root.right; // 保存右节点
            root.right = root.left;
            root.left = rightNode;
            // 递归找到右节点 继续交换 : 因为此时左右节点已经交换了,所以此时的右节点为root.left
            invertTree(root.left); 
    }
}
利用后序遍历
 class Solution {
        public TreeNode invertTree(TreeNode root) {
            // 后序遍历-- 从下向上交换
            if (root == null) return null;
            TreeNode leftNode = invertTree(root.left);
            TreeNode rightNode = invertTree(root.right);
            root.right = leftNode;
            root.left = rightNode;
            return root;
        }
    }

利用层次遍历
   class Solution {
        public TreeNode invertTree(TreeNode root) {
            // 层次遍历--直接左右交换即可
            if (root == null) return null;
            Queue<TreeNode> queue = new LinkedList<>();
            queue.offer(root);
            while (!queue.isEmpty()){
                TreeNode node = queue.poll();//队头取出元素，让他的额左右子树交换
                //交换
                TreeNode rightTree = node.right;
                node.right = node.left;
                node.left = rightTree;
                
                if (node.left != null){
                    queue.offer(node.left);
                }
                if (node.right != null){
                    queue.offer(node.right);
                }
            }
            return root;
        }
    }