LinkedList.java

package DataStruct;

public class LinkedList implements List {
	
	private Node head;
	
	public void add(Object o){
		if(head == null) {
			head = new Node();
			head.data = o;
		} else {
			Node temp = head;
			while(temp.next != null) {
				temp = temp.next;
			}
			temp.next = new Node();
			temp.next.data = o;
		}
	}

	public void add(int index , Object o){
		if(index > size()) {
			return ;
		}
		if(index == 0) {
			Node newNode = new Node();
			newNode.data = o;
			newNode.next = head;
			head = newNode;
		} else {
			int temp = 0;
			Node newNode = new Node();
			newNode.data = o;
			Node tempNode = head;
			while(temp != index - 1) {
				tempNode = tempNode.next;
				++temp;
			}
			Node tempNode2 = tempNode.next;
			tempNode.next = newNode;
			newNode.next = tempNode2;
		}
	}

	public Object get(int index){
		if(index > size() || size() == 0) {
			return null;
		}
		Node temp = head;
		for(int i = 0; i < index; ++i) {
			temp = temp.next;
		}

		return temp.data;
	}


	public Object remove(int index){
		if(size() == 0) {
			return null;
		}
		if(size() == 1) {
			Object obj = head.data;
			head = null;
			return obj;
		}
		if(index == 0) {
			Node temp = head;
			head = head.next;
			temp.next = null;
		} else if(index > size()) {
			return null;
		} else {
			int t = 0;
			Node temp = head;
			while(t != index - 1) {
				temp = temp.next;
				++t;
			}
			Node result = temp.next;
			temp.next = temp.next.next;
			return result.data;
		}
		return null;
	}
	
	public int size(){
		int len = 0;
		Node temp = head;
		while(temp != null) {
			temp = temp.next;
			++len;
		}
		return len;
	}
	
	public void addFirst(Object o){
		Node temp = new Node();
		temp.data = o;
		temp.next = head;
		head = temp;
	}
	public void addLast(Object o){
		Node newNode = new Node();
		newNode.data = o;

		if(size() == 0) {
			head = newNode;
		}
		Node temp = head;
		while(temp.next != null) {
			temp = temp.next;
		}
		temp.next = newNode;
	}
	public Object removeFirst(){
		if(size() == 0) {
			return null;
		}
		Node temp = head;
		head = head.next;
		return temp.data;
	}
	public Object removeLast(){
		if(size() == 0) {
			return null;
		}
		if(size() == 1) {
			Node temp = head.next;
			head = head.next;
			return temp.data;
		}
		Node temp1 = head;
		Node temp2 = head.next;
		while(temp2.next != null) {
			temp1 = temp1.next;
			temp2 = temp2.next;
		}
		temp1.next = null;
		return temp2.data;
	}
	public Iterator iterator(){
		return null;
	}
	
	
	private static  class Node{
		Object data;
		Node next;
		
	}

	/**
	 * 把该链表逆置
	 * 例如链表为 3->7->10 , 逆置后变为  10->7->3
	 */
	public  void reverse(){
		Node first = head;
		Node last = head.next;
		while(last != null) {
			Node temp = last;
			last = last.next;
			temp.next = first;
			first = temp;
		}
		head = first;
	}

	/**
	 * 删除一个单链表的前半部分
	 * 例如：list = 2->5->7->8 , 删除以后的值为 7->8
	 * 如果list = 2->5->7->8->10 ,删除以后的值为7,8,10

	 */
	public  void removeFirstHalf(){
		Node temp = head;
		int len = 1;
		while(temp.next != null) {
			temp = temp.next;
			len++;
		}

		int num = len / 2;

		for(int i = 0; i < num; ++i) {
			head = head.next;
		}
	}

