使用數組實現鏈表--Java

時間 2019-11-17

標籤使用數組實現鏈表 java 欄目 Java 简体版

原文原文鏈接

聲明：基本實現，細節不過多追究。。。java

數組須要在建立的時候分配好空間使用，根據索引查詢便可；而鏈表則不需提早分配空間，須要使用的時候動態分配便可。鏈表中數據的訪問是經過指針實現，每一個元素都包含下一個元素的一個索引。經過數組實現鏈表，那麼思路以下：node

數組中的每一個元素是一個對象，包含兩個字段：遊標和data。數組

第一次初始化時的數據以下：數據結構

如今看具體方法：this

add方法

public void add(T data) {
        Node node = nodeArray[maxSize - 1];
        int cur = node.getCur();
        int index = 1;
        if (cur == 0) {
            //空數組
        } else {
            while (node.getCur() > 0) {
                node = nodeArray[node.getCur()];
            }
            index = nodeArray[0].getCur();
        }
        //獲取要設置數據的節點
        Node currentNode = nodeArray[index];
        //上個節點下個遊標爲設置數據的節點的索引
        node.setCur(index);
        //備用鏈表的起始節點的遊標改成設置數據節點的遊標
        nodeArray[0].setCur(currentNode.getCur());
        //設置遊標爲0表示鏈表結束
        currentNode.setCur(0);
        currentNode.setData(data);

        ++length;
    }

添加數據時，先獲取要添加數據的節點的前置節點node
nodeArray[index]則爲要設置數據的節點
將node的遊標指向nodeArray[index]
nodeArray[0]的遊標指向currentNode的遊標指向的節點
設置currentNode的遊標爲0表示結尾；設置數據

簡單理解：先找到最後一個數據節點（node），而後找到該節點的遊標指向的節點（currentNode）,nodeArray[0]的遊標指向currentNode的遊標指向的節點（備用鏈表），node的遊標指向currentNode，currentNode的遊標修改成0表示結尾，設置數據。指針

insert方法

public void insert(int i, T data) {
        Node node = nodeArray[maxSize - 1];
        int j = 0;
        while (node.getCur() > 0 && i> j) {
            node = nodeArray[node.getCur()];
            j++;
        }
        //獲取要插入數據的位置
        int cur = nodeArray[0].getCur();

        Node n = nodeArray[cur];
        //設置備用列表指針
        nodeArray[0].setCur(n.getCur());

        n.setCur(node.getCur());
        n.setData(data);

        node.setCur(cur);


        ++length;
    }

先根據索引Index查找到要插入數據的前置節點-node
根據nodeArray[0]的遊標查找到要插入數據的節點n
nodeArray[0]的遊標設置爲n的遊標指向的節點
n的遊標設置爲node的遊標指向的節點，設置數據data
node的遊標指向爲n

delete方法

public void delete(int i){
        Node node = nodeArray[maxSize - 1];
        int j = 0;
        while (node.getCur() > 0 && i> j) {
            node = nodeArray[node.getCur()];
            j++;
        }
        int cur = node.getCur();
        Node n = nodeArray[cur];

        node.setCur(n.getCur());

        n.setCur(nodeArray[0].getCur());
        nodeArray[0].setCur(cur);

        --j;

    }

先找到要刪除節點的前置節點node
根據node的遊標cur找到要刪除的節點n
設置node的遊標指向n的遊標指向的節點
設置n的遊標指向nodeArray[0]的遊標指向的節點
設置nodeArray[0]的遊標爲cur

以上即爲經過數組實現的簡單鏈表，完整代碼以下：code

package com.vincent.array;

/**
 * Vincent 建立於 2016/7/26.
 */
public class LinkedList<T> {

    private int maxSize = Integer.MAX_VALUE;

    private int length = 0;

    private Node[] nodeArray = null;

    public LinkedList() {
        nodeArray = new Node[this.maxSize];
        init();
    }

    public LinkedList(int maxSize) {

        this.maxSize = maxSize;
        nodeArray = new Node[maxSize];
        init();
    }


    private void init() {
        for (int i = 0; i < maxSize; i++) {
            Node node = new Node(i + 1);
            nodeArray[i] = node;
        }
        nodeArray[maxSize - 1].setCur(0);
    }

    public void add(T data) {
        Node node = nodeArray[maxSize - 1];
        int cur = node.getCur();
        int index = 1;
        if (cur == 0) {
            //空數組
        } else {
            while (node.getCur() > 0) {
                node = nodeArray[node.getCur()];
            }
            index = nodeArray[0].getCur();
        }
        //獲取要設置數據的節點
        Node currentNode = nodeArray[index];
        //上個節點下個遊標爲設置數據的節點的索引
        node.setCur(index);
        //備用鏈表的起始節點的遊標改成設置數據節點的遊標
        nodeArray[0].setCur(currentNode.getCur());
        //設置遊標爲0表示鏈表結束
        currentNode.setCur(0);
        currentNode.setData(data);

        ++length;
    }


    public void insert(int i, T data) {
        Node node = nodeArray[maxSize - 1];
        int j = 0;
        while (node.getCur() > 0 && i> j) {
            node = nodeArray[node.getCur()];
            j++;
        }
        //獲取要插入數據的位置
        int cur = nodeArray[0].getCur();

        Node n = nodeArray[cur];
        //設置備用列表指針
        nodeArray[0].setCur(n.getCur());

        n.setCur(node.getCur());
        n.setData(data);

        node.setCur(cur);


        ++length;
    }

    public void delete(int i){
        Node node = nodeArray[maxSize - 1];
        int j = 0;
        while (node.getCur() > 0 && i> j) {
            node = nodeArray[node.getCur()];
            j++;
        }
        int cur = node.getCur();
        Node n = nodeArray[cur];

        node.setCur(n.getCur());

        n.setCur(nodeArray[0].getCur());
        nodeArray[0].setCur(cur);

        --j;

    }

    private class Node<T> {
        private T data;
        private int cur;

        public Node() {
        }

        public Node(int cur) {
            this.cur = cur;
        }

        public Node(T data, int cur) {
            this.data = data;
            this.cur = cur;
        }

        public T getData() {
            return data;
        }

        public void setData(T data) {
            this.data = data;
        }

        public int getCur() {
            return cur;
        }

        public void setCur(int cur) {
            this.cur = cur;
        }
    }
}

經過數組實現鏈表加深了二者的理解，數組和鏈表各有優缺點，在不一樣條件下選擇合適的數據結構有利於提升效率。對象