zl的第一周作业提交

group24/798277403/src/week1/ArrayList.java

@@ -0,0 +1,147 @@
+package week1;
+
+import java.util.Arrays;
+
+/**
+ java泛型：
+ ？ 表示不确定的java类型。
+ T  表示java类型。
+ K V 分别代表java键值中的Key Value。
+ E 代表Element。
+
+ * 自己实现的ArrayList
+ * Created by zhouliang on 2017-03-10.
+ */
+class ArrayList<E> implements List<E> {
+
+    private Object[] elementData;
+
+    private int size;
+
+    public ArrayList(int size){
+        this.elementData = new Object[size];
+    }
+
+    //默认大小为10
+    public ArrayList(){
+        this.elementData = new Object[10];
+    }
+
+    //判断是否需要扩展容量  ((旧容量 * 3) / 2) + 1
+    private void checkcapacity(int index){
+        if(index>elementData.length){
+            int length = (elementData.length*3)/2+1;
+            /*
+            Object[] temp = new Object[length];
+            for(int i=0; i<elementData.length; i++){
+                temp[i] = elementData[i];
+            }
+            elementData = temp;
+            */
+            elementData = Arrays.copyOf(elementData,length);
+
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    private E elementData(int index){
+        return  (E) elementData[index];
+    }
+
+    @Override
+    public void add(E e) {
+        //确保elementData的长度是否足够大
+        checkcapacity(size+1);
+
+        elementData[size]=e;
+        size++;
+    }
+
+    @Override
+    public void add(int index, E e) {
+
+        checkPositionIndex(index);
+        //确保elementData的长度是否足够大
+        checkcapacity(size+1);
+
+        elementData[index] = e;
+    }
+
+    @Override
+    public E get(int index) {
+        checkElementIndex(index);
+
+        return elementData(index);
+    }
+
+    @Override
+    public E remove(int index) {
+        checkElementIndex(index);
+
+        E e = elementData(index);
+
+        //如果是最后一个元素直接去掉
+        if(index == size-1){
+            elementData[index] = null;
+        }else{
+            for(int i=index; i<size; i++){
+                elementData[i]=elementData[i+1];
+            }
+        }
+        size--;
+        return e;
+    }
+
+    @Override
+    public int size() {
+        return size;
+    }
+
+    private void checkElementIndex(int index) {
+        if (!isElementIndex(index)) {
+            throw new IndexOutOfBoundsException("Index: " + index + ", Size: "
+                    + size);
+        }
+    }
+
+    private boolean isElementIndex(int index) {
+        return index >= 0 && index < size;
+    }
+
+    private void checkPositionIndex(int index) {
+        if (!isPositionIndex(index)) {
+            throw new IndexOutOfBoundsException("Index: " + index + ", Size: "
+                    + size);
+        }
+    }
+
+    private boolean isPositionIndex(int index) {
+        return index >= 0 && index <= size;
+    }
+
+    public Iterator iterator() {
+        return new ArrayListIterator(this);
+    }
+
+    private class ArrayListIterator implements Iterator {
+        private ArrayList<E> list = null;
+        private int position = 0;
+
+        private ArrayListIterator(ArrayList<E> list) {
+            this.list = list;
+        }
+
+        @Override
+        public boolean hasNext() {
+            if ((position + 1) > size()) {
+                return false;
+            }
+            return true;
+        }
+
+        @Override
+        public E next() {
+            return list.get(position++);
+        }
+    }
+}

group24/798277403/src/week1/ArrayListTest.java

@@ -0,0 +1,55 @@
+package week1;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * Created by zhouliang on 2017-03-10.
+ */
+public class ArrayListTest {
+
+    private ArrayList<Integer> arrayList = new ArrayList<Integer>();
+
+    @Before
+    public void setUp(){
+        for(int i=0; i<100; i++){
+            arrayList.add(i);
+        }
+    }
+
+    @Test
+    public void add() throws Exception {
+        for(int i=100; i<1000; i++){
+            arrayList.add(i);
+        }
+        Assert.assertEquals(1000,arrayList.size());
+    }
+
+    @Test
+    public void add1() throws Exception {
+        java.util.LinkedList l = new java.util.LinkedList();
+    }
+
+    @Test
+    public void get() throws Exception {
+        System.out.println(arrayList.get(99));
+    }
+
+    @Test
+    public void remove() throws Exception {
+        System.out.println(arrayList.size());
+        arrayList.remove(arrayList.size()-1);
+        System.out.println(arrayList.size());
+        //Assert.assertEquals((Integer)99,(Integer)arrayList.size());
+    }
+
+    @Test
+    public void iterator() throws Exception {
+        Iterator iterator = arrayList.iterator();
+        while(iterator.hasNext()){
+            System.out.println(iterator.next());
+        }
+    }
+
+}

group24/798277403/src/week1/BinaryTree.java

@@ -0,0 +1,124 @@
+package week1;
+
+/**
+ * Created by zhouliang on 2017-03-11.
+ */
+class BinaryTree {
+    private TreeNode root;
+
+    class TreeNode {
+        int val = 0;
+        TreeNode left = null;
+        TreeNode right = null;
+        public TreeNode(int val) {
+            this.val = val;
+        }
+    }
+
+    /**
+     * 递归创建二叉树
+     * @param node
+     * @param data
+     */
+    public void buildTree(TreeNode node,int data){
+        if(root == null){
+            root = new TreeNode(data);
+        }else{
+            if(data < node.val){
+                if(node.left == null){
+                    node.left = new TreeNode(data);
+                }else{
+                    buildTree(node.left,data);
+                }
+            }else{
+                if(node.right == null){
+                    node.right = new TreeNode(data);
+                }else{
+                    buildTree(node.right,data);
+                }
+            }
+        }
+    }
+
+    /**
+     * 前序遍历
+     * @param node
+     */
+    public void preOrder(TreeNode node){
+        if(node != null){
+            System.out.println(node.val);
+            preOrder(node.left);
+            preOrder(node.right);
+        }
+    }
+
+    /**
+     * 中序遍历
+     * @param node
+     */
+    public void inOrder(TreeNode node){
+        if(node != null){
+            inOrder(node.left);
+            System.out.println(node.val);
+            inOrder(node.right);
+        }
+    }
+
+    /**
+     * 后序遍历
+     * @param node 一般是传入根节点
+     */
+    public void postOrder(TreeNode node){
+        if(node != null){
+            postOrder(node.left);
+            postOrder(node.right);
+            System.out.println(node.val);
+        }
+    }
+
+
+    /**
+     * 分层打印
+     * @param root 树的根节点
+     * @return 分层后的数组
+     */
+    public int[][] printTree(TreeNode root) {
+        if(root == null){
+            return null;
+        }
+        java.util.LinkedList<TreeNode> queue = new java.util.LinkedList<TreeNode>();
+        TreeNode last = root;
+        TreeNode nlast = null ;
+        TreeNode currentNode = null;
+        java.util.ArrayList<java.util.ArrayList<Integer>> lists = new java.util.ArrayList<java.util.ArrayList<Integer>>();
+        java.util.ArrayList<Integer> list = new java.util.ArrayList<Integer>();
+        queue.add(last);
+        while(!queue.isEmpty()){
+            currentNode = queue.poll();
+            list.add(currentNode.val);
+
+            if(currentNode.left!=null){
+                queue.add(currentNode.left);
+                nlast = currentNode.left;
+            }
+            if(currentNode.right!=null){
+                queue.add(currentNode.right);
+                nlast = currentNode.right;
+            }
+            if(currentNode == last){
+                lists.add(list);
+                last = nlast;
+                list = new java.util.ArrayList<Integer>();
+            }
+        }
+
+        int[][] result = new int[lists.size()][];
+        for(int i = 0 ; i < lists.size() ; i++){
+            result[i] = new int[lists.get(i).size()];
+            for(int j = 0 ; j < lists.get(i).size() ; j++){
+                result[i][j] = lists.get(i).get(j);
+            }
+        }
+        return result;
+    }
+}