diff --git a/BinaryTree.java b/BinaryTree.java
new file mode 100644
index 0000000000000000000000000000000000000000..89015d9747550223ae28db43aaafd2563da90817
--- /dev/null
+++ b/BinaryTree.java
@@ -0,0 +1,210 @@
+// 写层序遍历用
+
+import java.util.Queue;
+import java.util.LinkedList;
+
+public class BinaryTree<T extends Comparable> {
+    public Node<T> root;
+
+    BinaryTree() {
+        root = null;
+    }
+
+    //插入
+    public void insert(T val) {
+        Node<T> newNode = new Node<T>(val);
+        if (root == null) {
+            root = newNode;
+            return;
+        }
+        Node<T> markNode = root;
+        Node<T> underNode;
+        while (true) {
+            underNode = markNode;
+            if (newNode.value.compareTo(markNode.value) > 0) {
+                //进入右节点
+                markNode = markNode.right;
+                if (markNode == null) {
+                    underNode.right = newNode;
+                    return;
+                }
+            } else {
+                //进入左节点
+                markNode = markNode.left;
+                if (markNode == null) {
+                    underNode.left = newNode;
+                    return;
+                }
+            }
+        }
+    }
+
+    //查找
+    public boolean select(T val) {
+        if (root == null) {
+            return false;
+        }
+        Node<T> markNode = root;
+        while (true) {
+            if (markNode.value.compareTo(val) == 0) {
+                return true;
+            }
+            if (val.compareTo(markNode.value) > 0) {
+                //进入右节点
+                markNode = markNode.right;
+            } else {
+                //进入左节点
+                markNode = markNode.left;
+            }
+            if (markNode == null) {
+                return false;
+            }
+        }
+    }
+
+    //删除
+    public boolean remove(T val) {
+        if (root == null) {
+            return false;
+        }
+        Node<T> markNode = root;
+        Node<T> underNode = null;
+        while (true) {
+            if (markNode.value.equals(val)) {
+                //找到节点进行删除操作
+                if (markNode.right == null && markNode.left == null) {
+                    //1.无子节点
+                    if (underNode == null) {
+                        //删除根节点 无子节点
+                        root = null;
+                        return true;
+                    }
+                    if (underNode.left == markNode) {
+                        underNode.left = null;
+                    } else {
+                        underNode.right = null;
+                    }
+
+                } else if (markNode.right == null || markNode.left == null) {
+                    //2.有一个子节点
+                    Node<T> newNode = null;
+                    if (markNode.right != null) {
+                        //右节点存在
+                        newNode = markNode.right;
+                    } else {
+                        //左节点存在
+                        newNode = markNode.left;
+                    }
+                    if (underNode == null) {
+                        //删除根节点 有一个子节点
+                        root = newNode;
+                        return true;
+                    }
+                    if (underNode.left == markNode) {
+                        underNode.left = newNode;
+                    } else {
+                        underNode.right = newNode;
+                    }
+
+                } else {
+                    //3.有两个子节点
+                    //左找最大
+                    Node<T> maxNode = markNode.left;
+                    Node<T> topNode = null;
+                    while (maxNode.right != null) {
+                        topNode = maxNode;
+                        maxNode = maxNode.right;
+                    }
+                    //移除最大节点
+                    if (topNode != null) {
+                        topNode.right = maxNode.left;
+                    } else {
+                        markNode.left = maxNode.left;
+                    }
+                    markNode.value = maxNode.value;
+                }
+                return true;
+            }
+            underNode = markNode;
+            if (val.compareTo(markNode.value) > 0) {
+                //进入右节点
+                markNode = markNode.right;
+            } else {
+                //进入左节点
+                markNode = markNode.left;
+            }
+            if (markNode == null) {
+                return false;
+            }
+        }
+    }
+
+
+    public void preOrder() {
+        preOrderTraversal(root);
+    }
+
+    //根左右
+    private void preOrderTraversal(Node tree) {
+        if (tree != null) {
+            // 打印自身
+            System.out.print(tree.value + " ");
+            // 打印10左子树
+            preOrderTraversal(tree.left);
+            // 打印右子树
+            preOrderTraversal(tree.right);
+        }
+    }
+
+    public void inOrder() {
+        inOrderTraversal(root);
+    }
+
+    // 左根右
+    private void inOrderTraversal(Node tree) {
+        if (tree != null) {
+            // 打印左子树
+            inOrderTraversal(tree.left);
+            // 打印自身
+            System.out.print(tree.value + " ");
+            // 打印右子树
+            inOrderTraversal(tree.right);
+        }
+    }
+
+    public void postOrder() {
+        postOrderTraversal(root);
+    }
+
+    //左右根
+    private void postOrderTraversal(Node tree) {
+        if (tree != null) {
+            // 打印左子树
+            postOrderTraversal(tree.left);
+            // 打印右子树
+            postOrderTraversal(tree.right);
+            // 打印自身
+            System.out.print(tree.value + " ");
+        }
+    }
+
+    public void level() {
+        if (root == null) {
+            return;
+        }
+        Queue<Node> queue = new LinkedList<>();
+        queue.add(root);
+        while (!queue.isEmpty()) {
+            Node<T> item = queue.remove();
+            System.out.print(item.value + " ");
+            if (item.left != null) {
+                queue.add(item.left);
+            }
+            if (item.right != null) {
+                queue.add(item.right);
+            }
+        }
+    }
+
+
+}
\ No newline at end of file
diff --git a/Main.java b/Main.java
new file mode 100644
index 0000000000000000000000000000000000000000..d48e8edf27fb7e82c1e7400093764a60f54f867e
--- /dev/null
+++ b/Main.java
@@ -0,0 +1,85 @@
+class Main {
+	public static void main(String[] args){
+		// 构造了一个空树
+		BinaryTree<Integer> bt = new BinaryTree<Integer>();
+	/*
+	*        10
+	*     5      15
+	*   3   7  12   20
+	* preOrder: 10 5 3 7 15 12 20
+	*/		
+//		bt.root = new Node<String>("10");
+//		Node<String> left1 = new Node<String>(5);
+//		bt.root.left = left1;
+//		Node<String> right1 = new Node<String>(15);
+//		bt.root.right = right1;
+//
+//		Node<String> left21 = new Node<String>(3);
+//		left1.left = left21;
+//		Node<String> left22 = new Node<String>(7);
+//		left1.right = left22;
+//
+//		Node<Integer> left23 = new Node<Integer>(12);
+//		Node<Integer> left24 = new Node<Integer>(20);
+//		right1.left = left23;
+//		right1.right = left24;
+
+
+		bt.insert(10);
+		bt.insert(5);
+		bt.insert(15);
+		bt.insert(3);
+		bt.insert(7);
+		bt.insert(12);
+		bt.insert(20);
+
+
+		bt.preOrder();
+		System.out.println();
+		bt.inOrder();
+		System.out.println();
+		bt.postOrder();
+		System.out.println();
+		bt.level();
+		System.out.println();
+		System.out.println("查询10是否存在"+bt.select(10));
+		System.out.println("查询20是存在"+bt.select(20));
+		System.out.println("查询30是存在"+bt.select(30));
+		System.out.println("查询40是存在"+bt.select(40));
+		bt.level();
+		System.out.println();
+		bt.remove(10);
+		bt.level();
+		System.out.println();
+		bt.remove(15);
+		bt.level();
+
+
+		System.out.println("进阶部分*******************************");
+
+		// 构造了一个空树
+		ParentBinaryTree<Integer> parentBinaryTree = new ParentBinaryTree<Integer>();
+		/*
+		 *        10
+		 *     5      15
+		 *   3   7  12   20
+		 */
+		parentBinaryTree.insert(10);
+		parentBinaryTree.insert(5);
+		parentBinaryTree.insert(15);
+		parentBinaryTree.insert(3);
+		parentBinaryTree.insert(7);
+		parentBinaryTree.insert(12);
+		parentBinaryTree.insert(20);
+		parentBinaryTree.inOrder();//中序
+		System.out.println();
+		parentBinaryTree.outputPredecessorSuccessor(7);
+		parentBinaryTree.outputPredecessorSuccessor(10);
+		parentBinaryTree.outputPredecessorSuccessor(12);
+
+
+
+
+
+	}
+}
\ No newline at end of file
diff --git a/Node.java b/Node.java
new file mode 100644
index 0000000000000000000000000000000000000000..d845786d309c0b0af9a216623da716af48f1af1d
--- /dev/null
+++ b/Node.java
@@ -0,0 +1,11 @@
+public class Node<T> {
+	public T value;
+	public Node left;
+	public Node right;
+
+	Node(T val){
+		value = val;
+		left = null;
+		right = null;
+	}
+}
\ No newline at end of file
diff --git a/PNode.java b/PNode.java
new file mode 100644
index 0000000000000000000000000000000000000000..ff17bfba96e9c491a98218c5d0fe120cecd5d95a
--- /dev/null
+++ b/PNode.java
@@ -0,0 +1,14 @@
+public class PNode<T> {
+
+    public T value;
+    public PNode left;
+    public PNode right;
+    public PNode parent;
+
+    PNode(T val) {
+        value = val;
+        left = null;
+        right = null;
+        parent = null;
+    }
+}
diff --git a/ParentBinaryTree.java b/ParentBinaryTree.java
new file mode 100644
index 0000000000000000000000000000000000000000..89f01affacfd404814cb9b53866be65cfaa77a12
--- /dev/null
+++ b/ParentBinaryTree.java
@@ -0,0 +1,138 @@
+public class ParentBinaryTree<T extends Comparable> {
+
+    public PNode<T> root;
+
+    ParentBinaryTree() {
+        root = null;
+    }
+
+    //插入
+    public void insert(T val) {
+        PNode<T> newPNode = new PNode<T>(val);
+        if (root == null) {
+            root = newPNode;
+            return;
+        }
+        PNode<T> markNode = root;
+        PNode<T> underNode;
+        while (true) {
+            underNode = markNode;
+            if (newPNode.value.compareTo(markNode.value) > 0) {
+                //进入右节点
+                markNode = markNode.right;
+                if (markNode == null) {
+                    underNode.right = newPNode;
+                    newPNode.parent = underNode;
+                    return;
+                }
+            } else {
+                //进入左节点
+                markNode = markNode.left;
+                if (markNode == null) {
+                    underNode.left = newPNode;
+                    newPNode.parent = underNode;
+                    return;
+                }
+            }
+        }
+    }
+
+    //中序 左根右
+    public void inOrder() {
+        inOrderTraversal(root);
+    }
+
+    private void inOrderTraversal(PNode<T> tree) {
+        if (tree != null) {
+            // 打印左子树
+            inOrderTraversal(tree.left);
+            // 打印自身
+            System.out.print(tree.value + " ");
+            // 打印右子树
+            inOrderTraversal(tree.right);
+        }
+    }
+
+    // 输出 前驱 后继
+    public void outputPredecessorSuccessor(T val){
+        if (root == null) {
+            System.out.println("空树");
+            return ;
+        }
+        PNode<T> markNode = root;
+        while (true) {
+            if (markNode.value.compareTo(val) == 0) {
+                PNode<T> precursor = precursor(markNode);
+                PNode<T> succeed = succeed(markNode);
+                System.out.println(val+"的节点的前驱："+precursor.value+"后继："+succeed.value);
+                return ;
+            }
+            if (val.compareTo(markNode.value) > 0) {
+                //进入右节点
+                markNode = markNode.right;
+            } else {
+                //进入左节点
+                markNode = markNode.left;
+            }
+            if (markNode == null) {
+                System.out.println("未找到该节点");
+                return ;
+            }
+        }
+
+
+    }
+
+
+
+    //后继
+    public PNode<T> succeed(PNode item) {
+        if (item == null) {
+            return null;
+        }
+        if (item.right != null) {
+            return minNode(item.right);
+        }
+        //右节点不存在
+        PNode parentNode = item.parent;
+        while (parentNode != null && item == parentNode.right) {
+            item = parentNode;
+            parentNode = parentNode.parent;
+        }
+        return parentNode;
+    }
+
+    //前驱
+    public PNode<T> precursor(PNode item) {
+        if (item == null) {
+            return null;
+        }
+        if (item.left != null) {
+            return maxNode(item.left);
+        }
+        //右节点不存在
+        PNode parentNode = item.parent;
+        while (parentNode != null && item == parentNode.left) {
+            item = parentNode;
+            parentNode = parentNode.parent;
+        }
+        return parentNode;
+    }
+
+    //最大节点
+    private PNode<T> maxNode(PNode item) {
+        while (item.right != null) {
+            item = item.right;
+        }
+        return item;
+    }
+
+    //最小节点
+    private PNode<T> minNode(PNode item) {
+        while (item.left != null) {
+            item = item.left;
+        }
+        return item;
+    }
+
+}