DS05-单向链表(使用虚拟头节点)

链表类LinkedList中可以设计一个私有内部类Node类,用于表示一个节点类,节点类中存放两个值,一个是支持泛型的E类型的e,一个是表示下一个节点的Node类型的next,链表类中有两个需要维护的参数,一个是用于表示虚拟头节点的dummyHead,另一个就是用于表示链表长度的size.

虚拟头节点就是在头节点前面再放一个空的节点,这个节点值为null,指向头节点.使用虚拟头节点主要是为了避免在使用头节点情况下经常要对头节点是否为空做判断,使整个链表的逻辑更加顺畅.

单向链表的插入/删除/查找/修改时间复杂度都为O(n)

代码如下:

/**
 * 链表类
 * @author ChenZhuJi
 *
 * @param <E>
 */
@SuppressWarnings("unused")
public class LinkedList<E> {
	private class Node {
		public Node next;
		public E e;

		public Node() {
			this(null, null);
		}

		public Node(E e, Node next) {
			this.e = e;
			this.next = next;
		}

		@Override
		public String toString() {
			return e.toString();
		}
	}

	private Node dummyHead;		//虚拟头节点
	private int size;			//链表的长度

	public LinkedList() {
		dummyHead = new Node(null, null);
		size = 0;
	}
	
	/**
	 * 获取链表中的元素个数
	 * @return 链表中的元素个数
	 */
	public int getSize() {
		return size;
	}
	
	/**
	 * 判断链表是否为空
	 * @return true/false
	 */
	public boolean isEmpty() {
		return size == 0;
	}

	/**
	 * 在链表中添加元素
	 * @param e 要添加的元素
	 * @param index 添加元素的索引位置
	 */
	public void add(E e, int index) {
		if (index < 0 || index > size) {
			throw new IllegalArgumentException("参数错误,索引越界");
		}
		Node prev = dummyHead;
		for (int i = 0; i < index ; i++) {
			prev = prev.next;
		}
		prev.next = new Node(e, prev.next);
		size++;
	}
	
	/**
	 * 在链表头添加元素
	 * @param e 要添加的元素
	 */
	public void addFirst(E e) {
		add(e,0);
	}
	/**
	 * 在链表尾部添加元素
	 * @param e 要添加的元素
	 */
	public void addLast(E e) {
		add(e,size);
	}
	
	/**
	 * 获取指定索引位置上的元素
	 * @param index 索引值
	 * @return 元素
	 */
	public E get(int index) {
		if(index > size || index <0) {
			throw new IllegalArgumentException("参数错误:索引越界");
		}
		Node prev = dummyHead;
		for(int i = 0; i < index ; i++) {
			prev = prev.next;
		}
		return prev.next.e;
	}
	
	/**
	 * 获取链表首元素的值
	 * @return 链表首元素
	 */
	public E getFirst() {
		return get(0);
	}
	
	/**
	 * 获取链表尾元素
	 * @return 链表最后一个元素
	 */
	public E getLast() {
		return get(size - 1);
	}
	
	/**
	 * 设置指定索引上的元素
	 * @param index 指定索引
	 * @param e 指定元素
	 */
	public void set(int index,E e)  {
		if(index >=  size || index < 0) {
			throw new IllegalArgumentException("参数错误,索引越界");
		}
		Node prev = dummyHead;
		for(int i = 0; i < index; i++) {
			prev = prev.next;
		}
		prev.e = e;
	}
	
	/**
	 * 判断链表中是否包含某个元素
	 * @param e 待查找的元素
	 * @return true/false
	 */
	public boolean contians(E e) {
		Node cur = dummyHead.next;
		while(cur.e != null) {
			if(cur.e.equals(e)) {
				return true;
			}
			cur = cur.next;
		}
		return false;
	}
	
	/**
	 * 删除链表中指定索引位置的元素
	 * @param index 指定的索引
	 * @return 被删除的元素
	 */
	public E remove(int index) {
		if(index >= size || index < 0) {
			throw new IllegalArgumentException("参数错误:索引越界");
		}
		Node cur = dummyHead;
		for(int i = 0; i < index; i++) {
			cur = cur.next;
		}
		Node ret = cur.next;
		cur.next = ret.next;
		ret.next = null;
		size--;
		return ret.e;
	}
	
	/**
	 * 删除链表表头元素
	 * @return 被删除的元素
	 */
	public E removeFirst() {
		return remove(0);
	}
	
	/**
	 * 删除链表尾部的元素
	 * @return 被删除的元素
	 */
	public E removeLast() {
		return remove(size - 1);
	}
	
	/**
	 * 删除链表中第一次出现的指定元素
	 * @param e 要删除的元素
	 */
	public void removeElement(E e) {
		Node cur = dummyHead;
		while(cur.next != null) {
			if(cur.next.e.equals(e)) {
				break;
			}
			cur = cur.next;
		}
		if(cur.next != null) {
			Node delNode = cur.next;
			cur.next = delNode.next;
			delNode.next = null;
		}
		size--;
	}
	
	@Override
	public String toString() {
		StringBuilder sb = new StringBuilder();
		Node prev = dummyHead.next;
		while (prev != null) {
			sb.append(prev + "->");
			prev = prev.next;
		}
		sb.append("null");
		return sb.toString();
	}
}