数据结构总结-- 树和二叉树

树的性质

1.树的结点数 = 结点度数和 + 1；(n0 + n1 + nm ….+1)

2.度为m的数第i层最多m^(i-1)次方个结点

3.高度为h的m次树，最多(m^h)/(m-1)

4.n个结点的m次树，最小高度logm(n(m-1)+1)

二叉树的定义

结点定义，根节点，左孩子，右孩子

java代码：

/**
* 结点类
*
* @author Administrator
*
* @param <T>
*/
static class BTNode<T> {
T value;
BTNode<T> leftChild;
BTNode<T> rightChild;

/**
* 结点构造方法
*
* @param value
*/
public BTNode(T value) {
this.value = value;
leftChild = null;
rightChild = null;
}

public BTNode() {
value = null;
leftChild = rightChild = null;
}

}

二叉树类：

public class BinaryTree<T> {

/**
* 结点类
*
* @author Administrator
*
* @param <T>
*/
static class BTNode<T> {
T value;
BTNode<T> leftChild;
BTNode<T> rightChild;

/**
* 结点构造方法
*
* @param value
*/
public BTNode(T value) {
this.value = value;
leftChild = null;
rightChild = null;
}

public BTNode() {
value = null;
leftChild = rightChild = null;
}

}

/**
* 根节点
*/
BTNode<T> root;

/**
* 构造方法
*/
public BinaryTree() {
root = new BTNode<T>(null);
}

二叉树的性质

1.叶子节点数= 双分支结点+1，分支数 = 总结点数-1；

2.编号为i (i>=0,i<=n)的结点，左孩子为2i + 1,右孩子为2i+2,一般使用数组存储时使用。如果起始i ==1，则左孩子 2i,右孩子2i+1

二叉树的存储结构

1.顺序存储

优点：结构紧凑，没有额外的指针空间，随机存取能力强，

缺点：插入删除耗时，所需空间较大时，较难找到连续的内存空间，不利于碎片空间利用。

2.链式存储结构

优点：碎片利用率高，不产生空结点，

缺点：不能随机存取，必须从头遍历

二叉树的基本操作

由括号表示法创建二叉树

括号表示法：兄弟结点用“，”分割，父节点后（）的内表示其子节点

Java实现

/**
* 使用括号表示法创建二叉树
* @param kuohao
* @return
*/
public BTNode<Character> createBTree(String kuohao){

BTNode<Character> [] stack= (BTNode<Character>[]) new Object[maxSize];
int top =-1;
//是否是左子结点
boolean isLeft = true;

BTNode<Character> tempRoot = null ;

for (int i = 1; i < kuohao.length(); i++) {
switch (kuohao.charAt(i)) {
case '(':
isLeft = true;
stack[++top] = tempRoot;

break;
case ')':
top--;
break;
case ',':
isLeft = false;
break;
default:
BTNode<Character> tempNode = new BTNode<>(kuohao.charAt(i));
if(tempRoot == null){
tempRoot = tempNode;
}else{
if(isLeft){
stack[top].leftChild = tempNode;
}else{
stack[top].rightChild = tempNode;
}
}
break;
}
}
return tempRoot;
}

二叉树的遍历，递归实现

所谓遍历就是找到结点并对其进行一定的操作

先序遍历

二叉树是递归结构，遍历很显然也是递归的，遍历顺序：根节点–》左子结点–》右子节点

/**
* 先序遍历
*/
public void preOrder(BTNode<T> root) {
// 对根节点进操作
System.out.println(root.value.toString());
preOrder(root.leftChild);
preOrder(root.rightChild);
}

中序遍历

遍历顺序：左子结点–》根节点–》右子节点

/**
* 中序遍历
*
* @param root
*/
public void inOrder(BTNode<T> root) {
inOrder(root.leftChild);
System.out.println(root.value.toString());
inOrder(root.rightChild);
}

后序遍历

遍历顺序：左子节点–》右子节点–》根节点

/**
* 后序遍历
*
* @param root
*/
public void postOrder(BTNode<T> root) {
postOrder(root.leftChild);
postOrder(root.rightChild);
System.out.println(root.value.toString());
}

二叉树的非递归遍历

非递归遍历使用栈保存需要遍历的结点，出栈表示遍历，因为栈的后入先出，适合回溯。

栈需要维护栈顶指针top，初始为top=-1，入栈top++，出栈top–；

先序遍历

先序遍历，根节点进栈，栈不为空时循环出栈，根节点出战，将根节点孩子进栈，注意先将右孩子进栈，再将左孩子进栈，

java 实现：

/**
* 非递归先序遍历
* @param root
*/
public void preOrderNoRecur(BTNode<T> root){
if(root == null){
return;
}
int top =-1;
BTNode<T> [] stack= (BTNode<T>[]) new Object[maxSize];
top ++;
stack[top] = root;//根节点入栈

while(top>-1){
BTNode<T> current = stack[top];//出栈
top --;

System.out.println(current.value.toString());//访问根节点，下次循环访问左子结点（如果存在）

if(current.rightChild !=null){
stack[top] = current.rightChild;//右子结点入栈
top ++;
}
if(current.leftChild != null){//右子节点入栈
stack[top] = current.leftChild;
top++;
}
}
}

中序遍历

中序遍历，开始访问的结点是根节点的最左子节点，在该节点之前的节点都进栈，出栈最左子节点访问之，将其右子节点入栈，重复上面的步骤。直到节点为null 或者栈空。两重循环，外循环判是否栈空结束，内循环入栈左子树。

java实现：

/**
* 非递归中序遍历
*
* @param root
*/
public void inOrderNoRecur(BTNode<T> root) {
if (root == null) {
return;
}
int top = -1;
BTNode<T>[] stack = (BTNode<T>[]) new Object[maxSize];
//
top++;
stack[top] = root;
BTNode<T> current = root;// 根节点入栈
while (top > -1 || current != null) {// ||
while (current.leftChild != null) {
stack[top] = current.leftChild;
top++;
}
// current 为根的左子结点都入栈了
if (top > -1) {
current = stack[top];
top--;
//
System.out.println(current.value.toString());
// stack[top] = current.rightChild;//入栈不是在这，在前面的循环
// top++;
current = current.rightChild;// 这里处理右子节点，下一步将右子树的左子树入栈
}
}
}

后序遍历

难点在于如何判断一个节点的右子树已经访问过了，需要一个标志刚刚访问过的节点 previous，如果current->rightChild == previous 那么说明current的右子树已经访问过，可以访问current。还要一个标志左子树是否全访问过。

后序遍历是先访问左子树，在访问右子树，最后访问根节点。先将左子树全部入栈，再判断栈顶的右子树是否访问过（即判断刚才访问的是否是栈顶的右子节点），是则访问栈顶出栈，否则重复上面步骤访问右子树的左子树，直到栈空。

三次循环。外部循环判断是否栈为空结束，内部1将左子树并入栈，内部2判断栈顶是否可以访问，可以则出栈，不可以则将右子树的左子树入栈。

栈中保存的是当前节点current的所有祖先节点

java实现：

/**
* 非递归后序遍历
*/
public void postOrderNoRecur(BTNode<T> root) {
if (root == null) {
return;
}
int top = -1;
BTNode<T>[] stack = (BTNode<T>[]) new Object[maxSize];
stack[++top] = root;
while (top > -1) {
BTNode<T> current = stack[top];
while (current != null) {
top++;
stack[top] = current;
current = current.leftChild;
}
// 左子结点都入栈了，开始判断栈顶是否能访问，
boolean leftCompeleted = true;
// 上一次访问的节点
BTNode<T> previous = null;
while (leftCompeleted && top > -1) {
BTNode<T> stackTop = stack[top];
if (stackTop.rightChild == previous) {// previous 说明没有右子节点
top--;
previous = stackTop;// !! 将stacktop设为之前访问过的节点。
System.out.println(stackTop.value.toString());
} else {
current = current.rightChild;
leftCompeleted = false;
}
}
}
}

层次遍历

层次遍历也叫广度优先遍历，从根节点开始，第一层遍历完遍历第二层，借助队列入队保存每层遍历过的结点，每次出队遍历其子节点，同时将子节点入队。队列先进先出，适合按层遍历。

java实现

/**
* 使用数组实现队列管理结点访问顺序
*
* @param root
*/
@SuppressWarnings("unchecked")
public void layOrder(BTNode<T> root) {
if (root == null) {
return;
}
int max = 50;
int front = 0, rear = 0;
int count = 0;

//创建object数组转为泛型数组
BTNode<T>[] queue = (BTNode<T>[]) new Object[max];

// 入队
queue[rear] = root;
rear = (rear + 1) % max;
count++;

while (count > 0) {
//出队
BTNode<T> out = queue[front];
front = (front + 1) % max;
count --;

//遍历出队结点的左右结点
//入队
if(out.leftChild != null){
queue[rear] = out.leftChild;
rear = (rear+1)%max;
count ++;
}
if(out.rightChild != null){
queue[rear] = out.rightChild;
rear = (rear+1)%max;
count ++;
}

}

}

查找节点的父节点

利用层次遍历法，在队列出队时，会遍历其左右子节点，此时比较待查找的结点和左右子节点是否相等，相等则返回刚刚出队的父节点。

特殊情况，待查结点是根节点，结点为null，结点不在树上

Java实现

public BTNode<T> findParentNode(BTNode<T> child){
if (child == null || child == root) {
return null;
}
int max = 50;
int front = 0, rear = 0;
int count = 0;

//创建object数组转为泛型数组
BTNode<T>[] queue = (BTNode<T>[]) new Object[max];

// 入队
queue[rear] = root;
rear = (rear + 1) % max;
count++;

BTNode<T> out;
while (count > 0) {
//出队
out = queue[front];
front = (front + 1) % max;
count --;

//遍历出队结点的左右结点
//入队
if(out.leftChild != null){
//判断是否是待查的子节点，是则返回刚刚出列的节点，为待求的父节点
if(out.leftChild.value == child.value){
return out;
}
queue[rear] = out.leftChild;
rear = (rear+1)%max;
count ++;
}
if(out.rightChild != null){
if(out.rightChild.value == child.value){
return out;
}
queue[rear] = out.rightChild;
rear = (rear+1)%max;
count ++;
}

}
//所有遍历完了没找到，则返回null，不在树上
return null;
}

求结点的左右兄弟结点

由上面的求父节点的方法，求得父节点后，再求该节点的兄弟结点即可

public BTNode<T> getBrotherNode(BTNode<T> child) {

BTNode<T> parent = findParentNode(child);
// 没有父节点
if (parent == null || child == null) {
return null;
}
if (parent.rightChild == child) {// 返回做兄弟
return parent.leftChild;
} else if (parent.leftChild == child) {
return parent.rightChild;
} else {
return null;
}

}

求树的高度

求树高度就是后序遍历树，取左子树和右子树较大者+1。

递归实现：

/**
* 求树的高度，递归后序遍历
* @param root
* @return
*/
public int getTreeHeight(BTNode<T> root) {
if (root == null) {
return 0;
}
int leftHeight = getTreeHeight(root.leftChild);
int rightHeight = getTreeHeight(root.rightChild);
return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
}

非递归实现主要是非递归后序遍历的修改。

判断是否是叶子节点，是则更新最大高度。

求某一节点所在的层次，或者某一节点的高度

/**
* 求任意节点的高度
*
* @param root
* @param node
* @param h，初始值为1，递归了多少次
* @return
*/
public int nodeHeight(BTNode<T> root, T node, int h) {
if (node == null) {
return 0;
}
if (root == null) {
return 0;
}
if (root.value == node) {
return h;
}
int leftHeight = nodeHeight(root.leftChild, node, h + 1);
if (leftHeight == 0) {
return nodeHeight(root.rightChild, node, h + 1);
}
return leftHeight;
}

将一个二叉树插入到另一棵树

找到待插入的节点，将其左子树改为要插入的二叉树。

/**
* 插入子树
*
* @param subTree
* @param node
*/
public void insertSubTree(BinaryTree<T> subTree, T node) {
if (node == null) {
return;
}
if (subTree.root == null) {
return;
}
BTNode<T> found = findNode(root, node);
if (found.leftChild == null) {
found.leftChild = subTree.root;
}
}

查找节点

递归查找，先序遍历

/**
* 查找节点
*
* @param root
* @param node
* @return
*/
private BTNode<T> findNode(BTNode<T> root, T node) {
if (root == null) {
return null;
}
if (root.value == node) {
return root;
}
BTNode<T> found = null;
found = findNode(root.leftChild, node);
if (found != null)
return found;

return findNode(root.rightChild, node);
}

删除子树

删除子树即删除某一节点的左子树或者右子树的所有节点。

递归删除节点，后序遍历树，先删除该节点的左子树，再删右子树，最后删根节点

javaj实现

/**
* 删除所有节点
*
* @param node
*/
public void deleteNodes(BTNode<T> node) {
if (node == null) {
return;
}
if (root == null) {
return;
}
deleteNodes(root.leftChild);
deleteNodes(root.rightChild);
node = null;// 置为null
}

/**
* 删除左子树
* @param node
*/
public void deleteSubTree(BTNode<T> node) {
if (node == null)
return;
deleteNodes(node.leftChild);
}

重建树

有先序遍历和中序遍历可以重建树，同理由后序遍历和中序遍历实现方式一样，都是先在中序序列上找到根节点，在重建左右子树。

/**
* 有前序和中序序列，重建二叉树
* @param preStr
* @param inStr
* @param nodesNum
* @param preStart
* @param inStart
* @return
*/
public BTNode<T> rebuildBinaryTree(T[] preStr, T[] inStr, int nodesNum, int preStart, int inStart) {
if (preStr == null || inStr == null || nodesNum <= 0) {
return null;
}
BTNode<T> tempRoot = new BTNode<>();
tempRoot.value = preStr[preStart];// 先序根节点为第一个
int i;
// 在中序中找到根节点
for (i = inStart; i < nodesNum; i++) {
if (inStr[i] == preStr[preStart]) {
break;
}
}
// 递归创建左右子树
//调整先序和中序开始构建的下标
tempRoot.leftChild = rebuildBinaryTree(preStr, inStr, i, preStart + 1, inStart);
tempRoot.rightChild = rebuildBinaryTree(preStr, inStr, nodesNum - i - 1, preStart + i + 1,  i + 1);
return tempRoot;

线索化二叉树

若节点的左右子节点为空，可以利用节点的空指针指向，该节点的直接前去和直接后继。

得到的线索化二叉树，根据不同的遍历方式不一样，