diff --git a/group24/75939388/learning2017/src/main/java/basic/dataStructure/BinaryTreeNode.java b/group24/75939388/learning2017/src/main/java/basic/dataStructure/BinaryTreeNode.java deleted file mode 100644 index 5050ae3c95..0000000000 --- a/group24/75939388/learning2017/src/main/java/basic/dataStructure/BinaryTreeNode.java +++ /dev/null @@ -1,58 +0,0 @@ -package basic.dataStructure; - -/** - * Created by macvi on 2017/4/4. - */ -public class BinaryTreeNode { - private int data; - private BinaryTreeNode left; - private BinaryTreeNode right; - - private BinaryTreeNode(){} - - public BinaryTreeNode(int data){ - this.data = data; - this.left = null; - this.right = null; - } - - public void setData(int data){ - BinaryTreeNode node = new BinaryTreeNode(data); - if(compareTo(data)){ - if(this.left == null){ - this.left = node; - }else{ - this.left.setData(data); - } - }else{ - if(this.right == null){ - this.right = node; - }else{ - this.right.setData(data); - } - } - } - - public int getData(){ - return data; - } - - private boolean compareTo(int d) { - System.out.println("data=" + this.data + ", d=" + d); - return this.data > d; - } - - private StringBuffer dataStr = new StringBuffer(); - private int index = 0; -// public String toString(BinaryTreeNode node) { -// while (node.left != null || node.right != null){ -// dataStr.append(index + "层，数据=").append(node.data).append("|"); -// if(node.left != null){ -// dataStr.append(node.left.data) -// } -// index ++; -// } -// -// return dataStr.toString(); -// } -} diff --git a/group24/75939388/learning2017/src/main/java/basic/dataStructure/binaryTree/BinaryTreeNode.java b/group24/75939388/learning2017/src/main/java/basic/dataStructure/binaryTree/BinaryTreeNode.java new file mode 100644 index 0000000000..b2b96c0349 --- /dev/null +++ b/group24/75939388/learning2017/src/main/java/basic/dataStructure/binaryTree/BinaryTreeNode.java @@ -0,0 +1,104 @@ +package basic.dataStructure.binaryTree; + +/** + * Created by macvi on 2017/4/4. + */ +public class BinaryTreeNode { +// private T data; +// private BinaryTreeNode left; +// private BinaryTreeNode right; +// private BinaryTreeNode before; +// +// private BinaryTreeNode(){} +// +// public BinaryTreeNode(T data){ +// this.data = data; +// this.left = null; +// this.right = null; +// } +// +// public void setData(int data){ +// BinaryTreeNode node = new BinaryTreeNode(data); +// if(compareTo(data)){ +// if(this.left == null){ +// this.left = node; +// }else{ +// this.left.setData(data); +// } +// }else{ +// if(this.right == null){ +// this.right = node; +// }else{ +// this.right.setData(data); +// } +// } +// } +// +// public BinaryTreeNode getLeft() { +// return left; +// } +// +// public void setLeft(BinaryTreeNode left) { +// this.left = left; +// } +// +// public BinaryTreeNode getRight() { +// return right; +// } +// +// public void setRight(BinaryTreeNode right) { +// this.right = right; +// } +// +// public T getData(){ +// return data; +// } +// +// private boolean compareTo(int d) { +// System.out.println("data=" + this.data + ", d=" + d); +// return (Integer)this.data > d; +// } +// +// private StringBuffer dataStr = new StringBuffer(); +// private int index = 0; +//// public String toString(BinaryTreeNode node) { +//// while (node.left != null || node.right != null){ +//// dataStr.append(index + "层，数据=").append(node.data).append("|"); +//// if(node.left != null){ +//// dataStr.append(node.left.data) +//// } +//// index ++; +//// } +//// +//// return dataStr.toString(); +//// } + private T data; + private BinaryTreeNode left; + private BinaryTreeNode right; + + public BinaryTreeNode(T data){ + this.data=data; + } + public T getData() { + return data; + } + public void setData(T data) { + this.data = data; + } + public BinaryTreeNode getLeft() { + return left; + } + public void setLeft(BinaryTreeNode left) { + this.left = left; + } + public BinaryTreeNode getRight() { + return right; + } + public void setRight(BinaryTreeNode right) { + this.right = right; + } + + public BinaryTreeNode insert(Object o){ + return null; + } +} diff --git a/group24/75939388/learning2017/src/main/java/basic/dataStructure/binaryTree/BinaryTreeUtil.java b/group24/75939388/learning2017/src/main/java/basic/dataStructure/binaryTree/BinaryTreeUtil.java new file mode 100644 index 0000000000..182785b346 --- /dev/null +++ b/group24/75939388/learning2017/src/main/java/basic/dataStructure/binaryTree/BinaryTreeUtil.java @@ -0,0 +1,120 @@ +package basic.dataStructure.binaryTree; + +import java.util.ArrayList; +import java.util.List; +import java.util.Stack; + +public class BinaryTreeUtil { + /** + * 用递归的方式实现对二叉树的前序遍历， 需要通过BinaryTreeUtilTest测试 + * + * @param root + * @return + */ + public static List preOrderVisit(BinaryTreeNode root) { + List result = new ArrayList(); + + preOrder(root, result); + + return result; + } + + private static void preOrder(BinaryTreeNode tree, List result){ + if(tree == null) return; + result.add(tree.getData()); + + preOrder(tree.getLeft(), result); + preOrder(tree.getRight(), result); + } + + /** + * 用递归的方式实现对二叉树的中遍历 + * + * @param root + * @return + */ + public static List inOrderVisit(BinaryTreeNode root) { + List result = new ArrayList(); + inOrder(root, result); + return result; + } + + private static void inOrder(BinaryTreeNode tree, List result){ + if(tree == null) return; + + inOrder(tree.getLeft(), result); + result.add(tree.getData()); + inOrder(tree.getRight(), result); + } + + /** + * 用递归的方式实现对二叉树的后遍历 + * + * @param root + * @return + */ + public static List postOrderVisit(BinaryTreeNode root) { + List result = new ArrayList(); + postOrder(root, result); + return result; + } + + private static void postOrder(BinaryTreeNode tree, List result){ + if(tree == null) return; + + postOrder(tree.getLeft(), result); + postOrder(tree.getRight(), result); + result.add(tree.getData()); + } + + /** + * 用非递归的方式实现对二叉树的前序遍历 + * @param root + * @return + */ + public static List preOrderWithoutRecursion(BinaryTreeNode root) { + List result = new ArrayList(); + Stack buffer = new Stack(); + BinaryTreeNode tmp = root; + while(tmp != null){ + //遍历这一排的左边节点，右边节点入栈缓存 + BinaryTreeNode node = tmp; + while(node != null){ + result.add(node.getData()); + if(node.getRight() != null) buffer.add(node.getRight()); + node = node.getLeft(); + } + + //遍历右边 + //栈中没有节点则表示遍历结束 + if (buffer.isEmpty()) break; + + tmp = buffer.pop(); + } + + return result; + } + /** + * 用非递归的方式实现对二叉树的中序遍历 + * @param root + * @return + */ + public static List inOrderWithoutRecursion(BinaryTreeNode root) { + List result = new ArrayList(); + Stack buffer = new Stack(); + + BinaryTreeNode tmp = root; + while (tmp != null || !buffer.isEmpty()){ + while(tmp != null){ + buffer.push(tmp); + tmp = tmp.getLeft(); + } + + tmp = buffer.pop(); + result.add(tmp.getData()); + tmp = tmp.getRight(); + } + return result; + } + +} diff --git a/group24/75939388/learning2017/src/main/java/basic/dataStructure/binaryTree/FileList.java b/group24/75939388/learning2017/src/main/java/basic/dataStructure/binaryTree/FileList.java new file mode 100644 index 0000000000..7d7af85490 --- /dev/null +++ b/group24/75939388/learning2017/src/main/java/basic/dataStructure/binaryTree/FileList.java @@ -0,0 +1,10 @@ +package basic.dataStructure.binaryTree; + +import java.io.File; + +public class FileList { + public void list(File f) { + } + + +} diff --git a/group24/75939388/learning2017/src/test/java/data_structure/binaryTree/BinaryTreeUtilTest.java b/group24/75939388/learning2017/src/test/java/data_structure/binaryTree/BinaryTreeUtilTest.java new file mode 100644 index 0000000000..09b50a1148 --- /dev/null +++ b/group24/75939388/learning2017/src/test/java/data_structure/binaryTree/BinaryTreeUtilTest.java @@ -0,0 +1,77 @@ +package data_structure.binaryTree; + +import basic.dataStructure.binaryTree.BinaryTreeNode; +import basic.dataStructure.binaryTree.BinaryTreeUtil; +import org.junit.After; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + +import java.util.List; + + + +public class BinaryTreeUtilTest { + + BinaryTreeNode root = null; + @Before + public void setUp() throws Exception { + root = new BinaryTreeNode(1); + root.setLeft(new BinaryTreeNode(2)); + root.setRight(new BinaryTreeNode(5)); + root.getLeft().setLeft(new BinaryTreeNode(3)); + root.getLeft().setRight(new BinaryTreeNode(4)); + } + + @After + public void tearDown() throws Exception { + } + + @Test + public void testPreOrderVisit() { + + List result = BinaryTreeUtil.preOrderVisit(root); + Assert.assertEquals("[1, 2, 3, 4, 5]", result.toString()); + + + } + @Test + public void testInOrderVisit() { + + + List result = BinaryTreeUtil.inOrderVisit(root); + Assert.assertEquals("[3, 2, 4, 1, 5]", result.toString()); + + } + + @Test + public void testPostOrderVisit() { + + + List result = BinaryTreeUtil.postOrderVisit(root); + Assert.assertEquals("[3, 4, 2, 5, 1]", result.toString()); + + } + + + @Test + public void testInOrderVisitWithoutRecursion() { + BinaryTreeNode node = root.getLeft().getRight(); + node.setLeft(new BinaryTreeNode(6)); + node.setRight(new BinaryTreeNode(7)); + + List result = BinaryTreeUtil.inOrderWithoutRecursion(root); + Assert.assertEquals("[3, 2, 6, 4, 7, 1, 5]", result.toString()); + + } + @Test + public void testPreOrderVisitWithoutRecursion() { + BinaryTreeNode node = root.getLeft().getRight(); + node.setLeft(new BinaryTreeNode(6)); + node.setRight(new BinaryTreeNode(7)); + + List result = BinaryTreeUtil.preOrderWithoutRecursion(root); + Assert.assertEquals("[1, 2, 3, 4, 6, 7, 5]", result.toString()); + + } +} diff --git a/group24/75939388/learning2017/src/test/java/data_structure/list/BinaryNodeTreeTest.java b/group24/75939388/learning2017/src/test/java/data_structure/list/BinaryNodeTreeTest.java index f5648c6596..0d14cdbd8c 100644 --- a/group24/75939388/learning2017/src/test/java/data_structure/list/BinaryNodeTreeTest.java +++ b/group24/75939388/learning2017/src/test/java/data_structure/list/BinaryNodeTreeTest.java @@ -1,7 +1,7 @@ package data_structure.list; import org.junit.Test; -import basic.dataStructure.BinaryTreeNode; +import basic.dataStructure.binaryTree.BinaryTreeNode; /** * @author : 温友朝