数据结构与算法笔记之树结构（三）

树
树（tree）是包含n（n>0）个节点的有穷集合，其中：

每个元素称为节点（node）；

有一个特定的节点被称为根节点或树根（root）。

除根节点之外的其余数据元素被分为m（m≥0）个互不相交的结合T1，T2，……Tm-1，其中每一个集合Ti（1<=i<=m）本身也是一棵树，被称作原树的子树（subtree）。

树这种数据结构在计算机世界中有广泛的应用，比如操作系统中用到了红黑树，数据库用到了B+树，编译器中的语法树，内存管理用到了堆（本质上也是树），信息论中的哈夫曼编码等等等等，在Java中TreeSet和TreeMap用到了树来排序（二分查找提高检索速度），不过一般都需要程序员自己去定义一个树的类，并实现相关性质，而没有现成的API。下面就用Java来实现各种常见的树

二叉树

二叉树是一种基础而且重要的数据结构，其每个结点至多只有二棵子树，二叉树有左右子树之分，第i层至多有2^{(i-1)个结点（i从1开始）；深度为k的二叉树至多有2}(k)-1)个结点，对任何一棵二叉树，如果其终端结点数为n0，度为2的结点数为n2，则n0=n2+1。

二叉树的性质：

1. 在非空二叉树中，第i层的结点总数不超过2^(i-1), i>=1;

2. 深度为h的二叉树最多有2^h-1个结点(h>=1)，最少有h个结点;

3. 对于任意一棵二叉树，如果其叶结点数为N0，而度数为2的结点总数为N2，则N0=N2+1;

4. 具有n个结点的完全二叉树的深度为log2(n+1);

5)有N个结点的完全二叉树各结点如果用顺序方式存储，则结点之间有如下关系：

若I为结点编号则 如果I>1，则其父结点的编号为I/2；

如果2I<=N，则其左儿子（即左子树的根结点）的编号为2I；若2I>N，则无左儿子；

如果2I+1<=N，则其右儿子的结点编号为2I+1；若2I+1>N，则无右儿子。

6)给定N个节点，能构成h(N)种不同的二叉树，其中h(N)为卡特兰数的第N项，h(n)=C(2*n, n)/(n+1)。

7)设有i个枝点，I为所有枝点的道路长度总和，J为叶的道路长度总和J=I+2i。

满二叉树、完全二叉树

满二叉树：除最后一层无任何子节点外，每一层上的所有结点都有两个子结点；

完全二叉树：若设二叉树的深度为h，除第 h 层外，其它各层 (1～(h-1)层) 的结点数都达到最大个数，第h层所有的结点都连续集中在最左边，这就是完全二叉树；

满二叉树是完全二叉树的一个特例。
二叉查找树

二叉查找树，又称为是二叉排序树（Binary Sort Tree）或二叉搜索树。二叉排序树或者是一棵空树，或者是具有下列性质的二叉树：

1. 若左子树不空，则左子树上所有结点的值均小于它的根结点的值；

2. 若右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值；

3. 左、右子树也分别为二叉排序树；

4. 没有键值相等的节点。

二叉查找树的性质：对二叉查找树进行中序遍历，即可得到有序的数列。

二叉查找树的时间复杂度：它和二分查找一样，插入和查找的时间复杂度均为O(logn)，但是在最坏的情况下仍然会有O(n)的时间复杂度。原因在于插入和删除元素的时候，树没有保持平衡。我们追求的是在最坏的情况下仍然有较好的时间复杂度，这就是平衡二叉树设计的初衷。

上面是我找的一些定义，链接为https://blog.csdn.net/u011277123/article/details/89875342
代码如下package demo5;

public class BinaryTree {

Node root;

//设置根节点
public void setRoot(Node root) {
	this.root = root;
}

//获取根节点
public Node getRoot() {
	return root;
}

public void frontShow() {
	if(root!=null) {
		root.frontShow();
	}
}

public void midShow() {
	if(root!=null) {
		root.midShow();
	}
}

public void afterShow() {
	if(root!=null) {
		root.afterShow();
	}
}

public Node frontSearch(int i) {
	return root.frontSearch(i);
}

public void delete(int i) {
	if(root.value==i) {
		root=null;
	}else {
		root.delete(i);
	}
}

}

package demo5;

