Java MyLinkedList 示例

注， 编译的sdk版本为java1.7

// 源代码。。

import java.util.*;

public class Main
{
	public static void main(String[] args)
	{
		MyLinkedList<Integer> myLinkedList = new MyLinkedList<Integer>();
		// cons
		System.out.println("size : "+myLinkedList.size());
		System.out.println(myLinkedList);
		System.out.println("===============");
		// add 
		myLinkedList.add(0, new Integer(2));
		System.out.println("size : "+myLinkedList.size());
		System.out.println(myLinkedList);
		myLinkedList.add(0, new Integer(1));
		System.out.println("size : "+myLinkedList.size());
		System.out.println(myLinkedList);
		myLinkedList.add(2, new Integer(3));
		System.out.println("size : "+myLinkedList.size());
		System.out.println(myLinkedList);
		myLinkedList.add(new Integer(4));
		System.out.println("size : "+myLinkedList.size());
		System.out.println(myLinkedList);
		System.out.println("===============");
		// remove 
		myLinkedList.remove(8);
		System.out.println("size : "+myLinkedList.size());
		System.out.println(myLinkedList);
		myLinkedList.remove(1);
		System.out.println("size : "+myLinkedList.size());
		System.out.println(myLinkedList);
		System.out.println("===============");
		// merge
		MyLinkedList<Integer> myLinkedList1 = new MyLinkedList<Integer>();
		myLinkedList1.add(new Integer(4));
		myLinkedList1.add(new Integer(3));
		myLinkedList1.add(new Integer(6));
		myLinkedList1.add(new Integer(5));
		System.out.println(myLinkedList.intersect(myLinkedList1));
		System.out.println(myLinkedList.union(myLinkedList1));
		System.out.println(myLinkedList.link(myLinkedList1));
		System.out.println("===============");
		// sort 
		System.out.println("before sort "+myLinkedList1);
		myLinkedList1.sort(new Comparator<Integer>(){
				@Override
				public int compare(Integer p1, Integer p2)
				{
					return p1.intValue() > p2.intValue() ? 1 : -1;
				}
		});
		System.out.println("after sort "+myLinkedList1);
		System.out.println("===============");
		// clean up
		myLinkedList.remove(2);
		System.out.println(myLinkedList);
		myLinkedList.removeAll();
		System.out.println(myLinkedList);
	}
}

class MyLinkedList<T> {
	private Node<T> headNode = new Node<T>();
	
	public MyLinkedList(){
		super();
	}
	
	public MyLinkedList(MyLinkedList<T> model){
		for(int i = 0; i < model.size(); i ++){
			this.add(model.get(i).data);
		}
	}
	
	public MyLinkedList(T[] models){
		for(T s : models)
			add(s);
	}
	
	public int size(){
		int n = 0;
		Node<T> p = this.headNode;
		while(p.hasNext()){
			n ++;
			p = p.next;
		}
		return n;
	}
	
	public T add(int index, T t){
		if(index < 0 || index > size())
			return null;
		if(index == 0){
			headNode.next = new Node<T>(t, headNode.next);
		}else{
			if(index == size()){
				get(size()-1).next = new Node<T>(t, null);
			}else{
				get(index).next = new Node<T>(t, get(index).next);
			}
		}
		return t;
	}
	
	public T add(T t){
		return add(size(), t);
	}
	
	public boolean remove(int index){
		if(index < 0 || index >= size())
			return false;
		if(index == 0){
			headNode.next = get(1);
		}else{
			if(size()-1 == index){
				get(index - 1).next = null;
			}else{
				get(index - 1).next = get(index).next;
			}
		}
		return true;
	}
	
	public void removeAll(){
		headNode.next = null;
	}
	
	public Node<T> get(int index){
		if(index < 0 || index >= size())
			return null;
		Node<T> ret = headNode;
		while(index-- >= 0)
			ret = ret.next;
		return ret;
	}
	
	public boolean contain(T t){
		for(int i = 0; i < size(); i ++){
			if(get(i).data.equals(t))
				return true;
		}
		return false;
	}
	
	public MyLinkedList<T> union(MyLinkedList<T> other){
		MyLinkedList<T> myLinkedList = new MyLinkedList<T>(this);
		for(int i = 0; i < other.size(); i ++){
			if(!contain(other.get(i).data))
				myLinkedList.add(other.get(i).data);
		}
		return myLinkedList;
	}
	
	public MyLinkedList<T> intersect(MyLinkedList<T> other){
		MyLinkedList<T> myLinkedList = new MyLinkedList<T>();
		for(int i = 0; i < other.size(); i ++)
			if(contain(other.get(i).data))
				myLinkedList.add(other.get(i).data);
		return myLinkedList;
	}
	
	public MyLinkedList<T> link(MyLinkedList<T> another){
		MyLinkedList<T> myLinkedList = new MyLinkedList<T>(this);
		for(int i = 0; i < another.size(); i ++)
			myLinkedList.add(another.get(i).data);
		return myLinkedList;
	}
	
	public void sort(Comparator<T> comp){
		for(int i = 0; i < size(); i ++)
			for(int j = 0; j < size() - i - 1; j ++)
				if(comp.compare(get(j).data, get(j + 1).data) > 0){
					Node<T> p0 = get(j);
					remove(j);
					add(j+1, p0.data);
				}
	}
	
	@Override
	public String toString(){
		String str = new String("Data :");
		Node<T> t = headNode;
		while(t.hasNext()){
			t = t.next;
			str += " " + t.toString();
		}
		if(t == headNode)
			str += " empty";
		return str;
	}
	
	class Node<T> {
		public T data = null;
		public Node<T> next = null;
		
		public Node(T data, Node<T> next){
			this.data = data;
			this.next = next;
		}
		
		public Node(Node<T> next){
			this.next = next;
		}
		
		public Node(T data){
			this.data = data;
		}
		
		public Node(){
			super();
		}
		
		public Node<T> nextNode(){
			return this.next;
		}
		
		public T getData(){
			return this.data;
		}
		
		public boolean hasNext(){
			return next == null ? false : true;
		}
		
		public String toString(){
			return this.data.toString();
		}
	}
}

// output

size : 0
Data : empty
===============
size : 1
Data : 2
size : 2
Data : 1 2
size : 3
Data : 1 2 3
size : 4
Data : 1 2 3 4
===============
size : 4
Data : 1 2 3 4
size : 3
Data : 1 3 4
===============
Data : 4 3
Data : 1 3 4 6 5
Data : 1 3 4 4 3 6 5
===============
before sort Data : 4 3 6 5
after sort Data : 3 4 5 6
===============
Data : 1 3
Data : empty