算法初級（四）——單鏈表

上一篇講述了順序表，順序表總的來說有以下特點：

• 在線性表中邏輯上相鄰的數據元素，在物理存儲位置上也是相鄰的；
• 存儲密度高，但要預先分配“足夠應用”的存儲空間，這可能將會造成存儲空間的浪費，其中存儲密度=$\frac{數據元素本身值所需的存儲空間}{該數據元素實際所佔用的空間}$
• 便於隨機存取
• 不便於插入和刪除操作，這是因爲在順序表上進行的插入和刪除操作會引起大量數據元素的移動
  
  順序存儲雖然是一種很有用的存儲結構，但是有如下侷限性：
• 若要爲線性表擴充存儲空間，則需要重新創建一個地址連續的更大的存儲空間，並把原有的數據元素都複製到新的存儲空間（可參考List實現源碼）
• 因爲順序存儲要求邏輯上相鄰的數據元素在物理存儲位置上也要相鄰，這就使得增刪操作會引起平均約一半的數據元素的移動
  所以順序表最適合表示“靜態”線性表，即線性表一旦生成，就很少進行插入與刪除操作，對於需要頻繁插入和刪除的“動態”線性表，通常採用的是鏈式存儲結構（鏈表）

單鏈表

鏈表中每一個結點包含存放數據元素值的數據域和存放指向邏輯上相鄰的指針域。若一個結點中只包含一個指針域，則稱此鏈表爲單鏈表。

一個單鏈表由頭指針head來唯一標識它
單鏈表中的最後一個結點（尾結點）沒有 後繼，所以指針域的值爲NULL值
有時爲了操作方便，在第一個結點之前虛加一個頭結點，頭結點的數據域一半不存放具體的值，指針域存放指向第一個結點（首結點）的指針
結點對象用java語言描述如下：

public class Node {
	private Object data;
    private Node next;
    
    
	public Node() {
		this(null,null);
	}
	
	public Node(Object data) {
		this(data,null);
	}


	public Node(Object data, Node next) {
		this.data = data;
		this.next = next;
	}

	public Object getData() {
		return data;
	}

	public void setData(Object data) {
		this.data = data;
	}

	public Node getNext() {
		return next;
	}

	public void setNext(Node next) {
		this.next = next;
	}
    
    
}

單鏈表類：

public class LinkList implements IList {
	private Node head;

	public LinkList() {
		head = new Node();
	}

	public LinkList(int n, boolean order) throws Exception {
		this();
		if (order)// 兩種創建方式，尾插法
			create1(n);
		else
			create2(n);
	}

	private void create1(int n) throws Exception {
		Scanner sc = new Scanner(System.in);
		for (int i = 0; i < n; i++) {
			insert(0, sc.next());
		}
	}

	private void create2(int n) throws Exception {
		Scanner sc = new Scanner(System.in);
		for (int i = 0; i < n; i++) {
			insert(length(), sc.next());
		}
	}

	@Override
	public void clear() {
		head.setData(null);
		head.setNext(null);
	}

	@Override
	public boolean isEmpty() {

		return head.getNext() == null;
	}

	@Override
	public int length() {
		Node p = head.getNext();
		int length = 0;
		while (p != null) {
			p = head.getNext();
			++length;
		}
		return length;
	}

	@Override
	public Object get(int i) throws Exception {
		Node p = head.getNext();
		int j = 0;
		while (p != null && j < i) {
			p = p.getNext();
			++j;
		}
		if (j > i || p == null) {
			throw new Exception("元素不存在");

		}
		return p.getData();
	}

	@Override
	public void insert(int index, Object object) throws Exception {
		Node p = head;
		int j = -1;
		while (p != null && j < index - 1) {
			p = p.getNext();
			++j;
		}
		if (j > index - 1 || p == null) {
			throw new Exception("插入位置不合法");
		}
		Node s = new Node(object);
//		s.setNext(head);
//		head = s;
		s.setNext(p);
		p.setNext(s);
	}

	@Override
	public void remove(int index) throws Exception {
		Node p = head;
		int j = -1;
		while (p.getNext() != null && j < index - 1) {
			p = p.getNext();
			++j;
		}
		if (j > index - 1 || p.getNext() == null) {
			throw new Exception("刪除位置不合法");
		}
		p.setNext(p.getNext().getNext());
	}

	@Override
	public int indexOf(Object object) {
		Node p = head.getNext();
		int j = 0;
		while (p != null && !p.getData().equals(object)) {
			p = p.getNext();
			++j;
		}
		if (p != null)
			return j;
		return -1;
	}

	@Override
	public void display() {
		Node node = head.getNext();
		while (node != null) {
			System.out.print(node.getData() + " ");
			node = node.getNext();
		}
		System.out.println();
	}

	public static void main(String[] args) throws Exception {
		int n = 10;
		LinkList l = new LinkList();
//		l.insert(0, 0);
//		l.insert(1, 1);
		for (int i = 0; i < n; i++) {
			l.insert(i, i);
		}
		System.out.println("請輸入i的值：");
		int i = new Scanner(System.in).nextInt();
		if (0 < i && i <= n)
			System.out.println("第" + i + "個元素的直接前驅是" + l.get(i - 1));
		else
			System.out.println("第" + i + "個元素的直接前驅不存在");
	}
}

並且簡單的測試了一下：

告辭！