java實現單鏈表增刪改查

package 數據結構算法.鏈表;

/*
 *定義節點
 *  鏈表由節點構成
 */
public class Node<E> {
    private E e;   //數據data
    private Node<E> next; //指向下一個節點

    public Node() {

    }

    public Node(E e) {
        this.e = e;
    }

    public Node<E> getNext() {
        return next;
    }

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

    public E getE() {
        return e;
    }

    public void setE(E e) {
        this.e = e;
    }
}

package 數據結構算法.鏈表;

/*
 * 定義實現類MyLinkedList
　*　實現鏈表的基本功能：增刪改查
 */
public class MyLinkedList<E> {
    //聲明頭節點尾節點
    private Node<E> head;
    private Node<E> last;
    //鏈表的大小
    private int size;
    private int modcount; //計算被修改的次數

    public MyLinkedList() {
        head = new Node<E>();//實例化頭結點
        last = head;
    }

    /*
     *返回單鏈表中存儲的元素總數
     */
    public int size() {
        return size;
    }

    /*
     *獲取指定索引位置的節點對象
     */
    public Node<E> get(int index) {
        if (index < 0 || index > size - 1)
            return null;
        Node<E> node = head.getNext();//將頭結點的下一個節點賦給Node
        for (int i = 0; i < index; i++) {
            node = node.getNext();//獲取node的下一個節點
        }
        return node;
    }

    /*
     *獲取指定索引位置的數據
     */
    public E getValue(int index) {
        if (index < 0 || index > size - 1)
            return null;
        Node<E> node = get(index);
        return node.getE();
    }

    /*
     *增加元素
     */
    public void add(E e) {
        Node<E> node = new Node<E>(e); //以e實例化一個節點
        last.setNext(node);//往尾節點后追加節點
        last = node;//該節點設為最后一個節點
        size++;
        modcount++;
    }

    /*
     *指定位置插入元素,返回插入的節點數據
     */
    public E add(int index, E e) {
        if (index < 0 || index > size - 1)
            return null;
        Node<E> node = new Node<E>(e); //實例化一個節點
        //找到插入的原節點
        Node<E> oldNode = get(index);
        if (index == 0) {//當索引為0時
            head.setNext(node);
        } else {
            //找到插入節點的上一個
            Node<E> bNode = get(index - 1);
            bNode.setNext(node);
        }
        node.setNext(oldNode);
        size++;
        modcount++;
        return oldNode.getE();
    }

    /*
     *刪除指定的節點e,並返回刪除節點的數據
     */
    public E delete(int index) {
        if (index < 0 || index > size - 1)
            return null;
        if (index == 0) {//當索引為1，令頭結點的下一個節點為頭結點
            Node<E> node = head.getNext();
            head.setNext(node.getNext());
        }
        //獲取要刪除節點的前一個節點
        Node<E> bNode = get(index - 1);
        //獲取要刪除的節點
        Node<E> Node = bNode.getNext();
        //獲取要刪除節點的下一個節點
        Node<E> nNode = Node.getNext();
        //刪除該節點
        bNode.setNext(nNode);
        //清除Node的下一個節點
        Node.setNext(null);
        size--;
        modcount++;
        return Node.getE();//返回節點中的數據域
    }

    /*
     *修改指定位置的數據域並返回修改后的數據
     */
    public E set(int index, E e) {
        if (index < 0 || index > size - 1)
            return null;
        //獲取指定位置的原節點
        Node<E> node = get(index);
        node.setE(e);
        modcount++;
        return node.getE();
    }
}

package 數據結構算法.鏈表;

/*
 *定義測試類
 */
public class MyLinkedListTest {
    public static void main(String[] args) {
        MyLinkedList<String> list = new MyLinkedList<>();

        //測試add
        list.add("one");
        list.add("two");
        list.add("three");
        list.add("four");
        list.add(0,"newone");
        list.add(1,"newtwo");
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.getValue(i)+" ");
        }

        //測試set
        System.out.println();
        list.set(0, "111");
        list.set(1, "222");
        System.out.println(list.getValue(0) + "   " + list.getValue(1));

        //測試delete
        System.out.println();
        list.delete(1);
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.getValue(i)+" ");
        }
    }
}

運行結果如下：

 

參考自：https://zhuanlan.zhihu.com/p/30141170