資料結構中的單向連結串列
PASCAL語言之父、圖靈獎得主尼古拉斯·沃斯(Niklaus Wirth)曾有一句在計算機領域幾乎人盡皆知的名言：“演算法+資料結構=程式”（Algorithm+Data Structures=Programs）。
資料結構指的是是計算機儲存、組織資料的方式。其中資料的邏輯結構分為線性結構和非線性結構。
線性結構是一個有序資料元素的集合，其資料元素之間的關係是一對一的關係，即除了第一個和最後一個資料元素之外，其它資料元素都是首尾相接的。
最基礎的兩種表示元素集合的方式就是陣列和連結串列。
陣列指的是有序的元素序列。其中一維陣列是線性的資料結構。陣列的優點是通過索引可以訪問任意元素，查詢快。陣列的缺點是在初始化陣列的時候，就要知道陣列的元素數量，而且插入和刪除元素非常複雜。
連結串列就很好地解決了陣列的缺點，其使用的空間大小和元素數量成正比，即不需要提供初始化的大小，而且插入和刪除元素比較簡單，不會“牽一髮而動全身”。連結串列的缺點是需要通過引用訪問任意元素，查詢很複雜。
連結串列是一種遞迴的資料結構。一般連結串列分為單向連結串列和雙向連結串列兩種實現。
單向連結串列（單連結串列、線性連結串列）是連結串列的一種，其特點是連結串列的連結方向是單向的，對連結串列的訪問要通過從頭部開始，依序往下讀取。而雙向連結串列（雙連結串列）的每個資料結點中都有兩個指標，分別指向直接後繼和直接前驅。所以，從雙向連結串列中的任意一個結點開始，都可以很方便地訪問它的前驅結點和後繼結點。
下面通過Java語言實現單向連結串列，來展示連結串列的相關操作。
Java實現單向連結串列
單向連結串列的每個節點只需要定義兩個屬性：當前節點的元素，下一個節點。
class Node{
Item item;
Node node;
}
複製程式碼使用連結串列實現棧
棧是一種先進後出(FILO)的資料結構，如果通過陣列實現棧，則要考慮陣列擴容的問題，可以通過連結串列來解決這個問題。
下面通過連結串列實現棧，並藉此演示了在連結串列的頭部增加節點以及除連結串列頭部節點。
package net.ijiangtao.tech.algorithms.algorithmall.datastructure.stack;
public interface Stack<Item> {
/**
* add an item
*
* @param item
*/
void push(Item item);
/**
* remove the most recently added item
*
* @return
*/
Item pop();
/**
* is the stack empty?
*
* @return
*/
boolean isEmpty();
/**
* number of items in the stac
*/
int size();
}
複製程式碼package net.ijiangtao.tech.algorithms.algorithmall.datastructure.stack.impl;
import net.ijiangtao.tech.algorithms.algorithmall.datastructure.stack.Stack;
import java.util.Iterator;
/**
* 連結串列實現可迭代的棧
* @param <Item>
* @author ijiangtao.net
*/
public class IterableLinkedListStack<Item> implements Stack<Item>,Iterable<Item> {
/** 棧頂元素 */
private Node first;
/** 棧元素數量 */
private int N;
/** 通過內部類定義連結串列節點 */
private class Node{
Item item;
Node next;
}
/**
* 向棧頂增加元素，即在連結串列的頭插入節點
* @param item
*/
@Override
public void push(Item item) {
Node oldFirst=first;
first=new Node();
first.item=item;
first.next=oldFirst;
N++;
}
/**
* 從棧頂移除元素，即移除連結串列的頭部節點
* @return
*/
@Override
public Item pop() {
Item item=first.item;
first=first.next;
N--;
return item;
}
@Override
public boolean isEmpty() {
return N==0;
}
@Override
public int size() {
return N;
}
@Override
public Iterator<Item> iterator() {
return new ListIterator();
}
/**
* 支援迭代方法，實現在內部類裡
*/
private class ListIterator implements Iterator<Item> {
private Node current = first;
@Override
public boolean hasNext() {
//或者 N!=0
return current !=null;
}
@Override
public Item next() {
Item item=current.item;
current=current.next;
return item;
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
}
public static void main(String[] args) {
//測試
Stack<String> stack=new IterableLinkedListStack<>();
stack.push("aa");
stack.push("bbb");
stack.push("abc");
for (String s:(IterableLinkedListStack<String>)stack) {
System.out.println(s);
}
System.out.println("stack.size="+stack.size());
System.out.println("stack.pop="+stack.pop());
System.out.println("stack.size="+stack.size());
System.out.println("stack.isEmpty="+stack.isEmpty());
System.out.println("stack.pop="+stack.pop());
System.out.println("stack.pop="+stack.pop());
System.out.println("stack.size="+stack.size());
System.out.println("stack.isEmpty="+stack.isEmpty());
//測試輸出
/**
* abc
* bbb
* aa
* stack.size=3
* stack.pop=abc
* stack.size=2
* stack.isEmpty=false
* stack.pop=bbb
* stack.pop=aa
* stack.size=0
* stack.isEmpty=true
*/
}
}
複製程式碼使用連結串列實現佇列
佇列是一種基於先進先出(FIFO)策略的集合模型。
下面基於連結串列實現佇列，並演示使用。
package net.ijiangtao.tech.algorithms.algorithmall.datastructure.queue;
/**
* 佇列
* @author ijiangtao.net
* @param <Item>
*/
public interface Queue<Item> {
/**
* 佇列是否為空
* @return
*/
boolean isEmpty();
/**
* 佇列大小
* @return
*/
int size();
/**
* 入隊
* @param item
*/
public void enqueue(Item item);
/**
* 出隊
* @return
*/
public Item dequeue();
}
複製程式碼package net.ijiangtao.tech.algorithms.algorithmall.datastructure.queue.impl;
import net.ijiangtao.tech.algorithms.algorithmall.datastructure.queue.Queue;
import java.util.Iterator;
/**
* 佇列
* @author ijiangtao.net
* @param <Item>
*/
public class IterableLinkedListQueue<Item> implements Queue<Item>,Iterable<Item>{
/** 隊頭，最初入隊的節點 */
private Node first;
/**隊尾，最晚入隊的節點*/
private Node last;
/** 佇列中元素的數量 */
private int N;
private class Node{
Item item;
Node next;
}
@Override
public boolean isEmpty() {
//或N==0
return first==null;
}
@Override
public int size() {
return N;
}
/**
* 入隊，即向隊尾增加一個元素
* @param item
*/
@Override
public void enqueue(Item item) {
Node oldLast=last;
last=new Node();
last.item=item;
last.next=null;
if (isEmpty()){
first=last;
}else {
oldLast.next=last;
}
N++;
}
/**
* 出隊，即移除隊頭元素
* @return
*/
@Override
public Item dequeue() {
Item item=first.item;
first=first.next;
if (isEmpty()){
last=null;
}
N--;
return item;
}
@Override
public Iterator<Item> iterator() {
return new ListIterator();
}
/**
* 支援迭代方法，實現在內部類裡
*/
private class ListIterator implements Iterator<Item> {
private Node current = first;
@Override
public boolean hasNext() {
//或者 N!=0
return current !=null;
}
@Override
public Item next() {
Item item=current.item;
current=current.next;
return item;
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
}
public static void main(String[] args) {
//測試
Queue<String> queue=new IterableLinkedListQueue<>();
queue.enqueue("aa");
queue.enqueue("bbb");
queue.enqueue("abc");
for (String s:(IterableLinkedListQueue<String>)queue) {
System.out.println(s);
}
System.out.println("queue.size="+queue.size());
System.out.println("queue.dequeue="+queue.dequeue());
System.out.println("queue.size="+queue.size());
System.out.println("queue.isEmpty="+queue.isEmpty());
System.out.println("queue.dequeue="+queue.dequeue());
System.out.println("queue.dequeue="+queue.dequeue());
System.out.println("queue.size="+queue.size());
System.out.println("queue.isEmpty="+queue.isEmpty());
//測試輸出
/**
* aa
* bbb
* abc
* queue.size=3
* queue.dequeue=aa
* queue.size=2
* queue.isEmpty=false
* queue.dequeue=bbb
* queue.dequeue=abc
* queue.size=0
* queue.isEmpty=true
*/
}
}
複製程式碼使用連結串列實現揹包
揹包是一種只支援新增不支援刪除的容器，它的作用是收集元素，並遍歷所收集到的元素。
包(Bag)與棧一樣，遵循先進後出的策略（FILO）。
下面提供基於連結串列的揹包實現。
package net.ijiangtao.tech.algorithms.algorithmall.datastructure.bag;
/**
* 揹包
* @author ijiangtao.net
* @param <Item>
*/
public interface Bag<Item> extends Iterable<Item>{
/**
* 向背包內加入元素
* @param item
*/
void add(Item item);
}
複製程式碼package net.ijiangtao.tech.algorithms.algorithmall.datastructure.bag.impl;
import net.ijiangtao.tech.algorithms.algorithmall.datastructure.bag.Bag;
import java.util.Iterator;
public class IterableLinkedListBag<Item> implements Bag<Item> {
private Node first;
private class Node{
Item item;
Node next;
}
@Override
public void add(Item item) {
Node oldFirst=first;
first=new Node();
first.item=item;
first.next=oldFirst;
}
@Override
public Iterator<Item> iterator() {
return new ListIterator();
}
/**
* 支援迭代方法，實現在內部類裡
*/
private class ListIterator implements Iterator<Item> {
private Node current = first;
@Override
public boolean hasNext() {
//或者 N!=0
return current !=null;
}
@Override
public Item next() {
Item item=current.item;
current=current.next;
return item;
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
}
public static void main(String[] args) {
//測試
Bag<String> bag=new IterableLinkedListBag<>();
bag.add("aa");
bag.add("bbb");
bag.add("abc");
for (String s:bag) {
System.out.println(s);
}
//測試輸出
/**
* abc
* bbb
* aa
*/
}
}
複製程式碼