演算法與資料結構-連結串列((linked-list)-Java實現單向連結串列

西召發表於2019-02-16
演算法資料結構Java

資料結構中的單向連結串列

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
         */
    }


}

複製程式碼

相關文章