Java實現單鏈表_使用鏈式存儲結構

Java實現單鏈表_使用鏈式存儲結構

單鏈表的示意圖：http://my.oschina.net/xinxingegeya/blog/261287

貼代碼，部分代碼參考：http://blog.csdn.net/zhangerqing/article/details/8796518

package hash;

/**
 * Created with IntelliJ IDEA.
 * User: ASUS
 * Date: 14-9-15
 * Time: 下午6:58
 * To change this template use File | Settings | File Templates.
 */
public class CustomLinkedList01<T> {

    /**
     * 用來表示單鏈表的節點類
     * class node
     *
     * @param <T>
     * @author egg
     */
    private static class Node<T> {
        T data;
        Node<T> next;

        Node(T data, Node<T> next) {
            this.data = data;
            this.next = next;
        }

        Node(T data) {
            this(data, null);
        }

        Node() {
        }
    }

    //頭指針指向頭結點
    //頭結點的數據域不存儲數據
    private Node<T> head;  //單鏈表的頭節點

    //初始化鏈表，初始化後的鏈表爲空
    public CustomLinkedList01() {
        head = new Node<T>();  //頭結點
    }

    /**
     * judge the list is empty
     * 除頭結點外沒有其餘節點，該鏈表爲空
     */
    public boolean isEmpty() {
        return head.next == null;
    }

    /**
     * 打印鏈表
     * print the list
     */
    public void traverse() {
        Node<T> p = head.next;
        for (Node<T> n = p; n != null; n = n.next)
            System.out.println(n.data);
    }

    /**
     * insert node from head
     * 頭插法
     */
    public void addFromHead(T item) {
        Node<T> newNode = new Node<T>(item);   //實例化一個節點
        Node<T> p = head.next;
        head.next = newNode;
        newNode.next = p;//新節點的後繼元素原來的head
    }

    /**
     * 尾插法
     * insert node from tail
     */
    public void addFromTail(T item) {
        Node<T> newNode = new Node<T>(item); //實例化一個新節點
        Node<T> p = head;
        while (p.next != null) { //遍歷到單鏈表的尾
            p = p.next;
        }
        p.next = newNode;    //尾節點的後繼節點爲新節點
        newNode.next = null; //新節點的後繼節點爲空
    }

    /**
     * delete node from head
     */
    public void removeFromHead() {
        if (!isEmpty()) {
            Node<T> p = head.next;  //刪除第一個節點
            head.next = p.next;
        } else {
            System.out.println("The list have been emptied!");
        }
    }

    /**
     * delete tail, lower effect
     * 刪除最後一個節點
     */
    public void removeFromTail() {
        if (isEmpty()) {
            System.out.println("The list have been emptied!");
        } else {
            //若是curr.next == null說明curr爲最後一個節點
            Node<T> prev = head, curr = head.next;
            while (curr.next != null) {
                prev = curr;
                curr = curr.next;
            }
            prev.next = null;
        }
    }

    /**
     * insert a new node
     * 在元素前面插入item
     *
     * @param appointedItem
     * @param item
     * @return
     */
    public boolean insertBefore(T appointedItem, T item) {
        Node<T> prev = head, curr = head.next, newNode;
        newNode = new Node<T>(item);
        //當到達尾節點或找到元素，跳出循環
        while ((curr != null) && (!appointedItem.equals(curr.data))) {
            prev = curr;
            curr = curr.next;
            // 若是到達鏈表的尾端，說明沒有找到插入點
            if (curr == null) {
                return false;
            }
        }
        newNode.next = curr;
        prev.next = newNode;
        return true;
    }

    /**
     * insert a new node
     *
     * @param appointedItem
     * @param item
     * @return
     */
    public boolean insertAfter(T appointedItem, T item) {
        Node<T> newNode = new Node<T>(item);
        Node<T> curr = head.next;
        //當到達尾節點或找到元素，跳出循環
        while ((curr != null) && (!appointedItem.equals(curr.data))) {
            curr = curr.next;
            if (curr == null) {
                return false;
            }
        }
        Node<T> p = curr.next;
        newNode.next = p;
        curr.next = newNode;
        return true;
    }


    /**
     * 刪除節點
     *
     * @param item
     */
    public void remove(T item) {
        Node<T> curr = head.next, prev = head;
        while (curr != null) {
            if (item.equals(curr.data)) {
                prev.next = curr.next;
                return;
            } else {
                prev = curr;
                curr = curr.next;
            }
        }
    }

    /**
     * 經過遍歷整個鏈表查找元素
     *
     * @param item
     * @return
     */
    public int indexOf(T item) {
        int index = 0;
        for (Node<T> p = head.next; p != null; p = p.next) {
            if (item.equals(p.data)) {
                return index;
            }
            index++;
        }
        return -1;
    }