	/**
	 * 从第i个元素开始， 删除length 个元素 ， 注意i从0开始
	 * @param i
	 * @param length
	 */
	public  void remove(int i, int length){
		if(i == 0) {
			head = null;
		}
		Node temp = head;
		for(int n = 1; n < i; ++n) {
			temp = temp.next;
		}
		Node last = temp;
		for(int n = 0; n < length; ++n) {
			if(last != null) {
				last = last.next;
			}
		}
		temp.next = last;

	}
	/**
	 * 假定当前链表和list均包含已升序排列的整数
	 * 从当前链表中取出那些list所指定的元素
	 * 例如当前链表 = 11->101->201->301->401->501->601->701
	 * listB = 1->3->4->6
	 * 返回的结果应该是[101,301,401,601]
	 * @param list
	 */
	public int[] getElements(LinkedList list){
			ArrayList<Integer> tempList = new ArrayList<Integer>();
			Node t = head;
			int i = 0;
			while(t != null) {
				tempList.add((Integer) t.data);
				i++;
			}
			int k = 0;
			int[] result = new int[i];
			for(int j = 0; j < list.size(); ++j) {
				result[k++] = (Integer)tempList.get((Integer) list.get(j));
			}
		return result;
	}

	/**
	 * 已知链表中的元素以值递增有序排列，并以单链表作存储结构。
	 * 从当前链表中中删除在list中出现的元素
	 * @param list
	 */

	public  void subtract(java.util.LinkedList<Integer> list){
		Node temp = head;
		Node temp2 = head;
		int i = 0;

		while(i < list.size() || temp != null) {
			if(i == list.size() || temp == null) {
				break;
			}
			if(list.get(i) > (Integer)temp.data) {
				temp2 = temp;
				temp = temp.next;
			} else if(list.get(i) < (Integer)temp.data) {
				i++;
			} else {
				temp2.next = temp.next;
			}
		}
	}

	/**
	 * 已知当前链表中的元素以值递增有序排列，并以单链表作存储结构。
	 * 删除表中所有值相同的多余元素（使得操作后的线性表中所有元素的值均不相同）
	 */
	public  void removeDuplicateValues(){
		Node temp1 = head;
		Node temp2 = head.next;
		while(temp2 != null) {
			if(temp1.data == temp2.data) {
				temp2 = temp2.next;
			} else {
				temp1.next = temp2;
				temp1 = temp2;
				temp2 = temp2.next;
			}
		}
	}

	/**
	 * 已知链表中的元素以值递增有序排列，并以单链表作存储结构。
	 * 试写一高效的算法，删除表中所有值大于min且小于max的元素（若表中存在这样的元素）
	 * @param min
	 * @param max
	 */
	public  void removeRange(int min, int max){
		Node first = head;
		Node first2 = first;
		Node last = head.next;
		Node last2 = last;
		while(last != null) {
			if((Integer)last.data < max && (Integer)first.data < min) {
				first2 = first;
				first = first.next;
				last2 = last;
				last = last.next;
			} else if((Integer)last.data > max && (Integer)first.data > min) {
				break;
			} else if((Integer)last.data < max && (Integer)first.data > min) {
				last2 = last;
				last = last.next;
			} else {
				first2 = first;
				first = first.next;
			}
		}
		first2.next = last;
	}

	/**
	 * 假设当前链表和参数list指定的链表均以元素依值递增有序排列（同一表中的元素值各不相同）
	 * 现要求生成新链表C，其元素为当前链表和list中元素的交集，且表C中的元素有依值递增有序排列
	 * @param list
	 */
	public  LinkedList intersection( LinkedList list){
		LinkedList result = new LinkedList();
		Node temp = head;
		Node temp2 = list.head;
		while(temp != null && temp2 != null) {
			if((Integer)temp.data == (Integer)temp2.data) {
				result.add(temp.data);
				temp = temp.next;
				temp2 = temp2.next;
			} else if((Integer)temp.data > (Integer)temp2.data) {
				temp2 = temp2.next;
			} else {
				temp = temp.next;
			}
		}

		return result;
	}
}