2. 程式人生 > >資料結構（2）-- 單向連結串列

資料結構（2）-- 單向連結串列

阿新 • • 發佈：2018-12-13

目錄

0.目錄
1.線性表 – 陣列
2.線性表 – 單向連結串列

連結串列

  連結串列是一種物理儲存單元上非連續、非順序的資料結構，資料元素的邏輯順序是通過連結串列中的指標連結次序實現的。連結串列由一系列節點組成，這些節點不必在記憶體中相連。每個節點由資料部分Data和鏈部分Next組成，Next指向下一個節點，這樣當新增或者刪除時，只需要修改相關節點的Next指向，效率很高）。

// 連結串列節點程式碼（使用內部類）
private class Node<E> {
	private E element;
	private Node<E> next;
	public Node(E e, Node<E> next) {
		element = e;
		this.next = next;
	}
	public Node(E e) {
		this(e, null);
	}
	public Node() {
		this(null);
	}

// 使用虛擬頭結點保持邏輯連貫性、使用尾節點改進效能
private Node<E> dummyHead;
private Node<E> tail;
private int size = 0;

// 兩種構造方法
public Linked(E e) {
	dummyHead = new Node<>();
	dummyHead.next = new Node<>(e);
	tail = dummyHead.next;
	size++;
}

public Linked() {
	dummyHead = new Node<>();
	tail = dummyHead;
}

// 在指定索引位置插入元素
public void add(int index, E e) {
	if (index < 0 || index > size) {
		throw new IllegalArgumentException("Wrong index: " + index);
	}
	Node<E> pre = dummyHead;
	for (int i = 0; i < index; i++) {
		pre = pre.next;
	}
	pre.next = new Node<>(e, pre.next);
	if (index == size) {
		tail = pre.next;
	}
	size++;
}

// 順序遍歷連結串列（重寫toString方法）
@Override
public String toString() {
	StringBuilder sb = new StringBuilder("Linked head[");
	Node<E> cur = dummyHead;
	while (cur.next != null) {
		cur = cur.next;
		sb.append(cur.element).append("->");
	}
	sb.append("NULL").append("]tail");
	return sb.toString();
}

// 逆序遍歷連結串列（遞迴思想）
public void printDesc() {
	System.out.print("Linked tail[Null");
	printDesc(dummyHead.next);
	System.out.println("]head");
}
private void printDesc(Node<E> head) {
	if (head != null) {
		printDesc(head.next);
		System.out.print("<-" + head.element);
	}
}

// 單鏈表反轉
public void reverse() {
	// 非遞迴(效率高)
	dummyHead.next = reverse(dummyHead.next);
	// 遞迴
	// dummyHead.next = reverseRecursion(dummyHead.next);
}
// 非遞迴實現
private Node<E> reverse(Node<E> head) {
	Node<E> pre = null;
	Node<E> cur = head;
	Node<E> next = null;
	while (cur != null) {
		next = cur.next;
		cur.next = pre;
		pre = cur;
		cur = next;
	}
	return pre;
}
// 遞迴實現
private Node<E> reverseRecursion(Node<E> node) {
	if (node == null) {
		return null;
	}
	if (node.next == null) {
		return node;
	}
	Node<E> next = node.next;
	node.next = null;
	Node<E> result = reverseRecursion(next);
	next.next = node;
	return result;
}

  上述程式碼簡單實現了基於單向連結串列實現的線性表的一些細節。單向連結串列實現的線性表，不需要擴容操作；引入了虛擬頭結點，使各方法在實現邏輯上會更加統一；引入了尾節點tail，使得對單鏈表的部分尾部操作效能顯著提升（O(n) -> O(1)），可顯著提升基於單向連結串列實現的其他資料結構的效能（如佇列、棧等，後續會介紹）。
  除了上述單向連結串列，還有其他的實現方式，常見的有迴圈單向連結串列、雙向連結串列、迴圈雙向連結串列。其中，LinkedList集合類的實現就是雙向連結串列。

複雜度分析

  1. 增：add – O(n)、addFirst 和 addLast（tail實現） – O(1)
  2. 刪：remove – O(n)、removeFirst – O(1)
  3. 改：set – O(n)、setFirst 和 setLast（tail實現） – O(1)
  4. 查：get – O(n)、getFirst 和 getLast（tail實現） – O(1)