    /**
     * judge the list contains one data
     */
    public boolean contains(T item) {
        return indexOf(item) != -1;
    }

    public static void main(String args[]) {
        CustomLinkedList01 linkedList = new CustomLinkedList01();

        linkedList.addFromHead("s1");
        linkedList.addFromHead("s2");
        linkedList.addFromHead("s3");
        linkedList.addFromHead("s4");
        linkedList.addFromHead("s5");
        linkedList.addFromHead("s6");
        linkedList.addFromTail("s00");
        linkedList.addFromTail("s01");
        linkedList.addFromTail("s02");

        System.out.println(linkedList.contains("s03"));

        System.out.println("#############insertBefore###############");
        linkedList.remove("s1");
        linkedList.traverse();


        System.out.println("#############insertBefore###############");
        linkedList.insertBefore("s3", "mm");
        linkedList.insertBefore("s02", "mm");
        linkedList.traverse();


        System.out.println("#############insertAfter###############");
        linkedList.insertAfter("mm", "uu");
        linkedList.insertAfter("uu", "pp");
        linkedList.traverse();

        System.out.println("#############removeFromHead###############");
        linkedList.removeFromHead();
        linkedList.traverse();


        System.out.println("#############removeFromTail###############");
        linkedList.removeFromTail();
        linkedList.traverse();


        System.out.println("#############removeFromTail###############");
        linkedList.removeFromTail();
        linkedList.traverse();
    }
}

 

在Java中，linkedList是這樣一種存儲結構

示例代碼以下，

package hash;

public class LinkedList<T> {

    /**
     * class node
     *
     * @param <T>
     * @author egg
     */
    private static class Node<T> {
        T data;
        Node<T> next;

        Node(T data, Node<T> next) {
            this.data = data;
            this.next = next;
        }

        Node(T data) {
            this(data, null);
        }
    }

    // data
    private Node<T> head, tail;

    public LinkedList() {
        head = tail = null;
    }

    /**
     * judge the list is empty
     */
    public boolean isEmpty() {
        return head == null;
    }

    /**
     * add head node
     */
    public void addHead(T item) {
        head = new Node<T>(item);
        if (tail == null)
            tail = head;
    }

    /**
     * add the tail pointer
     */
    public void addTail(T item) {
        if (!isEmpty()) {
            tail.next = new Node<T>(item);
            tail = tail.next;
        } else {
            head = tail = new Node<T>(item);
        }
    }

    /**
     * print the list
     */
    public void traverse() {
        if (isEmpty()) {
            System.out.println("null");
        } else {
            for (Node<T> p = head; p != null; p = p.next)
                System.out.println(p.data);
        }
    }

    /**
     * insert node from head
     */
    public void addFromHead(T item) {
        Node<T> newNode = new Node<T>(item);
        newNode.next = head;
        head = newNode;
    }

    /**
     * insert node from tail
     */
    public void addFromTail(T item) {
        Node<T> newNode = new Node<T>(item);
        Node<T> p = head;
        while (p.next != null)
            p = p.next;
        p.next = newNode;
        newNode.next = null;
    }

    /**
     * delete node from head
     */
    public void removeFromHead() {
        if (!isEmpty())
            head = head.next;
        else
            System.out.println("The list have been emptied!");
    }

    /**
     * delete frem tail, lower effect
     */
    public void removeFromTail() {
        Node<T> prev = null, curr = head;
        while (curr.next != null) {
            prev = curr;
            curr = curr.next;
            if (curr.next == null)
                prev.next = null;
        }
    }

    /**
     * insert a new node
     *
     * @param appointedItem
     * @param item
     * @return
     */
    public boolean insert(T appointedItem, T item) {
        Node<T> prev = head, curr = head.next, newNode;
        newNode = new Node<T>(item);
        if (!isEmpty()) {
            while ((curr != null) && (!appointedItem.equals(curr.data))) {
                prev = curr;
                curr = curr.next;
            }
            newNode.next = curr;
            prev.next = newNode;
            return true;
        }
        return false;
    }

    public void remove(T item) {
        Node<T> curr = head, prev = null;
        boolean found = false;
        while (curr != null && !found) {
            if (item.equals(curr.data)) {
                if (prev == null)
                    removeFromHead();
                else
                    prev.next = curr.next;
                found = true;
            } else {
                prev = curr;
                curr = curr.next;
            }
        }
    }


    public int indexOf(T item) {
        int index = 0;
        Node<T> p;
        for (p = head; p != null; p = p.next) {
            if (item.equals(p.data))
                return index;
            index++;

        }
        return -1;
    }

    /**
     * judge the list contains one data
     */
    public boolean contains(T item) {
        return indexOf(item) != -1;
    }
}

=====END=====