735371210

group22/735371210/.gitignore

@@ -0,0 +1 @@
+/bin/

group22/735371210/.project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>task1</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

group22/735371210/src/task1/basic/Iterator.java

@@ -0,0 +1,8 @@
+package task1.basic;
+
+public interface Iterator {
+
+	public boolean hasNext();
+	public Object next();
+
+}

group22/735371210/src/task1/basic/LinkedList.java

@@ -0,0 +1,140 @@
+package task1.basic;
+
+public class LinkedList implements List{
+
+	private Node head = new Node();
+	private int size;
+
+	private static class Node{
+		Object data;
+		Node next;
+	}
+
+
+	public void add(Object o){
+		addLast(o);
+
+	}
+	public void add(int index ,Object o){
+		if(index<0 || index>size -1){
+			throw new ArrayIndexOutOfBoundsException();
+		}
+
+		Node node=head;
+
+		Node newNode=new Node();
+
+		for(int i =0;i<index;i++){
+			node=node.next;
+		}
+		newNode.data=o;
+
+		if(index==0){
+			addFirst(o);
+
+		}else{
+			newNode.next=node.next;
+			node.next=newNode;
+
+		}
+		size++;
+
+	}
+	public Object get(int index){
+
+		Node node=head;
+		for(int i=0;i<index;i++){
+			node=node.next;
+		}
+		return node.data;
+
+	}
+	public Object remove(int index){
+
+		Node indexNode=head;
+		Node node=head;
+
+		for(int i=0;i<index;i++){
+			indexNode=indexNode.next;
+
+		}
+		for(int i=0;i<index-1;i++){
+			node=node.next;
+		}
+
+		node.next=indexNode.next;
+
+		indexNode.next=null;
+
+		size--;
+
+		return indexNode.data;
+
+
+	}
+
+	public int size(){
+		return size;
+	}
+
+	public void addFirst(Object o){
+
+		Node newNode=new Node();
+		newNode.data=o;
+		newNode.next=head;
+		head=newNode;
+		size++;
+	}
+	public void addLast(Object o){
+
+		Node newNode= new Node();
+
+		Node node= head;
+
+		for (int i=0;i<size ;i++){
+			node=node.next;
+		}
+
+		newNode.data=o;
+		node.next=newNode;
+		size++;
+
+
+	}
+	public Object removeFirst(){
+
+		head=head.next;
+
+		size--;
+
+		return head.data;
+
+
+	}
+
+	public Object removeLast(){
+
+		Node node=head;
+		for(int i=0;i<size-1 ;i++){
+			node=node.next;
+		}
+
+		Node lastNode=node.next;
+		node.next=null;
+
+		size--;
+
+		return lastNode.data;
+
+
+	}
+
+
+
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+
+	}
+
+}

group22/735371210/src/task1/basic/List.java

@@ -0,0 +1,11 @@
+package task1.basic;
+
+public interface List {
+
+	public void add(Object o);
+	public void add(int index,Object o);
+	public Object get(int index);
+	public Object remove(int index);
+	public int size();
+
+}

group22/735371210/src/task1/basic/MyArrayList.java

@@ -0,0 +1,120 @@
+package task1.basic;
+
+import java.util.Arrays;
+
+public class MyArrayList implements List {
+
+	private int size=0;
+	private Object[] elementData=new Object[3];
+
+	public void add(Object o){
+
+		checkLength(size+1);
+
+		elementData[size++]=o;
+
+	}
+
+	public void checkLength(int minLength){
+
+		if(minLength>elementData.length){
+			grow(minLength);
+
+		}
+	}
+
+	public void grow(int minLength){
+
+		int oldLength = elementData.length;
+		int newLength = oldLength + oldLength>>1;
+
+		if(newLength < minLength){
+			newLength=minLength;
+		}
+
+		elementData= Arrays.copyOf(elementData, newLength);
+
+
+
+	}
+	public void add(int index ,Object o){
+		checkLength(size+1);
+		System.arraycopy(elementData, index, elementData, index+1, size-index);
+		elementData[index]=o;
+		size++;
+
+	}
+	public Object get(int index){
+
+		return elementData[index];
+
+
+	}
+	public Object remove(int index){
+
+		Object element=elementData[index];
+
+		System.arraycopy(elementData, index+1, elementData, index, size-index-1);
+
+		elementData[size-1]=null;
+
+		size--;
+
+		return element;
+	}
+
+	public int size(){
+
+		return size;
+	}
+
+	public Iterator iterator(){
+		return new ArrayListIterator();
+	}
+
+	class ArrayListIterator implements Iterator{
+
+		int pos=0;
+
+		public boolean hasNext(){
+
+			if(elementData[pos]!=null){
+				return true;
+			}
+
+			return false;
+
+		}
+
+		public Object next(){
+
+			return elementData[pos++];
+		}
+
+	}
+	public static void main(String[] args){
+		MyArrayList my=new MyArrayList();
+		my.add(0);
+		my.add(1);
+		my.add(2,10);
+		my.add(1,11);
+		my.add(3,32);
+
+		Object ele=my.remove(2);
+
+		System.out.println(ele);
+		System.out.println(my.get(1));
+		System.out.println(my.size());
+
+		System.out.println("---------");
+
+		Iterator it=my.iterator();
+		while(it.hasNext()){
+			System.out.println(it.next());
+		}
+
+
+
+	}
+
+}

group22/735371210/src/task1/basic/Queue.java

@@ -0,0 +1,45 @@
+package task1.basic;
+
+import java.util.LinkedList;
+
+public class Queue {
+
+	private LinkedList q=new LinkedList();
+
+	public void enQueue(Object o){
+
+		q.addLast(o);
+	}
+
+	public Object deQueue(){
+		return q.removeFirst();
+
+	}
+
+	public int size(){
+
+		return q.size();
+	}
+
+	public static void main(String[] args){
+		Queue testQ= new Queue();
+
+		testQ.enQueue(11);
+		testQ.enQueue(12);
+
+        testQ.enQueue(13);
+
+        System.out.println(testQ.size());
+
+        Object s1=testQ.deQueue();
+        System.out.println(s1);
+
+        Object s2=testQ.deQueue();
+        System.out.println(s2);
+
+
+
+
+	}
+
+}

group22/735371210/src/task1/basic/Stack.java

@@ -0,0 +1,40 @@
+package task1.basic;
+
+import java.util.ArrayList;
+public class Stack {
+
+	private ArrayList elementData =new ArrayList();
+
+	public void push(Object o){
+
+		elementData.add(o);
+	}
+
+	public Object pop(){
+
+		return elementData.remove(size()-1);
+
+	}
+
+	public boolean isEmpty(){
+		return elementData.isEmpty();
+
+	}
+
+	public Object peek(){
+
+		return elementData.get(size()-1);
+
+
+	}
+
+	public int size(){
+		return elementData.size();
+	}
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+
+	}
+
+}