diff --git a/shujujiegou/Tree.iml b/shujujiegou/Tree.iml
new file mode 100644
index 0000000..9465dd8
--- /dev/null
+++ b/shujujiegou/Tree.iml
@@ -0,0 +1,11 @@
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/shujujiegou/src/com/lmk/arraybinarytree/ArrayBinaryTree.java b/shujujiegou/src/com/lmk/arraybinarytree/ArrayBinaryTree.java
new file mode 100644
index 0000000..a7d2909
--- /dev/null
+++ 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-1){
+ return;
+ }
+ if(2*index +1this.root.length-1){
+ return;
+ }
+ if(2*index+1arr[max]){
+ max = left;
+ }
+
+ //如果右节点数大于最大值，最大值为右节点
+ if(rightarr[max]){
+ max = right;
+ }
+ //最大值不等于当前节点，交换位置
+ if(max!=currentparents){
+ int temp = arr[max];
+ arr[max] = arr [currentparents];
+ arr[currentparents] = temp;
+ //继续排序
+ maxHead(arr,size,max);
+ }
+ }
+
+ }
+
+
+ /**
+ *
+ * @param arr 数组
+ * @param size 排序的长度
+ */
+ public void sortHead(int[] arr,int size){
+
+
+ for(int i =size-1;i>=0;i--){
+ //父节点位置
+ int start = (i-1)/2;
+ maxHead(arr,size,start);
+ }
+ }
+
+ /**
+ *
+ * @param arr 待排序数组
+ */
+ public void sortSwapHead(int[] arr){
+
+ for(int i = 0;i=0;i--){
+// h.heapSort(sortarrray,i);
+// System.out.println(Arrays.toString(sortarrray));
+// }
+
+ for (int i = 0; i < sortarrray.length; i++) {
+
+ //每次建堆就可以排除一个元素了
+ h.heapSort(sortarrray, sortarrray.length - i);
+
+ //交换
+ int temp = sortarrray[0];
+ sortarrray[0] = sortarrray[(sortarrray.length - 1) - i];
+ sortarrray[(sortarrray.length - 1) - i] = temp;
+
+ }
+ System.out.println(Arrays.toString(sortarrray));
+
+
+ }
+
+
+ public void heapSort(int arr[],int size){
+// int start = (arr.length-1)/2;
+// for(int i = start;i>0;i--){
+// maxHeap(arr,i,arr.length);
+// }
+// int temp =arr[0];
+// arr[0]=arr[size];
+
+ for (int i = size - 1; i >= 0; i--) {
+ maxHeap(arr, (i-1)/2, size);
+ }
+
+ }
+ int[] waitSortArray = new int[]{7,2,4,5,6,2};
+ /**
+ * 7
+ * 2 6
+ * 3 0 2 5
+ * 8 9
+ */
+
+ /**
+ *
+ * @param arr 数组
+ * @param currentRootIndex 当前节点父节点的位置
+ * @param size 节点总数
+ */
+ public void maxHeap(int arr[],int currentRootIndex,int size){
+
+ if(currentRootIndex list =new ArrayList<>();
+
+ for(int value:arr){
+ list.add(new Node(value));
+ }
+ //当集合中只有一个树时，他就是最优二叉树
+ while(list.size()>1){
+ System.out.println(list.size());
+ //排序
+ list.sort(Node::compareTo);
+ //去除最小的两个节点 最小的为左节点
+ Node left = list.get(0);
+ Node right = list.get(1);
+ //创建一个新的二叉树
+ Node newNode = new Node(left.getValue()+right.getValue());
+ newNode.setLeftNode(left);
+ newNode.setRightNode(right);
+ //移除两个最小的节点
+ list.remove(0);
+ list.remove(0);
+ //将新树添加到集合中
+ list.add(newNode);
+ }
+ return list.get(0);
+ }
+
+ public static void before(Node node){
+ node.before(node);
+ }
+}
diff --git a/shujujiegou/src/com/lmk/humantree/Node.java b/shujujiegou/src/com/lmk/humantree/Node.java
new file mode 100644
index 0000000..d08098e
--- /dev/null
+++ b/shujujiegou/src/com/lmk/humantree/Node.java
@@ -0,0 +1,68 @@
+package com.lmk.humantree;
+
+public class Node implements Comparable {
+
+ //值
+ private int value;
+
+ //左节点
+ private Node leftNode;
+
+ //右节点
+ private Node rightNode;
+
+ public Node(int value) {
+ this.value = value;
+ }
+
+ public int getValue() {
+ return value;
+ }
+
+ public void setValue(int value) {
+ this.value = value;
+ }
+
+ public Node getLeftNode() {
+ return leftNode;
+ }
+
+ public void setLeftNode(Node leftNode) {
+ this.leftNode = leftNode;
+ }
+
+ @Override
+ public String toString() {
+ return "Node{" +
+ "value=" + value +
+ '}';
+ }
+
+ public Node getRightNode() {
+ return rightNode;
+ }
+
+ public void setRightNode(Node rightNode) {
+ this.rightNode = rightNode;
+ }
+
+ @Override
+ public int compareTo(Object o) {
+ return this.value - ((Node)o).value;
+ }
+
+ public void before(Node node) {
+ if(node!=null){
+ System.out.println(node.getValue());
+
+ if(node.leftNode!=null){
+ before(node.leftNode);
+ }
+
+ if(node.rightNode!=null){
+ before(node.rightNode);
+ }
+ }
+
+ }
+}
diff --git a/shujujiegou/src/com/lmk/threadbinarytree/TestThreadBinaryTree.java b/shujujiegou/src/com/lmk/threadbinarytree/TestThreadBinaryTree.java
new file mode 100644
index 0000000..12f7009
--- /dev/null
+++ b/shujujiegou/src/com/lmk/threadbinarytree/TestThreadBinaryTree.java
@@ -0,0 +1,26 @@
+package com.lmk.threadbinarytree;
+
+public class TestThreadBinaryTree {
+ public static void main(String[] args) {
+ ThreadBinaryTree threadBinaryTree =new ThreadBinaryTree();
+
+ TreeNode node1 = new TreeNode(1);
+ TreeNode node2 = new TreeNode(2);
+ TreeNode node3 = new TreeNode(3);
+ TreeNode node4 = new TreeNode(4);
+ TreeNode node5 = new TreeNode(5);
+ TreeNode node6 = new TreeNode(6);
+ TreeNode node7 = new TreeNode(7);
+
+ threadBinaryTree.root = node1;
+ node1.leftNode=node2;
+ node1.rightNode = node3;
+ node2.leftNode = node4;
+ node2.rightNode = node5;
+ node3.leftNode =node6;
+ node3.rightNode = node7;
+ threadBinaryTree.threadBinaryTree();
+ System.out.println(node4.rightNode.value);
+ System.out.println(node5.leftNode.value);
+ }
+}
diff --git a/shujujiegou/src/com/lmk/threadbinarytree/ThreadBinaryTree.java b/shujujiegou/src/com/lmk/threadbinarytree/ThreadBinaryTree.java
new file mode 100644
index 0000000..65215be
--- /dev/null
+++ b/shujujiegou/src/com/lmk/threadbinarytree/ThreadBinaryTree.java
@@ -0,0 +1,52 @@
+package com.lmk.threadbinarytree;
+
+
+
+/**
+ * 线索二叉树
+ *
+ */
+public class ThreadBinaryTree {
+
+ TreeNode root;
+ //存储前一个结点
+ TreeNode preNode;
+
+ public void threadBinaryTree(){
+ if(root!=null){
+ threadBinaryTree(root);
+ }
+
+ }
+ //中序线索二叉树
+ public void threadBinaryTree( TreeNode node){
+ //左节点
+ if(node.leftNode!=null){
+ threadBinaryTree(node.leftNode);
+ }
+
+ //根
+ //左节点为空，指向前一个节点，flag变为1
+ if(node.leftNode==null){
+ node.leftNode = preNode;
+ node.leftFlag=1;
+ }
+ //如果前一个节点为空，使其指向本节点（即右节点指向后一个节点）
+ if(preNode!=null&&preNode.rightNode==null){
+ preNode.rightNode=node;
+ preNode.rightFlag=1;
+ }
+
+ preNode = node;
+ //右节点
+ if(node.rightNode!=null){
+ threadBinaryTree(node.rightNode);
+ }
+ }
+
+
+
+
+
+
+}
diff --git a/shujujiegou/src/com/lmk/threadbinarytree/TreeNode.java b/shujujiegou/src/com/lmk/threadbinarytree/TreeNode.java
new file mode 100644
index 0000000..de4822f
--- /dev/null
+++ b/shujujiegou/src/com/lmk/threadbinarytree/TreeNode.java
@@ -0,0 +1,13 @@
+package com.lmk.threadbinarytree;
+
+public class TreeNode {
+
+ public TreeNode(int value){
+ this.value = value;
+ }
+ int value;
+ TreeNode leftNode;
+ int leftFlag;
+ TreeNode rightNode;
+ int rightFlag;
+}