台哥算法练习 - 自己写的一个LinkedList

package suanfa;

/**
 * 当年学习数据结构和算法的时候，自己写的一个LinkedList，
 * 可以看到，LinkedList是动态链表，插入和删除的效率比较高，查询其长度的效率比较低
 * 
 * 推荐一本学习数据结构和算法的书籍，《数据结构java版》清华大学出版社，译者梁志敏
 * 
 * @author 台哥  https://blog.csdn.net/chaohi
 * 
 * @param <T>
 */
public class LinkedList<T> {
	private Node<T> node;
	private int listSize;

	// 构造方法
	public LinkedList() {
		node = new Node<T>();
		listSize = 0;
	}

	// 在索引index处添加元素
	public void add(int index, T element) {
		if (index < 0 || index > listSize) {
			return;
		}
		Node<T> preNode = node;
		for (int i = 0; i < index; i++)
			preNode = preNode.next;
		Node<T> newNode = new Node<T>(element);
		if (preNode.next != null) {
			preNode.next.prev = newNode;
			newNode.next = preNode.next;
		}
		newNode.prev = preNode;
		preNode.next = newNode;
		listSize++;
	}

	// 在尾部添加元素并返回true
	public boolean add(T element) {
		this.add(listSize, element);
		return true;
	}

	// 返回第一个element元素的索引
	public int indexOf(T element) {
		Node<T> curNode = node;
		for (int i = 0; i <= listSize - 1; i++) {
			curNode = curNode.next;
			if (curNode.equals(element))
				return i;
		}
		return -1;
	}

	// 返回最后一个element元素的索引
	public int lastIndexOf(T element) {
		int index = -1;
		Node<T> curNode = node;
		for (int i = 0; i <= listSize - 1; i++) {
			curNode = curNode.next;
			if (curNode.equals(element))
				index = i;
		}
		return index;
	}

	// 得到索引index处的节点
	public Node<T> getNode(int index) {
		Node<T> curNode = node;
		for (int i = 0; i <= index; i++) {
			curNode = curNode.next;
		}
		return curNode;
	}

	// 得到索引index处的元素
	public T get(int index) {
		if (index < 0 || index >= listSize) {
			return null;
		}
		return this.getNode(index).value;
	}

	// 为索引index处的元素赋值
	public T set(int index, T element) {
		if (index < 0 || index >= listSize) {
			return null;
		}
		T previousValue = this.get(index);
		Node<T> curNode = this.getNode(index);
		curNode.value = element;
		return previousValue;
	}

	// 删除索引index处的元素
	public T remove(int index) {
		if (index < 0 || index >= listSize) {
			return null;
		}
		Node<T> curNode = this.getNode(index);
		curNode.prev.next = curNode.next;
		if (curNode.next != null)
			curNode.next.prev = curNode.prev;
		listSize--;
		return curNode.value;
	}

	// 删除列表中的element元素
	public boolean remove(T element) {
		int index = this.indexOf(element);
		if (index != -1) {
			this.remove(index);
			return true;
		}
		return false;
	}

	// 返回列表的长度
	public int size() {
		return listSize;
	}

	// 判断列表是否为空
	public boolean isEmpty() {
		return listSize == 0;
	}

	// 清空列表
	public void clear() {
		node = null;
		listSize = 0;
	}

	// 判断列表中是否存在元素element
	public boolean contains(T element) {
		return !(this.indexOf(element) == -1);
	}

	// 节点
	@SuppressWarnings("hiding")
	private class Node<T> {
		public T value;
		public Node<T> prev;
		public Node<T> next;

		public Node() {
		};

		public Node(T t) {
			this.value = t;
		}
	}

	// 测试
	public static void main(String[] args) {
		LinkedList<String> l = new LinkedList<String>();
		l.add("台哥");
		l.add("taigecailing");
		l.add(1, "当当当当");
		System.out.println("size=:" + l.size());

		for (int i = 0; i < l.size(); i++) {
			System.out.print(l.get(i) + " , ");
		}
		System.out.println();
		
		l.remove(2);
		System.out.println(l.get(2));
	}

}