java数据结构——二叉树（BinaryTree）

前面我们已经学习了一些线性结构的数据结构和算法，接下来我们开始学习非线性结构的内容。

二叉树

前面显示增、删、查、遍历方法，完整代码在最后面。

/**
 * 为什么我们要学习树结构。
 * 1、有序数组插入数据项和删除数据项太慢。
 * 2、链表查找数据太慢。
 * 3、在树中能非常快速的查找、插入、删除数据，结合了有序数组和链表的优点
 * 4、暂时还不知道
 */

结点打包类

 public class BinaryTree {
     //数据项（对象什么都可以）
     public long data;
     //左孩子
     public BinaryTree leftChiled;
     //右孩子
     public BinaryTree rightChiled;

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

 }

 public void add(int value) {
         // 封装结点
         BinaryTree newnode = new BinaryTree(value);

         BinaryTree parent;// 引用父节点

         BinaryTree current = root;// current引用根结点

         if (root == null) {// 如果root为null，也就是第一次插入
             root = newnode;
             return;
         } else {
             while (true) {

                 parent = current;// 父节点指向指向当前节点，保存上一个结点
                 if (current.data > value) {
                     current = current.leftChiled;
                     if (current == null) {
                         parent.leftChiled = newnode;
                         return;
                     }
                 } else {
                     current = current.rightChiled;

                     if (current == null) {
                         parent.rightChiled = newnode;
                         return;
                     }
                 }

             }
         }
     }

添加方法

 

一、删除节点是二叉树操作中最复杂的。在删除之前首先要查找要删的节点。找到节点后，这个要删除的节点可能会有三种情况需要考虑。

1.该节点是叶子节点，没有子节点。

要删除叶节点，只需要改变该节点的父节点的引用值，将指向该节点的引用设置为null就可以了。

2.该节点有一个子节点。

改变父节点的引用，将其直接指向要删除节点的子节点。

3.该节点有两个子节点。

要删除有两个子节点的节点，就需要使用它的中序后继来替代该节点。

费我九牛二虎之力还是给整出来了。

 

 public boolean delete(long value) {// 删除
         BinaryTree current = root;// current保存根结点
         BinaryTree parent = root;// parent保存parent的父节点
         boolean isLeftchild = true;
         while (current.data != value) {
             parent = current;
             // 进行比较，比较当前值和查找值的大小
             if (current.data > value) {
                 current = current.leftChiled;
                 isLeftchild = true;// true为左子树
             } else {
                 current = current.rightChiled;
                 isLeftchild = false;
             }
             if (current == null) {
                 return false;
             }
         }
         if (current.leftChiled == null && current.rightChiled == null) {// 第1种情况
             if (isLeftchild) {
                 parent.leftChiled = null;
             } else {
                 parent.rightChiled = null;
             }
         } else if (current.rightChiled == null) {// 第2种情况
             if (current == root) {
                 root = current.leftChiled;
             } else if (isLeftchild) {
                 parent.leftChiled = current.leftChiled;
             } else {
                 parent.rightChiled = current.leftChiled;
             }
         } else if (current.leftChiled == null) {
             if (current == root) {
                 root = current.rightChiled;
             } else if (isLeftchild) {
                 parent.leftChiled = current.rightChiled;
             } else {
                 parent.rightChiled = current.rightChiled;
             }
         } else {// 第3种情况
             BinaryTree successor = getSuccessor(current);// 根结点开始，successor存放中序后继结点
             if (current == root) {// 替换工作
                 root = successor;
             } else if (isLeftchild) {// 要删除的父节点的左子节点
                 parent.leftChiled = successor;
             } else {// 要删除的父节点的右子节点
                 parent.rightChiled = successor;
             }
             successor.leftChiled = current.leftChiled;// 中序后继结点引用删除的左边的结点
         }

         return true;
     }

     public BinaryTree getSuccessor(BinaryTree delBin) {// 找中序后继结点方法
         // delBin为要删除的结点
         BinaryTree successor = delBin;// successor为查找的中序后继结点
         BinaryTree successorParent = delBin; // successor的父节点
         BinaryTree current = delBin.rightChiled; // 当前开始遍历的结点

         while (current != null) {// 这里完成elBin.rightChiled是叶子结点
             successorParent = successor;// successorParent保存上一个successor的引用
             successor = current;// 循环完成以后，successor保存的就是中序后继结点
             current = current.leftChiled;
         }
         // 中序后继结点有两种情况，就是delBin.rightChiled是否为叶子结点的两种情况

         if (successor != delBin.rightChiled) {// elBin.rightChiled不是叶子结点，中序后继结点是左边的
             successorParent.leftChiled = successor.rightChiled;// 中序后继结点后面肯定只有右子节点
             successor.rightChiled = delBin.rightChiled;// 中序后继结点的右子节点指向要删除的右边的结点
             // successor.rightChiled指向要删除的rightChiled
             // 交换成功
         }
         return successor;

     }