public class Node {
//节点的权
int value;
//左儿子
Node leftNode;
//右儿子
Node rightNode;

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

//设置左儿子
public void setLeftNode(Node leftNode) {
	this.leftNode = leftNode;
}
//设置右儿子
public void setRightNode(Node rightNode) {
	this.rightNode = rightNode;
}

//前序遍历
public void frontShow() {
	//先遍历当前节点的内容
	System.out.println(value);
	//左节点
	if(leftNode!=null) {
		leftNode.frontShow();
	}
	//右节点
	if(rightNode!=null) {
		rightNode.frontShow();
	}
}

//中序遍历
public void midShow() {
	//左子节点
	if(leftNode!=null) {
		leftNode.midShow();
	}
	//当前节点
	System.out.println(value);
	//右子节点
	if(rightNode!=null) {
		rightNode.midShow();
	}
}

//后序遍历
public void afterShow() {
	//左子节点
	if(leftNode!=null) {
		leftNode.afterShow();
	}
	//右子节点
	if(rightNode!=null) {
		rightNode.afterShow();
	}
	//当前节点
	System.out.println(value);
}

//前序查找
public Node frontSearch(int i) {
	Node target=null;
	//对比当前节点的值
	if(this.value==i) {
		return this;
	//当前节点的值不是要查找的节点
	}else {
		//查找左儿子
		if(leftNode!=null) {
			//有可能可以查到，也可以查不到，查不到的话，target还是一个null
			target = leftNode.frontSearch(i);
		}
		//如果不为空，说明在左儿子中已经找到
		if(target!=null) {
			return target;
		}
		//查找右儿子
		if(rightNode!=null) {
			target=rightNode.frontSearch(i);
		}
	}
	return target;
}

//删除一个子树
public void delete(int i) {
	Node parent = this;
	//判断左儿子
	if(parent.leftNode!=null&&parent.leftNode.value==i) {
		parent.leftNode=null;
		return;
	}
	//判断右儿子
	if(parent.rightNode!=null&&parent.rightNode.value==i) {
		parent.rightNode=null;
		return;
	}
	
	//递归检查并删除左儿子
	parent=leftNode;
	if(parent!=null) {
		parent.delete(i);
	}
	
	//递归检查并删除右儿子
	parent=rightNode;
	if(parent!=null) {
		parent.delete(i);
	}
}

}

package demo5;

public class TestBinaryTree {

public static void main(String[] args) {
	//创建一颗树
	BinaryTree binTree = new BinaryTree();
	//创建一个根节点
	Node root = new Node(1);
	//把根节点赋给树
	binTree.setRoot(root);
	//创建一个左节点
	Node rootL = new Node(2);
	//把新创建的节点设置为根节点的子节点
	root.setLeftNode(rootL);
	//创建一个右节点
	Node rootR = new Node(3);
	//把新创建的节点设置为根节点的子节点
	root.setRightNode(rootR);
	//为第二层的左节点创建两个子节点
	rootL.setLeftNode(new Node(4));
	rootL.setRightNode(new Node(5));
	//为第二层的右节点创建两个子节点
	rootR.setLeftNode(new Node(6));
	rootR.setRightNode(new Node(7));
	//前序遍历树
	binTree.frontShow();
	System.out.println("===============");
	//中序遍历
	binTree.midShow();
	System.out.println("===============");
	//后序遍历
	binTree.afterShow();
	System.out.println("===============");
	//前序查找
	Node result = binTree.frontSearch(5);
	System.out.println(result);
	
	System.out.println("===============");
	//删除一个子树
	binTree.delete(4);
	binTree.frontShow();
	
}

}
平衡二叉树

平衡二叉树又被称为AVL树，具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。它的出现就是解决二叉查找树不平衡导致查找效率退化为线性的问题，因为在删除和插入之时会维护树的平衡，使得查找时间保持在O(logn)，比二叉查找树更稳定。

ALLTree 的 Node 由 BST 的 Node 加上 private int height; 节点高度属性即可，这是为了便于判断树是否平衡。

维护树的平衡关键就在于旋转。对于一个平衡的节点，由于任意节点最多有两个儿子，因此高度不平衡时，此节点的两颗子树的高度差2.容易看出，这种不平衡出现在下面四种情况：

1、6节点的左子树3节点高度比右子树7节点大2，左子树3节点的左子树1节点高度大于右子树4节点，这种情况成为左左。

2、6节点的左子树2节点高度比右子树7节点大2，左子树2节点的左子树1节点高度小于右子树4节点，这种情况成为左右。

3、2节点的左子树1节点高度比右子树5节点小2，右子树5节点的左子树3节点高度大于右子树6节点，这种情况成为右左。

4、2节点的左子树1节点高度比右子树4节点小2，右子树4节点的左子树3节点高度小于右子树6节点，这种情况成为右右。

从图2中可以可以看出，1和4两种情况是对称的，这两种情况的旋转算法是一致的，只需要经过一次旋转就可以达到目标，我们称之为单旋转。2和3两种情况也是对称的，这两种情况的旋转算法也是一致的，需要进行两次旋转，我们称之为双旋转。

单旋转是针对于左左和右右这两种情况，这两种情况是对称的，只要解决了左左这种情况，右右就很好办了。图3是左左情况的解决方案，节点k2不满足平衡特性，因为它的左子树k1比右子树Z深2层，而且k1子树中，更深的一层的是k1的左子树X子树，所以属于左左情况。

为使树恢复平衡，我们把k1变成这棵树的根节点，因为k2大于k1，把k2置于k1的右子树上，而原本在k1右子树的Y大于k1，小于k2，就把Y置于k2的左子树上，这样既满足了二叉查找树的性质，又满足了平衡二叉树的性质。

这样的操作只需要一部分指针改变，结果我们得到另外一颗二叉查找树，它是一棵AVL树，因为X向上一移动了一层，Y还停留在原来的层面上，Z向下移动了一层。整棵树的新高度和之前没有在左子树上插入的高度相同，插入操作使得X高度长高了。因此，由于这颗子树高度没有变化，所以通往根节点的路径就不需要继续旋转了。