数据结构之二叉树
数据结构分线性存储结构和非线性存储结构，前面说的顺序表，单链表，双链表，栈，队列都属于线性结构，线性结构的特别是集合中必存在唯一的一个"第一个元素，集合中必存在唯一的一个"最后的元素"；除最后元素之外，其它数据元素均有唯一的"后继"；除第一元素之外，其它数据元素均有唯一的"前驱"。大家注意的是唯一2个字，也就是说线性结构不可能存在2个或多个前驱结点，同样不可能出现2个或多个后继结点，现在我们说下2叉树，很明显是非线性的因为它有2个后继结点。
一：树的基本概念
父母结点：结点的前驱节点称为父母结点
孩子结点：结点的后继节点称为孩子结点
兄弟结点：拥有同一父母的结点称为兄弟结点
度：结点拥有子树的的个数（后继节点的个数）没有后继结点的称为叶子结点（树的度指的是所有结点中度最大的）
结点层次：指的是按照这个结点算起来的高度。
树的高度：就是树的层次。
二：二叉树结点类
public class BinaryNode<T> {
public T data;
public BinaryNode<T> left;
public BinaryNode<T> right;
public BinaryNode(T data, BinaryNode<T> left, BinaryNode<T> right) {
this.data = data;
this.left = left;
this.right = right;
}
public BinaryNode(T data) {//构建叶子节点
this(data, null, null);
}
public BinaryNode() {
this(null, null, null);
}
}
三：树的抽象接口
public interface BinaryTTree<T> {
/**
* 判断二叉树是否为null
* @return
*/
boolean isEmpty();
/**
* 返回二叉树节点个数
* @return
*/
int count();
/**
* 返回二叉树的高度
* @return
*/
int height();
/**
* 先根遍历
*/
void preOrder();
/**
* 中根遍历
*/
void inOrder();
/**
* 后跟遍历
*/
void postOrder();
/**
* 层次遍历
*/
void levelOrder();
/**
* 查找并返回首次出现关键字为key的元素节点
* @param key
* @return
*/
BinaryNode<T> search(T key);
/**
* 返回弄得节点的父节点
* @param node
* @return
*/
BinaryNode<T> getParent(BinaryNode<T> node);
/**
* 插入x作为根节点
* @param x
*/
void insertRoot(T x);
/**
* 插入p的孩子节点（leftchild验证为左子树还是右子树）
* @return
*/
BinaryNode<T> insertChild(BinaryNode<T> p,T x,boolean leftChild);
/**
* 删除p节点的左或者右子树
* @param p
* @param leftChild
*/
void removeChild(BinaryNode<T> p,boolean leftChild);
/**
* 删除二叉树
*/
void removeAll();
}
四：树的实现
现在我先画一个很简单的树来帮助理解
首先我们应该定义一个根，如果这个根空，则表示是空树。比如上面这颗树我们怎么计算他结点的个数呢，我们采取的方式是计算左子树的个数+右子树的个数+根不就是么，我们采用递归的思想来解决。
public int count() {
return count(this.root);
}
private int count(BinaryNode<T> node){
if (node==null){
return 0;
}
return 1+count(node.left)+count(node.right);
}
二叉树的高度其实道理一样，计算左子树高度和右子树高度取大的然后加上根即可
public int height() {
return height(this.root);
}
public int height(BinaryNode<T> root) {
if (root == null) {
return 0;
}
int lh = height(root.left);
int rh = height(root.right);
return lh >= rh ? lh + 1 : rh + 1;
}
先根遍历，就是先遍历根然后左子树然后右子树，比如上面的采用先根就是25,15,13,20,35，30,40.代码如下
public void preOrder() {
System.out.println("先根遍历开始：");
preOrder(this.root);
System.out.println();
}
public void preOrder(BinaryNode<T> p){
if (p!=null){
System.out.println(p.data.toString()+" ");
preOrder(p.left);
preOrder(p.right);
}
}
中根是先执行左子树然后根最后右子树
public void inOrder() {
System.out.println("中根遍历开始：");
inOrder(this.root);
System.out.println();
}
public void inOrder(BinaryNode<T> p){
if (p!=null){
inOrder(p.left);
System.out.println(p.data.toString()+" ");
inOrder(p.right);
}
}
后根是先左子树，然后右子树最后才根
public void postOrder() {
System.out.println("后跟遍历");
postOrder(this.root);
System.out.println();
}
public void postOrder(BinaryNode<T> p){
if (p!=null){
postOrder(p.left);
postOrder(p.right);
System.out.println(p.data.toString()+" ");
}
}
查找也是如何，先从根比对，然后比对多有的左子树，如果没有找到在从右子树中查找
public BinaryNode<T> search(T key) {
return search(this.root, key);
}
public BinaryNode<T> search(BinaryNode<T> node,T key) {
if (node == null || key == null) {
return null;
}
if (node.data.equals(key)) {
return node;
}
BinaryNode<T> find = search(node.left, key);
if (find == null) {
find = search(node.right, key);
}
return find;
}
public BinaryNode<T> getParent(BinaryNode<T> node) {
if (this.root==null||node==null||this.root==node){
return null;
}
return getParent(this.root,node);
}
//以p为根的子树中查找，并返回node节点的父母节点
public BinaryNode<T> getParent(BinaryNode<T> p,BinaryNode<T> node){
if (p.left==node||p.right==node){
return p;
}
BinaryNode<T> find=getParent(p.left,node);
if (find==null){
find=getParent(p.right,node);
}
return find;
}
public void insertRoot(T x) {
this.root = new BinaryNode<T>(x, this.root, null);
}
public BinaryNode<T> insertChild(BinaryNode<T> p, T x, boolean leftChild) {
if (p==null||x==null){
return null;
}
if (leftChild){
p.left=new BinaryNode<T>(x,p.left,null);
return p.left;
}
p.right=new BinaryNode<T>(x,null,p.right);
return p.right;
}
public void removeChild(BinaryNode<T> p, boolean leftChild) {
if (p != null) {
if (leftChild) {
p.left = null;
} else {
p.right = null;
}
}
}
public void removeAll() {
this.root=null;
}
五：排序二叉树
主要说二叉树的添加和删除
首先第一步必须找到要插入节点的位置，也就是说找到这个即将插入这个结点的父结点
if (this.root == null) {
this.root = new BinaryNode<T>(x);
} else {
BinaryNode<T> p = this.root, parent = null;
while (p != null) {
parent = p;
if (x.compareTo(p.data) == 0) {
return;
}
if (x.compareTo(p.data) < 0) {
p = p.left;
}else {
p=p.right;
}
}
我们先分析这段代码，如果是空树就和简单直接赋值即可，如果非空，我们分别申明2个变量，用parent来记录父结点，我们知道我们要插入的树已经是顺序的了，所以我们只要知道这个要插入的节点放在左边还是右边。我们找到了这个节点的父结点了就好办了。我们只需要和父结点比对即可，如果小就是左子树，如果打就是右子树
p = new BinaryNode<T>(x);
if (x.compareTo(parent.data) <= 0) {
parent.left = p;
} else {
parent.right = p;
}
删除是相对比较复杂的，但是同样首先要找到要删除的结点p，然后在进行操作如下
if (p==null){
return null;
}
//首先找到删除节点p
if (x.compareTo(p.data)<0){
return remove(x,p.left,p);
}
if (x.compareTo(p.data)>0){
return remove(x,p.right,p);
}
现在有几种情况，第一这个父结点左子树为null右子树不为null；第二右子树为null左子树不为null，第三都不为null。第一种情况我们只需要把要删除的p结点替换它的右子树即可，第二种情况我们同样把删除的p结点替换成它的左子树。第三种情况，既然删除父结点p我们只要需要把p结点的右子树中最小的结点赋值给这个删除的p结点即可，然后置空p结点右子树中的最小结点
if (p.left!=null&&p.right!=null){
BinaryNode<T> insucc=p.right;
while (insucc.left!=null){
insucc=insucc.left;
}//找到要删除节点的节点
p.data=insucc.data;
return remove(p.data,p.right,p);
}
然后我们考虑一下特别情况，比如这颗树 本身是叶子结点，或者度为1，那么直接进行转换就可以
if (parent==null){
if (p.left!=null){
root=p.left;
}else {
root=p.right;
}
return p;
}
最后代码如下
if (p==parent.left){
if (p.left!=null){
parent.left=p.left;
}else {
parent.left=p.right;
}
}else {
if (p.left!=null){
parent.right=p.left;
}else {
parent.right=p.right;
}
}
本文来自博客园，作者：小珍珠在河里敲代码，转载请注明原文链接：https://www.cnblogs.com/Jansens520/p/6496506.html