删除方法

二、

     public BinaryTree find(int value) {// 查找
         // 引用当前结点，从根结点开始
         BinaryTree current = root;
         // 循环，只要查找值不等于当前结点的数据项
         while (current.data != value) {
             // 进行比较，比较当前值和查找值的大小
             if (current.data > value) {
                 current = current.leftChiled;
             } else {
                 current = current.rightChiled;
             }
             if (current == null) {
                 return null;
             }

         }
         return current;
     }

查找方法

遍历二叉树，有3种遍历方法。其中，中序遍历最为常用，因为可以让特定的数据排序输出，前面我们已经学习了递归方法，接下来我们也使用递归方法实现。

前序遍历。
(1)访问根结点
(2)前序遍历左子树
(3)前序遍历右子树

 public void frontOrder(BinaryTree localBin) {// 前序
         if (localBin != null) {// 递归结束条件
             System.out.println(localBin.data);
             frontOrder(localBin.leftChiled);
             frontOrder(localBin.rightChiled);
         }
     }

前序遍历

中序遍历。
(1)中序遍历左子树
(2)访问根结点
(3)中序遍历右子树

 public void middleOrder(BinaryTree localBin) {// 前序
         if (localBin != null) {// 递归结束条件
             middleOrder(localBin.leftChiled);
             System.out.println(localBin.data);
             middleOrder(localBin.rightChiled);
         }
     }

中序遍历

后序遍历。
(1)后序遍历左子树
(2)后序遍历右子树
(3)访问根结点

 public void endOrder(BinaryTree localBin) {// 前序
         if (localBin != null) {// 递归结束条件
             endOrder(localBin.leftChiled);
             endOrder(localBin.rightChiled);
             System.out.println(localBin.data);
         }
     }

后序遍历

