数据结构复习整理-02单链表

链表

链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点组成，每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。

链表接口

package com.gc;
public interface List<E> {
	static final int ELEMENT_NOT_FOUND = -1;
	/**
	 * 清除所有元素
	 */
	void clear();

	/**
	 * 元素的数量
	 * @return
	 */
	int size();

	/**
	 * 是否为空
	 * @return
	 */
	boolean isEmpty();

	/**
	 * 是否包含某个元素
	 * @param element
	 * @return
	 */
	boolean contains(E element);

	/**
	 * 添加元素到尾部
	 * @param element
	 */
	void add(E element);

	/**
	 * 获取index位置的元素
	 * @param index
	 * @return
	 */
	E get(int index);

	/**
	 * 设置index位置的元素
	 * @param index
	 * @param element
	 * @return 原来的元素ֵ
	 */
	E set(int index, E element);

	/**
	 * 在index位置插入一个元素
	 * @param index
	 * @param element
	 */
	void add(int index, E element);

	/**
	 * 删除index位置的元素
	 * @param index
	 * @return
	 */
	E remove(int index);

	/**
	 * 查看元素的索引
	 * @param element
	 * @return
	 */
	int indexOf(E element);
}
//继承数组

public abstract class AbstractList<E> implements List<E>{
	
	protected int size;
	
	// 下标越界抛出的异常
	protected void outOfBounds(int index) {
		throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
	}
	// 检查下标越界(不可访问或删除size位置)
	protected void rangeCheck(int index){
		if(index < 0 || index >= size){
			outOfBounds(index);
		}
	}
	// 检查add()的下标越界(可以在size位置添加元素)
	protected void rangeCheckForAdd(int index) {
		if (index < 0 || index > size) {
			outOfBounds(index);
		}
	}
	
	@Override
	public boolean contains(E element) {
		return indexOf(element)!=ELEMENT_NOT_FOUND;
	}
	
	@Override
	public int size() {
		return size;
	}

	@Override
	public boolean isEmpty() {
		return size == 0;
	}
	
	@Override
	public void add(E element) {
		add(size, element);
	}

}

单向链表（Single Linked List）

public class SingleLinkedList<E> extends AbstractList<E> {

	private Node<E> first;

	// 链表中的节点
	private static class Node<E> {
		E element; // 节点元素
		Node<E> next; // 节点指向下一个节点

		public Node(E element, Node<E> next) {
			this.element = element;
			this.next = next;
		}
	}
}

获取元素 get(int index)

@Override
public E get(int index) {
	return node(index).element;
}
/**
 * 根据索引找到节点
 */
private Node<E> node(int index) {
	rangeCheck(index);
	Node<E> node = first;
	for (int i = 0; i < index; i++) {
		node = node.next;
	}
	return node;
}

清空元素 clear()

@Override
public void clear() {
	size = 0;
	first = null;
}

添加元素 add(int index, E element)

@Override
public void add(int index, E element) {
	/*
	* 最好：O(1)
	* 最坏：O(n)
	* 平均：O(n)
	*/
	rangeCheckForAdd(index);
	if(index == 0){ // 给空链表添加第一个元素的情况
		first = new Node<>(element, first);
	}else{
	   //指向上一个节点
		Node<E> prev = node(index - 1);
		prev.next = new Node<>(element, prev.next);
	}
	size++;
}

删除元素 remove(int index)

@Override
public E remove(int index) {
	/*
	* 最好：O(1)
	* 最坏：O(n)
	* 平均：O(n)
	*/
	rangeCheck(index);
	Node<E> node = first;
	if (index == 0) { // 删除第一个元素是特殊情况
		first = first.next;
	} else {
		Node<E> prev = node(index - 1); // 找到前一个元素
		node = prev.next; // 要删除的元素
		prev.next = node.next; // 删除元素
	}
	size--;
	return node.element;
}