数据结构（3）-线性表（静态链表）

用数组来描述单链表；
让数组的元素都是由两个数据域组成，data和cur。数组的每一个下标都对应一个data和cur。数据域data用来存放数据，而游标cur相当于单链表中的next，存放该元素的后继在数组中的下标。
优点：在插入和删除操作时，只需要修改游标，不需要移动元素，从而改进了在顺序存储结构中的插入和删除操作需要移动大量元素的缺点；
缺点：没有解决连续存储分配带来的表长难以确定的问题，失去了顺序存储结构随机存取的特性；

package com.qddx.chapter3;

public class MyStaticList {

    public static void main(String[] args) {
        StaticList<String> list1 = new StaticList<String>();
        list1.add(1, "aaa");
        list1.add(1, "bbb");
        list1.add(1, "ccc");
        System.out.println(list1);
        list1.add("ddd");
        System.out.println(list1.listSize());
        System.out.println(list1.delete(4));
        System.out.println(list1.listSize());
        System.out.println(list1);

    }

}

class StaticNode<T> {// 定义节点
    T data;
    int cur;
}

class StaticList<T> {

    private int maxSize = 100;
    private int size = 1;
    // private int currentFree = 0;// 指定当前空闲位置
    private StaticNode<T>[] linkList = null;
    private int r = maxSize - 1;

    // 静态链表的长度
    public int listSize() {
        return size - 1;
    }

    // 静态链表构造函数 不指定大小
    public StaticList() {
        this.maxSize = maxSize;
        r = maxSize - 1;
        linkList = new StaticNode[maxSize];
        initSpace();
    }

    // 静态链表构造函数 指定了静态链表的大小
    public StaticList(int defaultSize) {
        r = defaultSize - 1;
        linkList = new StaticNode[defaultSize];
        initSpace();
    }

    // 初始化空间
    private void initSpace() {
        for (int i = 0; i < linkList.length - 1; i++) {
            linkList[i] = new StaticNode<T>();
            linkList[i].cur = i + 1;
        }
        // 头结点
        linkList[linkList.length - 1] = new StaticNode<T>();
        linkList[linkList.length - 1].cur = 0;// 目前静态链表为空，最后一个元素而的cur为0

    }

    // 分配空间 返回0 认为已经没有可用的空间
    private int malloc() {
        int i = linkList[0].cur;
        if (i != 0) {
            linkList[0].cur = linkList[i].cur;
        }
        return i;
    }

    // 默认是在最前面插入元素
    public void add(T data) {
        int i = malloc();
        if (i == 0) {
            addSpace();
        }
        linkList[i].cur = linkList[linkList.length - 1].cur;
        linkList[linkList.length - 1].cur = i;
        linkList[i].data = data;
        size++;

    }

    // 静态链表扩容
    private void addSpace() {
        maxSize += 8;
        StaticNode<T>[] link = linkList;
        linkList = new StaticNode[maxSize];
        System.arraycopy(link, 0, linkList, 0, link.length);
        for (int i = link.length; i < maxSize; i++) {
            linkList[i] = new StaticNode<T>();
            linkList[i].cur = i + 1;
        }
        linkList[0].cur = link.length;
    }

    // 向静态链表的指定位置插入一个数据
    public void add(int index, T data) {
        int temp = 0;
        int j = 2;
        if (index < 1 || index > linkList.length - 2) {
            throw new IndexOutOfBoundsException("线性表索引越界");
        }
        int i = malloc();
        if (i == 0 || index == linkList.length - 1) {
            addSpace();
        }

        if (index == 1) {
            add(data);
            /*
             * temp = linkList[linkList.length - 1].cur; int m =
             * linkList[0].cur;// 找出空闲空间 linkList[0].cur = linkList[m].cur;//
             * 将该空闲空间的下一个空闲空间赋值给头结点 linkList[linkList.length - 1].cur = m;
             * linkList[m].cur = temp; linkList[m].data = data; size++;
             */
        } else {
            temp = linkList[linkList.length - 1].cur;
            while (j != index) {
                temp = linkList[temp].cur;
                j++;
            }
            int t = linkList[0].cur;// 找出空闲空间
            linkList[0].cur = linkList[t].cur;// 将该空闲空间的下一个空闲空间赋值给头结点
            linkList[t].cur = linkList[temp].cur;// index位置的下一个的索引赋值给该空闲空间的索引
            linkList[temp].cur = t;// 将该空闲的索引赋值给index位置之前的索引
            linkList[t].data = data;// 进行数据赋值
            size++;
        }

    }

    // 删除指定位置的元素 成功则返回要删除的元素，失败则返回null
    public T delete(int index) {
        int temp = linkList[linkList.length - 1].cur;
        int previous = linkList[linkList.length - 1].cur;
        int j = 1;
        if (index < 0 || index > size) {
            return null;
        } else {

            while (j != index) {
                previous = temp;
                temp = linkList[temp].cur;
                j++;
            }
            linkList[previous].cur = linkList[temp].cur;
            size--;
            return linkList[temp].data;

        }
    }

    @Override
    public String toString() {
        String str = "[";
        if (size == 0) {
            return "[]";
        } else {
            int temp = linkList[linkList.length - 1].cur;
            while (linkList[temp].data != null) {
                str += linkList[temp].data.toString() + ",";
                temp = linkList[temp].cur;
            }
            return str + "]";
        }
    }
}

本文有些许不完善的地方，代码仅供参考，欢迎交流学习。
参考1
参考2