前辈的头发秃光不是没有原因的，哈哈哈。

 

 package binarytree;

 public class TestTree {
     // 根结点
     public BinaryTree root;

     public static void main(String[] args) {
         TestTree tt = new TestTree();
         tt.add(10);
         tt.add(5);
         tt.add(4);
         tt.add(6);
         tt.add(12);
         tt.add(11);
         tt.add(14);
         tt.add(13);

         tt.middleOrder(tt.root);
         tt.delete(10);
         System.out.println();
         tt.middleOrder(tt.root);

     }

     public void frontOrder(BinaryTree localBin) {// 前序
         if (localBin != null) {// 递归结束条件
             System.out.print(localBin.data + " ");
             frontOrder(localBin.leftChiled);
             frontOrder(localBin.rightChiled);
         }
     }

     public void middleOrder(BinaryTree localBin) {// 中序
         if (localBin != null) {// 递归结束条件
             middleOrder(localBin.leftChiled);
             System.out.print(localBin.data + " ");
             middleOrder(localBin.rightChiled);
         }
     }

     public void endOrder(BinaryTree localBin) {// 后序
         if (localBin != null) {// 递归结束条件
             endOrder(localBin.leftChiled);
             endOrder(localBin.rightChiled);
             System.out.print(localBin.data + " ");
         }
     }

     public void add(int value) {
         // 封装结点
         BinaryTree newnode = new BinaryTree(value);

         BinaryTree parent;// 引用父节点

         BinaryTree current = root;// current引用根结点

         if (root == null) {// 如果root为null，也就是第一次插入
             root = newnode;
             return;
         } else {
             while (true) {

                 parent = current;// 父节点指向指向当前节点，保存上一个结点
                 if (current.data > value) {
                     current = current.leftChiled;
                     if (current == null) {
                         parent.leftChiled = newnode;
                         return;
                     }
                 } else {
                     current = current.rightChiled;

                     if (current == null) {
                         parent.rightChiled = newnode;
                         return;
                     }
                 }

             }
         }
     }

     public BinaryTree find(int value) {// 查找
         // 引用当前结点，从根结点开始
         BinaryTree current = root;
         // 循环，只要查找值不等于当前结点的数据项
         while (current.data != value) {
             // 进行比较，比较当前值和查找值的大小
             if (current.data > value) {
                 current = current.leftChiled;
             } else {
                 current = current.rightChiled;
             }
             if (current == null) {
                 return null;
             }

         }
         return current;
     }

     public boolean delete(long value) {// 删除
         BinaryTree current = root;// current保存根结点
         BinaryTree parent = root;// parent保存parent的父节点
         boolean isLeftchild = true;
         while (current.data != value) {
             parent = current;
             // 进行比较，比较当前值和查找值的大小
             if (current.data > value) {
                 current = current.leftChiled;
                 isLeftchild = true;// true为左子树
             } else {
                 current = current.rightChiled;
                 isLeftchild = false;
             }
             if (current == null) {
                 return false;
             }
         }
         if (current.leftChiled == null && current.rightChiled == null) {// 第1种情况
             if (isLeftchild) {
                 parent.leftChiled = null;
             } else {
                 parent.rightChiled = null;
             }
         } else if (current.rightChiled == null) {// 第2种情况
             if (current == root) {
                 root = current.leftChiled;
             } else if (isLeftchild) {
                 parent.leftChiled = current.leftChiled;
             } else {
                 parent.rightChiled = current.leftChiled;
             }
         } else if (current.leftChiled == null) {
             if (current == root) {
                 root = current.rightChiled;
             } else if (isLeftchild) {
                 parent.leftChiled = current.rightChiled;
             } else {
                 parent.rightChiled = current.rightChiled;
             }
         } else {// 第3种情况
             BinaryTree successor = getSuccessor(current);// 根结点开始，successor存放中序后继结点
             if (current == root) {// 替换工作
                 root = successor;
             } else if (isLeftchild) {// 要删除的父节点的左子节点
                 parent.leftChiled = successor;
             } else {// 要删除的父节点的右子节点
                 parent.rightChiled = successor;
             }
             successor.leftChiled = current.leftChiled;// 中序后继结点引用删除的左边的结点
         }

         return true;
     }

     public BinaryTree getSuccessor(BinaryTree delBin) {// 找中序后继结点方法
         // delBin为要删除的结点
         BinaryTree successor = delBin;// successor为查找的中序后继结点
         BinaryTree successorParent = delBin; // successor的父节点
         BinaryTree current = delBin.rightChiled; // 当前开始遍历的结点

         while (current != null) {// 这里完成elBin.rightChiled是叶子结点
             successorParent = successor;// successorParent保存上一个successor的引用
             successor = current;// 循环完成以后，successor保存的就是中序后继结点
             current = current.leftChiled;
         }
         // 中序后继结点有两种情况，就是delBin.rightChiled是否为叶子结点的两种情况

         if (successor != delBin.rightChiled) {// elBin.rightChiled不是叶子结点，中序后继结点是左边的
             successorParent.leftChiled = successor.rightChiled;// 中序后继结点后面肯定只有右子节点
             successor.rightChiled = delBin.rightChiled;// 中序后继结点的右子节点指向要删除的右边的结点
             // successor.rightChiled指向要删除的rightChiled
             // 交换成功
         }
         return successor;

     }
 }

complete code