  可以看出，基於單鏈表實現的線性表結構，特點是：中間操作慢、首尾操作快。

原始碼

public class Linked<E> {

	private class Node<E> {
		private E element;
		private Node<E> next;

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

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

		public Node() {
			this(null);
		}

		@Override
		public String toString() {
			return element == null ? "null" : element.toString();
		}
	}

	private Node<E> dummyHead;
	private Node<E> tail;
	private int size = 0;

	public Linked(Node<E> node) {
		dummyHead = new Node<>();
		dummyHead.next = node;
		if (node == null) {
			tail = dummyHead;
		} else {
			tail = dummyHead.next;
			size++;
		}
	}

	public Linked(E e) {
		dummyHead = new Node<>();
		dummyHead.next = new Node<>(e);
		tail = dummyHead.next;
		size++;
	}

	public Linked() {
		dummyHead = new Node<>();
		tail = dummyHead;
	}

	/**
	 * 在指定索引位置插入元素 O(n) 
	 * 特例：addFirst 和 addLast(tail實現) 為O(1)
	 * 
	 * @param index
	 * @param e
	 */
	public void add(int index, E e) {
		if (index < 0 || index > size) {
			throw new IllegalArgumentException("Wrong index: " + index);
		}
		Node<E> pre = dummyHead;
		for (int i = 0; i < index; i++) {
			pre = pre.next;
		}
		pre.next = new Node<>(e, pre.next);
		if (index == size) {
			tail = pre.next;
		}
		size++;
	}

	public void addFirst(E e) {
		add(0, e);
	}

	public void addLast(E e) {
		// 複用add方法，則時間複雜度為O(n)
		// add(size, e);

		// 使用tail節點實現，則時間複雜度為O(1)
		tail.next = new Node<>(e);
		tail = tail.next;
		size++;
	}

	/**
	 * 刪除指定位置的元素 O(n) 
	 * 特例：removeFirst為O(1)
	 * 
	 * @param index
	 */
	public void remove(int index) {
		if (index < 0 || index >= size) {
			throw new IllegalArgumentException("Wrong index: " + index);
		}
		Node<E> pre = dummyHead;
		for (int i = 0; i < index; i++) {
			pre = pre.next;
		}
		if (index == size - 1) {
			tail = pre;
		}
		// 使del節點能被JVM正常GC
		Node<E> del = pre.next;
		pre.next = del.next;
		del.next = null;
		size--;
	}

	public void removeFirst() {
		remove(0);
	}

	public void removeLast() {
		remove(size - 1);
	}

	/**
	 * 更改指定索引位置的元素 O(n) 
	 * 特例：setFirst 和 setLast(tail實現) 為O(1)
	 * 
	 * @param index
	 * @param e
	 */
	public void set(int index, E e) {
		if (index < 0 || index >= size) {
			throw new IllegalArgumentException("Wrong index: " + index);
		}
		Node<E> cur = dummyHead.next;
		for (int i = 0; i < index; i++) {
			cur = cur.next;
		}
		cur.element = e;
	}

	public void setFirst(E e) {
		set(0, e);
	}

	public void setLast(E e) {
		// 複用add方法，則時間複雜度為O(n)
		// set(size - 1, e);

		// 使用tail節點實現，則時間複雜度為O(1)
		tail.element = e;
	}

	/**
	 * 查詢指定索引位置的元素 O(n) 
	 * 特例：getFirst 和 getLast(tail實現) 為O(1)
	 * 
	 * @param index
	 * @return
	 */
	public E get(int index) {
		if (index < 0 || index >= size) {
			throw new IllegalArgumentException("Wrong index: " + index);
		}
		Node<E> cur = dummyHead.next;
		for (int i = 0; i < index; i++) {
			cur = cur.next;
		}
		return cur.element;
	}

	public E getFirst() {
		return get(0);
	}

	public E getLast() {
		return tail.element;
	}

	public int getSize() {
		return size;
	}

	public boolean isEmpty() {
		return size == 0;
	}

	/**
	 * 查詢連結串列是否包含某個元素，如果包含返回索引，如果不包含返回-1 O(n)
	 * 
	 * @param e
	 * @return
	 */
	public int contains(E e) {
		if (e == null) {
			return -1;
		}
		Node<E> cur = dummyHead.next;
		for (int i = 0; i < size; i++) {
			if (e.equals(cur.element)) {
				return i;
			}
			cur = cur.next;
		}
		return -1;
	}

