githublmk · githublmk · Dec 19, 2019 · Dec 19, 2019
diff --git a/shujujiegou/Tree.iml b/shujujiegou/Tree.iml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>
diff --git a/shujujiegou/src/com/lmk/arraybinarytree/ArrayBinaryTree.java b/shujujiegou/src/com/lmk/arraybinarytree/ArrayBinaryTree.java
@@ -0,0 +1,82 @@
+package com.lmk.arraybinarytree;
+
+public class ArrayBinaryTree {
+    private int[] root;
+
+    public ArrayBinaryTree() {
+    }
+
+    public ArrayBinaryTree(int[] root) {
+        this.root = root;
+    }
+
+    public int[] getRoot() {
+        return root;
+    }
+
+    public void setRoot(int[] root) {
+        this.root = root;
+    }
+
+    public void before(){
+        before(0);
+    }
+
+    /**
+     * 先序遍历
+     * @param index
+     */
+    public void before(int index) {
+        if(index>this.root.length-1){
+            return;
+        }
+        System.out.println(this.root[index]);
+
+        if(2*index+1 <this.root.length){
+            before(2*index +1);
+        }
+        if(2*index +2<this.root.length){
+            before(2*index +2);
+        }
+    }
+
+    public void middle(){
+        middle(0);
+    }
+    /**
+     * 中序遍历
+     * @param index
+     */
+    public void middle(int index){
+        if(index>this.root.length-1){
+            return;
+        }
+        if(2*index +1<this.root.length){
+            middle(2*index+1);
+        }
+        System.out.println(this.root[index]);
+        if(2*index +2<this.root.length){
+            middle(2*index+2);
+        }
+    }
+
+    public void after(){
+        after(0);
+    }
+    /**
+     * 后序遍历
+     * @param index
+     */
+     public void after(int index){
+        if(index>this.root.length-1){
+            return;
+        }
+        if(2*index+1<this.root.length){
+            after(2*index+1);
+        }
+        if(2*index+2<this.root.length){
+            after(2*index+2);
+        }
+         System.out.println(this.root[index]);
+     }
+}
diff --git a/shujujiegou/src/com/lmk/arraybinarytree/TestArrayBinaryTree.java b/shujujiegou/src/com/lmk/arraybinarytree/TestArrayBinaryTree.java
@@ -0,0 +1,27 @@
+package com.lmk.arraybinarytree;
+
+public class TestArrayBinaryTree {
+
+    /**
+     * 顺序存储二叉树
+     * 左子子节点  2n +1
+     * 右子节点   2n +2
+     * 父节点  （n-1）/2
+     *          1
+     *        2   3
+     *      4  5  6 7
+      * @param args
+     */
+
+    public static void main(String[] args) {
+        ArrayBinaryTree tree =new ArrayBinaryTree();
+        int[] array =new int[]{1,2,3,4,5,6,7};
+        tree.setRoot(array);
+        System.out.println("------先序--------");
+        tree.before();
+        System.out.println("------中序-------");
+        tree.middle();
+        System.out.println("-------后序--------");
+        tree.after();
+    }
+}
diff --git a/shujujiegou/src/com/lmk/binarytree/BinaryTree.java b/shujujiegou/src/com/lmk/binarytree/BinaryTree.java
@@ -0,0 +1,75 @@
+package com.lmk.binarytree;
+
+public class BinaryTree {
+
+    private TreeNode root;
+
+    public BinaryTree(){}
+
+    public BinaryTree(TreeNode root){
+        this.root = root;
+    }
+
+    public TreeNode getRoot() {
+        return root;
+    }
+
+    public void setRoot(TreeNode root) {
+        this.root = root;
+    }
+
+    //先序查找
+    public TreeNode beforeSearch(int value){
+       if(this.root ==null){
+           return  null;
+       }else{
+           return this.root.beforeSearch(value);
+       }
+    }
+    /**
+     * 中序查找
+     */
+    public TreeNode middleSearch(int value){
+        if(this.root==null){
+            return null;
+        }else{
+           return  this.root.middleSearch(value);
+        }
+
+    }
+
+    public TreeNode afterSearch(int value){
+        if(this.root == null){
+            return null;
+        }else {
+            return this.root.afterSearch(value);
+        }
+
+    }
+
+    /**
+     * 删除值为i的节点
+     * @param i
+     */
+    public void delete(int i) {
+        /*
+        判断根节点的值是否等于i，等于i根节点置空
+         */
+        if(root !=null&&root.getValue() ==i){
+            root =null;
+        }else{
+            root.delete(i);
+        }
+
+
+    }
+
+    public void middle() {
+
+        if(root==null){
+            return;
+        }
+        root.middle();
+
+    }
+}
diff --git a/shujujiegou/src/com/lmk/binarytree/TestBinaryTree.java b/shujujiegou/src/com/lmk/binarytree/TestBinaryTree.java
@@ -0,0 +1,58 @@
+package com.lmk.binarytree;
+
+public class TestBinaryTree {
+
+    /**
+     *
+     * @param args
+     *                          1
+     *                       2    3
+     *                    4   5  6  7
+     */
+    public static void main(String[] args) {
+
+
+
+        TreeNode root =new TreeNode(1);
+        BinaryTree tree =new BinaryTree(root);
+
+        TreeNode left1 = new TreeNode(2);
+        root.setLeftNode(left1);
+
+        TreeNode right1 = new TreeNode(3);
+        root.setRightNode(right1);
+
+        TreeNode left21 = new TreeNode(4);
+        left1.setLeftNode(left21);
+
+        TreeNode right21 = new TreeNode(5);
+        left1.setRightNode(right21);
+
+        TreeNode left22 = new TreeNode(6);
+        right1.setLeftNode(left22);
+
+        TreeNode right22 =new TreeNode(7);
+        right1.setRightNode(right22);
+        System.out.println("------------删除节点-------------");
+        tree.delete(1);
+        tree.middle();
+
+        System.out.println("------先序--------");
+        TreeNode beforeResult = tree.beforeSearch(6);
+        if(beforeResult !=null){
+            System.out.println(beforeResult.getValue());
+        }
+        System.out.println(beforeResult);
+        System.out.println(left22==beforeResult);
+        System.out.println("-----中序--------");
+        TreeNode restltMiddle = tree.middleSearch(4);
+        System.out.println(restltMiddle!=null?restltMiddle.getValue()+"|"+restltMiddle:restltMiddle);
+        System.out.println(left21==restltMiddle);
+
+        System.out.println("----后序---------");
+        TreeNode resultAfter = tree.afterSearch(6);
+        System.out.println(resultAfter!=null?resultAfter.getValue()+"|"+resultAfter:resultAfter);
+        System.out.println(left22==resultAfter);
+    }
+
+}
diff --git a/shujujiegou/src/com/lmk/binarytree/TreeNode.java b/shujujiegou/src/com/lmk/binarytree/TreeNode.java
@@ -0,0 +1,138 @@
+package com.lmk.binarytree;
+
+public class TreeNode {
+
+    private int value;
+
+    private TreeNode leftNode;
+
+    private TreeNode rightNode;
+
+    public TreeNode(){
+
+    }
+
+    public TreeNode(int value) {
+        this.value = value;
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    public void setValue(int value) {
+        this.value = value;
+    }
+
+    public TreeNode getLeftNode() {
+        return leftNode;
+    }
+
+    public void setLeftNode(TreeNode leftNode) {
+        this.leftNode = leftNode;
+    }
+
+    public TreeNode getRightNode() {
+        return rightNode;
+    }
+
+    public void setRightNode(TreeNode rightNode) {
+        this.rightNode = rightNode;
+    }
+
+    public TreeNode beforeSearch(int value) {
+        if(this.value == value){
+            return this;
+        }
+        if(this.leftNode !=null){
+           TreeNode temp = leftNode.beforeSearch(value);
+            if(temp!=null){
+                return temp;
+            }
+
+        }
+        if(this.rightNode !=null) {
+            TreeNode temp =rightNode.beforeSearch(value);
+            if(temp !=null){
+                return temp;
+            }
+
+        }
+        return null;
+    }
+
+    public TreeNode middleSearch(int value) {
+
+        if(leftNode !=null){
+            TreeNode temp = leftNode.middleSearch(value);
+            if(temp !=null){
+                return temp;
+            }
+        }
+        if(this.value == value ){
+            return this;
+        }
+        if(rightNode !=null){
+            TreeNode temp = rightNode.middleSearch(value);
+            if(temp !=null){
+                return temp;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * 后序查找
+     * @param value
+     * @return
+     */
+    public TreeNode afterSearch(int value) {
+        TreeNode temp =null;
+        if(this.leftNode !=null){
+            temp =leftNode.afterSearch(value);
+            if(temp !=null){
+                return temp;
+            }
+        }
+
+        if(this.rightNode !=null){
+            temp = rightNode.afterSearch(value);
+            if(temp !=null){
+                return temp;
+            }
+        }
+        if(this.value == value){
+            return this;
+        }
+        return temp;
+    }
+
+    public void delete(int i) {
+
+
+        if(leftNode!=null&&leftNode.getValue()==i){
+            leftNode =null;
+        }
+        if(rightNode!=null&&rightNode.getValue()==i){
+            rightNode=null;
+        }
+        if(leftNode!=null){
+            leftNode.delete(i);
+        }
+        if(rightNode !=null){
+            rightNode.delete(i);
+        }
+    }
+
+    public void middle() {
+
+        System.out.println(this.value);
+
+        if(this.leftNode!=null){
+            leftNode.middle();
+        }
+        if(this.rightNode!=null){
+            rightNode.middle();
+        }
+    }
+}