超级链表~

// 十万条数据，尾插7359ms，头插3ms！

public class Node {
    // 一个是真正存入的数据，另一个是指向下一个数据块的引用
    private Integer data;
    private Node next;

    public Node() {
    }

    public Node(Integer data, Node next) {
        this.data = data;
        this.next = next;
    }

    public Integer getData() {
        return data;
    }

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

    public Node getNext() {
        return next;
    }

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

优化——抽离出共有的方法

package Link;

public class SurperLink {

    // 链表的头部
    private Node head;

    private int currentindex = -1;

    // 对数据的增删改查
    // 增加一个元素，头插
    public void addToHeader(int data) {
        this.add(0, data);
    }

    // 增加一个元素，尾插
    public void addToTail(int data) {
        this.add(currentindex + 1, data);
    }

    // 指定位置插入
    public void add(int index, int data) {
        if (head == null) {
            head = new Node(data, null);
        } else {
            if (index == 0) {
                // 创建一个指向头部的node
                Node node = new Node(data, head);
                // 新的node变成头
                head = node;
            } else {
                // 找到下标为 index-1 的节点
                Node node = selectNode(index - 1);
                // 在指定下标插入
                Node newNode = new Node(data, node.getNext());
                node.setNext(newNode);
            }
        }
        currentindex++;
    }


    // 删除一个元素
    public void delete(int index) {

        if (index == 0) {
            head = head.getNext();
        } else {
            Node node = selectNode(index - 1);
            // 删除的核心
            node.setNext(node.getNext().getNext());
        }
    }


    // 修改一个元素
    public void set(int index, int data) {
        // 找到下标为index的节点
        selectNode(index).setData(data);
    }


    // 查询一个元素
    // 使用 Integer 比使用 int 多一个 NULL
    public Integer select(int index) {
        return selectNode(index).getData();
    }

    // 抽离出共有的方法
    private Node selectNode(int index) {
        Node node = head;
        for (int i = 0; i < index; i++) {
            node = node.getNext();
        }
        return node;
    }


    // 获取长度
    public int size() {
        return currentindex + 1;
    }


    // 把我的数组变成字符串
    public String arrayToString() {
        String result = "[";
        for (int i = 0; i <= currentindex; i++) {
            result += select(i) + ",";
        }
        return result.substring(0, result.length() - 1) + "]";
    }


}

链表排序

只能排1000条左右，耗时848ms

    public void sort() {
        for (int i = 0; i < currentIndex; i++) {
            for (int j = 0; j < currentIndex - 1; j++) {
                int temp = select(j);
                selectNode(j).setData(selectNode(j + 1).getData());
                selectNode(j + 1).setData(temp);
            }
        }
    }

优化

1000条，耗时193ms

2000   1588ms

3000    5442ms

    public void sort() {
        for (int i = 0; i < currentIndex; i++) {
            for (int j = 0; j < currentIndex - 1; j++) {
                Node node = selectNode(j);
                Node next = node.getNext();

                if (node.getData() > next.getData()) {
                    int temp = node.getData();
                    node.setData(next.getData());
                    next.setData(temp);
                }
            }
        }
    }

再优化

1000条，耗时32ms

10000   288ms

    // 再优化
    public void sort() {
        for (int i = 0; i < currentIndex; i++) {
            Node node = null;
            for (int j = 0; j < currentIndex - 1; j++) {
                if (j == 0) {
                    node = head;
                } else {
                    // 每次循环就是找下一个
                    node = node.getNext();
                }
                Node next = node.getNext();
                if (node.getData() > next.getData()) {
                    int temp = node.getData();
                    node.setData(next.getData());
                    next.setData(temp);
                }
            }
        }
    }