	/**
	 * 反向列印連結串列，遞迴思想
	 */
	public void printDesc() {
		System.out.print("Linked tail[Null");
		printDesc(dummyHead.next);
		System.out.println("]head");
	}

	private void printDesc(Node<E> head) {
		if (head != null) {
			printDesc(head.next);
			System.out.print("<-" + head.element);
		}
	}

	/**
	 * 反轉連結串列
	 */
	public void reverse() {
		// 非遞迴(效率高)
		dummyHead.next = reverse(dummyHead.next);

		// 遞迴
		// dummyHead.next = reverseRecursion(dummyHead.next);
	}

	private Node<E> reverse(Node<E> head) {
		Node<E> pre = null;
		Node<E> cur = head;
		Node<E> next = null;
		while (cur != null) {
			next = cur.next;
			cur.next = pre;
			pre = cur;
			cur = next;
		}
		return pre;
	}

	// 遞迴實現
	private Node<E> reverseRecursion(Node<E> node) {
		if (node == null) {
			return null;
		}
		if (node.next == null) {
			return node;
		}
		Node<E> next = node.next;
		node.next = null;
		Node<E> result = reverseRecursion(next);
		next.next = node;
		return result;
	}

	@Override
	public String toString() {
		StringBuilder sb = new StringBuilder("Linked head[");
		Node<E> cur = dummyHead;
		while (cur.next != null) {
			cur = cur.next;
			sb.append(cur.element).append("->");
		}
		sb.append("NULL").append("]tail");
		// sb.append(size);
		return sb.toString();
	}
}

相關推薦

資料結構（2）-- 單向連結串列

目錄 0.目錄 1.線性表 – 陣列 2.線性表 – 單向連結串列 連結串列   連結串列是一種物理儲存單元上非連續、非順序的資料結構，資料元素的邏輯順序是通過連結串列中的指標連結次序實現的。連結串列由一系列節點組成，這些節點不必在記憶體中相連。每個節點由資料部分Data和鏈部分

資料結構（一）單向連結串列的的分析與python程式碼實現

概念        單向連結串列也叫單鏈表，是連結串列中最簡單的一種形式，它的每個節點包含兩個域，一個資訊域（元素域）和一個連結域。這個連結指向連結串列中的下一個節點，而最後一個節點的連結域則指向一個空值。 結構  程式碼實現

JavaScript 資料結構（一）： 連結串列

前言 從實用性角度來說，連結串列對Javascript 來說沒有任何價值，為什麼呢？ 我們先了解連結串列的特性，這個特性我們放在c++前提下來說，因為 這個特性是 根據 記憶體特性 來闡述的，Javascript 不存在記憶體操作，所有資料型別，本質性繼承Object 物件，而Ob

大話資料結構（四）——雙向連結串列的java實現

在實現了單向連結串列後，我們在使用單向連結串列中會發現一個問題：在單向連結串列中查詢某一個結點的下一個結點的時間複雜度是O(1)，但是查詢這個結點的上一個結點的時候，時間複雜度的最大值就變成了O(n)，因為在查詢這個指定結點的上一個結點時又需要從頭開始遍歷。 那麼該如何解決這個困難呢？

用 python 學習資料結構（二）雙向連結串列

##一、相比單向連結串列，雙向連結串列的優勢 雙向連結串列的每個節點儲存了前一個節點和後一個節點的引用（指標），到達某個節點是，可以向前或者向後遍歷，提高了操作的效率。比如，insertBefore(nodeA, value) 操作，可以一步完成，而不需要先查詢

資料結構（一）之連結串列篇

連結串列篇 #include<stdio.h>//P77例三 int ReversDouble(LinkList L) { int n=1; LinkList pre,p,q; pre=L; p1=L->next; p=L->next; wh

資料結構（二）雙向連結串列的的分析與python程式碼實現

概念        每個節點有兩個連結：一個指向前一個節點，當此節點為第一個節點時，指向空值；而另一個指向下一個節點，當此節點為最後一個節點時，指向空值。 特點：         節點包含

演算法與資料結構（二） 基於連結串列的佇列

基於連結串列的佇列 一個數據的集合如果以連結串列來儲存，那麼它的容量就是無限的。 實現的過程中，需要注意連結串列為空的情況下，需要對頭引用和尾引用做特殊處理。 實現程式碼 /** * Created by 18855127160 on 2

資料結構（4）：連結串列的原理和實現

上、簡單的單端連結串列 完整程式碼向下拉 連結串列是一種常用的資料結構，在插入和移除操作中有著優秀的表現，同為資料結構的陣列哭暈，其實陣列的訪問效率比連結串列高多了有木有。 我們先看一下連結串列的樣子 有同學可能要說了，這不就是我們生活中的交通工具——火車，沒錯連結串列的結構和下圖簡直就是一個模子刻出來的

小白的資料結構程式碼實戰（2）----雙向連結串列的各種操作

//Author:張佳琪 #include <stdio.h> #include <stdlib.h> typedef int ElemType; typedef struct Node { ElemType data; struct

資料結構實現 2.1：連結串列（C++版）

1. 概念及基本框架 連結串列 是一種 線性結構 ，而且儲存上屬於 鏈式儲存（即記憶體的物理空間是不連續的），是線性表的一種。連結串列結構如下圖所示： 下面以一個我實現的一個簡單的連結串列類來進一步理解連結串列。 template <class T&g

資料結構（三）單向迴圈連結串列的的分析與python程式碼實現

概念 單鏈表的一個變形是單向迴圈連結串列，連結串列中最後一個節點的next域不再為None，而是指向連結串列的頭節點。 節點包含兩個域：元素域和連結域（下一個節點），尾節點next指向第0個節點，當連結串列只有一個節點時，自己的next指向自己，基於單鏈表的基礎上，增加考慮首節點和尾節點

JAVA基礎（63）---單向連結串列

鏈式儲存結構 結點在儲存器中的位置是任意的，即邏輯上相鄰的資料元素在物理上不一定相鄰。 單鏈表的儲存映像 單向連結串列的每個資料項儲存的都是  資料 + 下一個資料地址  ；雙向連結串列儲存的是  上一個資料地址 + 資料 + 下一個資料地址

Glib學習（2） 雙向連結串列 Doubly-Linked Lists

首先貼出來glib庫的幫助文件網址 http://web.mit.edu/barnowl/share/gtk-doc/html/glib/glib-Doubly-Linked-Lists.html#g-list-find 由於雙向連結串列與單向連結串列的很多函式功能和名稱

深入理解系列之JAVA資料結構（2）——LinkedList

1、LinkedList 是一個繼承於AbstractSequentialList的雙向連結串列。它也可以被當作堆疊、佇列或雙端佇列進行操作。 2、LinkedList相對於ArrayList來說，是可以快速新增，刪除元素，ArrayList新增刪除

演算法與資料結構（2）：時間複雜度——以歸併排序為例

這一篇文章我們首先會介紹一下歸併排序，並以歸併排序和我們上一章所說的插入排序為例，介紹時間複雜度。此係列的所有程式碼均可在我的 [github](https://github.com/AlbertShenC/Algorithm) 上找到。 [點此](https://github.com/AlbertShen

一本正經的聊資料結構（2）：陣列與向量

前文傳送門： 一本正經的聊資料結構（1）：時間複雜度 引言 這個系列沒有死，我還在更新。 最近事情太多了，這篇文章也是斷斷續續寫了好幾天才湊完。 上一篇我們介紹了一個基礎概念「時間複雜度」，這篇我們來看第一個真正意義上的資料結構「陣列」。 那為什麼題目中還會有一個向量呢？這個是什麼東西？ 不要急，且聽我慢

資料結構實現（六）：連結串列棧（C++版）

資料結構實現（六）：連結串列棧（C++版） 1. 概念及基本框架 2. 基本操作程式實現 2.1 入棧操作 2.2 出棧操作 2.3 查詢操作 2.4 其他操作 3. 演算法複雜度分析 3.1

資料結構實現（五）：連結串列（C++版）

資料結構實現（五）：連結串列（C++版） 1. 概念及基本框架 2. 基本操作程式實現 2.1 增加操作 2.2 刪除操作 2.3 修改操作 2.4 查詢操作 2.5 其他操作 3. 演算法複雜度分析

Java資料結構（一）——連結串列

Java中的資料結構又很多種，如棧，佇列，樹等，但是他們的形式歸根到底就是兩種：一個是陣列，一個是連結串列，所有的結構都是對這兩個的變形。 什麼是線性表？ 陣列和連結串列都屬於是線性表，那什麼是線性表：一個線性表是n個相同特性的資料元素的有序序列。各元素之間是一對一的關係。但這並不是