diff --git a/group24/1148285693/.gitignore b/group24/1148285693/.gitignore new file mode 100644 index 0000000000..8e0951ea09 --- /dev/null +++ b/group24/1148285693/.gitignore @@ -0,0 +1,36 @@ +# Mobile Tools for Java (J2ME) +.mtj.tmp/ + +# Package Files +*.war +*.ear +*.bk +.gradle +target +*.class +*.real + +# virtual machine crash logs +# see http://www.java.com/en/download/help/error_hotspot.xml +hs_err_pid* + +# Eclipse Files # +.project +.classpath +.settings + +# Idea +*.iml +*.ipr +*.iws +.idea + +# log +*_IS_UNDEFINED +logs +*.log + +# other +*.bak +.directory +.DS_Store \ No newline at end of file diff --git a/group24/1148285693/learning2017/learning-basic/pom.xml b/group24/1148285693/learning2017/learning-basic/pom.xml new file mode 100644 index 0000000000..7cb5cfb3f0 --- /dev/null +++ b/group24/1148285693/learning2017/learning-basic/pom.xml @@ -0,0 +1,22 @@ + + + 4.0.0 + + + + learning2017 + me.lzb + 1.0 + + + + learning-basic + basic + 1.0 + + + + + diff --git a/group24/1148285693/learning2017/learning-basic/src/main/java/me/lzb/homework0312/basic/ArrayList.java b/group24/1148285693/learning2017/learning-basic/src/main/java/me/lzb/homework0312/basic/ArrayList.java new file mode 100644 index 0000000000..c93b6c76e0 --- /dev/null +++ b/group24/1148285693/learning2017/learning-basic/src/main/java/me/lzb/homework0312/basic/ArrayList.java @@ -0,0 +1,96 @@ +package me.lzb.homework0312.basic; + +/** + * 简易ArrayList + * Created by LZB on 2017/3/11. + */ +public class ArrayList implements List { + + private int size = 0; + + private Object[] elementData = {}; + + + public void add(Object o) { + if (elementData.length < size + 1) { + Object[] target = new Object[size + 1]; + System.arraycopy(elementData, 0, target, 0, elementData.length); + elementData = target; + } + elementData[size] = o; + size = size + 1; + } + + + public void add(int index, Object o) throws IndexOutOfBoundsException { + if (index < 0 || index > size) { + throw new IndexOutOfBoundsException("index boom"); + } + + int leftSize = index; + int rightSize = size - index; + Object[] target = new Object[elementData.length + 1]; + System.arraycopy(elementData, 0, target, 0, leftSize); + target[index] = o; + System.arraycopy(elementData, index, target, index + 1, rightSize); + elementData = target; + size = size + 1; + } + + public Object get(int index) throws IndexOutOfBoundsException { + if (index < 0 || index >= size) { + throw new IndexOutOfBoundsException("index boom"); + } + return elementData[index]; + } + + public Object remove(int index) throws IndexOutOfBoundsException { + if (index < 0 || index >= size) { + throw new IndexOutOfBoundsException("index boom"); + } + Object removeObject = elementData[index]; + int leftSize = index; + int rightSize = size - index - 1; + Object[] target = new Object[elementData.length - 1]; + System.arraycopy(elementData, 0, target, 0, leftSize); + System.arraycopy(elementData, index + 1, target, index, rightSize); + elementData = target; + size = size - 1; + return removeObject; + } + + public int size() { + return size; + } + + + public Iterator iterator() { + return new ArrayListIterator(this); + } + + private class ArrayListIterator implements Iterator { + private ArrayList arrayList; + + int pos = 0; + + private ArrayListIterator(ArrayList arrayList) { + this.arrayList = arrayList; + } + + @Override + public boolean hasNext() { + if (pos >= arrayList.size) { + return false; + } + + return true; + } + + @Override + public Object next() { + Object result = arrayList.get(pos); + pos = pos + 1; + return result; + } + } +} diff --git a/group24/1148285693/learning2017/learning-basic/src/main/java/me/lzb/homework0312/basic/BinaryTreeNode.java b/group24/1148285693/learning2017/learning-basic/src/main/java/me/lzb/homework0312/basic/BinaryTreeNode.java new file mode 100644 index 0000000000..053baad0d4 --- /dev/null +++ b/group24/1148285693/learning2017/learning-basic/src/main/java/me/lzb/homework0312/basic/BinaryTreeNode.java @@ -0,0 +1,53 @@ +package me.lzb.homework0312.basic; + +/** + * 左边比父节点小，右边比父节点大 + * Created by LZB on 2017/3/11. + */ +public class BinaryTreeNode { + + private int data; + private BinaryTreeNode left; + private BinaryTreeNode right; + + public BinaryTreeNode(int data){ + this.data = data; + } + + public int getData() { + return data; + } + + + //这层满了就下一层继续add,直到找到空位 + public void add(int d){ + BinaryTreeNode b = new BinaryTreeNode(d); + if(compareTo(b)){ + //比父节点小，左边 + if(this.left == null){ + this.left = b; + }else { + this.left.add(d); + } + + }else {//相等不考虑 + //比父节点大，右边 + if(this.right == null){ + this.right = b; + }else { + this.right.add(d); + } + + } + } + + + public boolean compareTo(BinaryTreeNode node){ + if(this.data > node.getData()){ + return true; + } + return false; + } + + +} diff --git a/group24/1148285693/learning2017/learning-basic/src/main/java/me/lzb/homework0312/basic/Iterator.java b/group24/1148285693/learning2017/learning-basic/src/main/java/me/lzb/homework0312/basic/Iterator.java new file mode 100644 index 0000000000..138e090126 --- /dev/null +++ b/group24/1148285693/learning2017/learning-basic/src/main/java/me/lzb/homework0312/basic/Iterator.java @@ -0,0 +1,10 @@ +package me.lzb.homework0312.basic; + +/** + * Created by LZB on 2017/3/11. + */ +public interface Iterator { + public boolean hasNext(); + public Object next(); + +} diff --git a/group24/1148285693/learning2017/learning-basic/src/main/java/me/lzb/homework0312/basic/LinkedList.java b/group24/1148285693/learning2017/learning-basic/src/main/java/me/lzb/homework0312/basic/LinkedList.java new file mode 100644 index 0000000000..7b12d27c6c --- /dev/null +++ b/group24/1148285693/learning2017/learning-basic/src/main/java/me/lzb/homework0312/basic/LinkedList.java @@ -0,0 +1,266 @@ +package me.lzb.homework0312.basic; + + +/** + * 简易LinkedList + * Created by LZB on 2017/3/11. + */ +public class LinkedList implements List { + + private int size = 0; + + + private Node first; + + private Node last; + + + private static class Node { + Object data; + Node next; + + public Node(Object data, Node next) { + this.data = data; + this.next = next; + } + + } + + + public void add(Object o) { + if (first == null) { + first = new Node(o, null); + last = first; + } else { + Node n = new Node(o, null); + last.next = n; + last = n; + } + size = size + 1; + } + + + public void add(int index, Object o) throws IndexOutOfBoundsException { + if (index < 0 || index > size) { + throw new IndexOutOfBoundsException("index boom"); + } + + if (index == size) { + add(o); + return; + } + + if (index == 0) { + Node n = new Node(0, first); + first = n; + size = size + 1; + return; + } + + Node before = first; + for (int i = 0; i < index - 1; i++) { + before = before.next; + } + + Node after = before.next; + + Node n = new Node(o, after); + + before.next = n; + + size = size + 1; + + } + + + public Object get(int index) { + if (index < 0 || index >= size) { + throw new IndexOutOfBoundsException("index boom"); + } + Node result = first; + for (int i = 0; i < index; i++) { + result = result.next; + } + return result.data; + } + + + public Object remove(int index) { + if (index < 0 || index >= size) { + throw new IndexOutOfBoundsException("index boom"); + } + + if (size == 1) { + Node result = last; + last = null; + first = null; + size = size - 1; + return result.data; + } + + if (index == size - 1) { + Node result = last; + last = null; + size = size - 1; + return result.data; + } + + + if (index == 0) { + Node result = first; + Node second = first.next; + first = second; + size = size - 1; + return result.data; + } + + + Node before = first; + for (int i = 0; i < index - 1; i++) { + before = before.next; + } + Node result = before.next; + Node after = before.next.next; + before.next = after; + size = size - 1; + return result.data; + } + + public int size() { + return size; + } + + public void addFirst(Object o) { + add(0, o); + } + + + public void addLast(Object o) { + add(o); + } + + + public Object removeFirst() { + return remove(0); + } + + + public Object removeLast() { + return remove(size); + } + + + public Iterator iterator() { + return new LinkedListIterator(this); + } + + + private class LinkedListIterator implements Iterator { + private LinkedList linkedList; + + int pos = 0; + + private LinkedListIterator(LinkedList linkedList) { + this.linkedList = linkedList; + } + + @Override + public boolean hasNext() { + + if (pos >= linkedList.size) { + return false; + } + return true; + } + + @Override + public Object next() { + Object result = linkedList.get(pos); + pos = pos + 1; + return result; + } + } + + + //后面的方法先不用写的说 + + /** + * 把该链表逆置 + * 例如链表为 3->7->10 , 逆置后变为 10->7->3 + */ + public void reverse() { + + } + + /** + * 删除一个单链表的前半部分 + * 例如：list = 2->5->7->8 , 删除以后的值为 7->8 + * 如果list = 2->5->7->8->10 ,删除以后的值为7,8,10 + */ + public void removeFirstHalf() { + + } + + /** + * 从第i个元素开始， 删除length 个元素 ， 注意i从0开始 + * + * @param i + * @param length + */ + public void remove(int i, int length) { + + } + + /** + * 假定当前链表和list均包含已升序排列的整数 + * 从当前链表中取出那些list所指定的元素 + * 例如当前链表 = 11->101->201->301->401->501->601->701 + * listB = 1->3->4->6 + * 返回的结果应该是[101,301,401,601] + * + * @param list + */ + public static int[] getElements(LinkedList list) { + return null; + } + + /** + * 已知链表中的元素以值递增有序排列，并以单链表作存储结构。 + * 从当前链表中中删除在list中出现的元素 + * + * @param list + */ + + public void subtract(LinkedList list) { + + } + + /** + * 已知当前链表中的元素以值递增有序排列，并以单链表作存储结构。 + * 删除表中所有值相同的多余元素（使得操作后的线性表中所有元素的值均不相同） + */ + public void removeDuplicateValues() { + + } + + /** + * 已知链表中的元素以值递增有序排列，并以单链表作存储结构。 + * 试写一高效的算法，删除表中所有值大于min且小于max的元素（若表中存在这样的元素） + * + * @param min + * @param max + */ + public void removeRange(int min, int max) { + + } + + /** + * 假设当前链表和参数list指定的链表均以元素依值递增有序排列（同一表中的元素值各不相同） + * 现要求生成新链表C，其元素为当前链表和list中元素的交集，且表C中的元素有依值递增有序排列 + * + * @param list + */ + public LinkedList intersection(LinkedList list) { + return null; + } +} diff --git a/group24/1148285693/learning2017/learning-basic/src/main/java/me/lzb/homework0312/basic/List.java b/group24/1148285693/learning2017/learning-basic/src/main/java/me/lzb/homework0312/basic/List.java new file mode 100644 index 0000000000..bd66593efa --- /dev/null +++ b/group24/1148285693/learning2017/learning-basic/src/main/java/me/lzb/homework0312/basic/List.java @@ -0,0 +1,13 @@ +package me.lzb.homework0312.basic; + +/** + * list接口 + * Created by LZB on 2017/3/11. + */ +public interface List { + void add(Object o); + void add(int index, Object o); + Object get(int index); + Object remove(int index); + int size(); +} diff --git a/group24/1148285693/learning2017/learning-basic/src/main/java/me/lzb/homework0312/basic/Queue.java b/group24/1148285693/learning2017/learning-basic/src/main/java/me/lzb/homework0312/basic/Queue.java new file mode 100644 index 0000000000..50ea66f1a2 --- /dev/null +++ b/group24/1148285693/learning2017/learning-basic/src/main/java/me/lzb/homework0312/basic/Queue.java @@ -0,0 +1,31 @@ +package me.lzb.homework0312.basic; + +/** + * 先进先出 + * Created by LZB on 2017/3/11. + */ +public class Queue { + LinkedList elementData = new LinkedList(); + + public void enQueue(Object o){ + elementData.add(o); + } + + public Object deQueue() throws IndexOutOfBoundsException{ + if(isEmpty()){ + throw new IndexOutOfBoundsException("index boom"); + } + return elementData.remove(elementData.size() - 1); + } + + public boolean isEmpty(){ + if(elementData.size() <= 0){ + return true; + } + return false; + } + + public int size(){ + return elementData.size(); + } +} diff --git a/group24/1148285693/learning2017/learning-basic/src/main/java/me/lzb/homework0312/basic/Stack.java b/group24/1148285693/learning2017/learning-basic/src/main/java/me/lzb/homework0312/basic/Stack.java new file mode 100644 index 0000000000..4cd8d3dfd9 --- /dev/null +++ b/group24/1148285693/learning2017/learning-basic/src/main/java/me/lzb/homework0312/basic/Stack.java @@ -0,0 +1,49 @@ +package me.lzb.homework0312.basic; + +/** + * 先进后出 + * Created by LZB on 2017/3/11. + */ +public class Stack { + private ArrayList elementData = new ArrayList(); + + public void push(Object o) { + elementData.add(o); + } + + /** + * 获取最后进的那个，并删除 + * + * @return + */ + public Object pop() throws IndexOutOfBoundsException { + if (isEmpty()) { + throw new IndexOutOfBoundsException("index boom"); + } + + return elementData.remove(elementData.size() - 1); + } + + /** + * 返回最后进去的元素 + * + * @return + */ + public Object peek() throws IndexOutOfBoundsException { + if (isEmpty()) { + throw new IndexOutOfBoundsException("index boom"); + } + return elementData.get(elementData.size() - 1); + } + + public boolean isEmpty() { + if (elementData.size() <= 0) { + return true; + } + return false; + } + + public int size() { + return elementData.size(); + } +} diff --git a/group24/1148285693/learning2017/learning-basic/src/test/java/me/lzb/homework0312/basic/ArrayListTest.java b/group24/1148285693/learning2017/learning-basic/src/test/java/me/lzb/homework0312/basic/ArrayListTest.java new file mode 100644 index 0000000000..c35ed8d2b4 --- /dev/null +++ b/group24/1148285693/learning2017/learning-basic/src/test/java/me/lzb/homework0312/basic/ArrayListTest.java @@ -0,0 +1,113 @@ +package me.lzb.homework0312.basic; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.ExpectedException; + +/** + * ArrayList测试 + * Created by LZB on 2017/3/11. + */ + +public class ArrayListTest { + + private ArrayList arrayList; + + private String[] strArray; + + @Rule + public ExpectedException thrown = ExpectedException.none(); + + @Before + public void instantiate() throws Exception { + arrayList = new ArrayList(); + arrayList.add("a"); + arrayList.add("b"); + arrayList.add("c"); + arrayList.add("d"); + + strArray = new String[]{"a", "b", "c", "d"}; + } + + + @Test + public void sizeTest() { + Assert.assertEquals(4, arrayList.size(), 0); + } + + @Test + public void getTest() throws IndexOutOfBoundsException { + Assert.assertEquals("a", arrayList.get(0).toString()); + Assert.assertEquals("c", arrayList.get(2).toString()); + Assert.assertEquals("d", arrayList.get(3).toString()); + + thrown.expect(IndexOutOfBoundsException.class); + thrown.expectMessage("index boom"); + arrayList.get(100); + arrayList.get(-1); + } + + @Test + public void iteratoreTest(){ + Iterator iterator = arrayList.iterator(); + int a = 0; + while (iterator.hasNext()){ + Assert.assertEquals(strArray[a], iterator.next().toString()); + a = a + 1; + } + } + + + @Test + public void addTest() { + arrayList.add("f"); + Assert.assertEquals("f", arrayList.get(4).toString()); + } + + @Test + public void removeTest() throws IndexOutOfBoundsException { + + ArrayList list = new ArrayList(); + list.add("a"); + list.add("b"); + list.add("c"); + list.add("d"); + + + String r1 = list.remove(1).toString(); + Assert.assertEquals("b", r1); + Assert.assertEquals(3, list.size()); + + String r0 = list.remove(0).toString(); + Assert.assertEquals("a", r0); + Assert.assertEquals(2, list.size()); + + String rs = list.remove(list.size() - 1).toString(); + Assert.assertEquals("d", rs); + Assert.assertEquals(1, list.size()); + + thrown.expect(IndexOutOfBoundsException.class); + thrown.expectMessage("index boom"); + list.remove(100); + + } + + + @Test + public void addIndexTest() throws IndexOutOfBoundsException { + arrayList.add(0, "0"); + Assert.assertEquals("0", arrayList.get(0).toString()); + arrayList.add(arrayList.size(), "s"); + Assert.assertEquals("s", arrayList.get(arrayList.size() - 1).toString()); + arrayList.add(2, "2a"); + Assert.assertEquals("2a", arrayList.get(2).toString()); + + thrown.expect(IndexOutOfBoundsException.class); + thrown.expectMessage("index boom"); + arrayList.add(10, "10a"); + } + + +} diff --git a/group24/1148285693/learning2017/learning-basic/src/test/java/me/lzb/homework0312/basic/LinkedListTest.java b/group24/1148285693/learning2017/learning-basic/src/test/java/me/lzb/homework0312/basic/LinkedListTest.java new file mode 100644 index 0000000000..740d8768c7 --- /dev/null +++ b/group24/1148285693/learning2017/learning-basic/src/test/java/me/lzb/homework0312/basic/LinkedListTest.java @@ -0,0 +1,114 @@ +package me.lzb.homework0312.basic; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.ExpectedException; + + +/** + * linkedliksTest + * Created by LZB on 2017/3/11. + */ +public class LinkedListTest { + + private LinkedList linkedList; + + private String[] strArray; + + @Rule + public ExpectedException thrown = ExpectedException.none(); + + @Before + public void instantiate() throws Exception { + linkedList = new LinkedList(); + linkedList.add("a"); + linkedList.add("b"); + linkedList.add("c"); + linkedList.add("d"); + + strArray = new String[]{"a", "b", "c", "d"}; + } + + + @Test + public void iteratoreTest(){ + Iterator iterator = linkedList.iterator(); + int a = 0; + while (iterator.hasNext()){ + Assert.assertEquals(strArray[a], iterator.next().toString()); + a = a + 1; + } + } + + + @Test + public void sizeTest() { + Assert.assertEquals(4, linkedList.size(), 0); + } + + @Test + public void getTest() throws IndexOutOfBoundsException { + Assert.assertEquals("a", linkedList.get(0).toString()); + Assert.assertEquals("b", linkedList.get(1).toString()); + Assert.assertEquals("d", linkedList.get(3).toString()); + + thrown.expect(IndexOutOfBoundsException.class); + thrown.expectMessage("index boom"); + linkedList.get(100); + linkedList.get(-1); + } + + + @Test + public void addTest() { + linkedList.add("f"); + Assert.assertEquals("f", linkedList.get(4).toString()); + } + + @Test + public void removeTest() throws IndexOutOfBoundsException { + + LinkedList list = new LinkedList(); + list.add("a"); + list.add("b"); + list.add("c"); + list.add("d"); + + + String r1 = list.remove(1).toString(); + Assert.assertEquals("b", r1); + Assert.assertEquals(3, list.size()); + + String r0 = list.remove(0).toString(); + Assert.assertEquals("a", r0); + Assert.assertEquals(2, list.size()); + + String rs = list.remove(list.size() - 1).toString(); + Assert.assertEquals("d", rs); + Assert.assertEquals(1, list.size()); + + thrown.expect(IndexOutOfBoundsException.class); + thrown.expectMessage("index boom"); + list.remove(100); + list.remove(-1); + } + + + @Test + public void addIndexTest() throws IndexOutOfBoundsException { + linkedList.add(0, "0"); + Assert.assertEquals("0", linkedList.get(0).toString()); + linkedList.add(linkedList.size(), "s"); + Assert.assertEquals("s", linkedList.get(linkedList.size() - 1).toString()); + linkedList.add(2, "2a"); + Assert.assertEquals("2a", linkedList.get(2).toString()); + thrown.expect(IndexOutOfBoundsException.class); + thrown.expectMessage("index boom"); + linkedList.add(100, "10a"); + + } + + +} diff --git a/group24/1148285693/learning2017/pom.xml b/group24/1148285693/learning2017/pom.xml new file mode 100644 index 0000000000..6493774794 --- /dev/null +++ b/group24/1148285693/learning2017/pom.xml @@ -0,0 +1,110 @@ + + + 4.0.0 + + me.lzb + learning2017 + 1.0 + learning2017 + pom + + https://github.com/lzbferrari/coding2017 + 2017编程提高 + + + + lzb + https://github.com/lzbferrari + lzbferrari@gmail.com + + + + + learning-basic + + + + 1.8 + 1.8 + UTF-8 + UTF-8 + UTF-8 + + + + + + aliyun + aliyun + http://maven.aliyun.com/nexus/content/groups/public + + true + never + + + false + + + + + + + aliyun + aliyun + http://maven.aliyun.com/nexus/content/groups/public + + true + + + false + + + + + + + + + junit + junit + 4.12 + + + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + 3.6.1 + + ${java.version} + ${java.version} + UTF-8 + + + + + + org.apache.maven.plugins + maven-surefire-plugin + 2.19.1 + + + org.apache.maven.surefire + surefire-junit47 + 2.19.1 + + + + false + + + + + + \ No newline at end of file