java 实现静态链表

java实现静态链表

底层是数组+节点类；
这个还是有点复杂的，写的时候发现有问题，找了好久，最后发现只是用错了循环和判断语句，一言难尽啊。

代码

/**
 * 静态链表节点
 * @param <E>
 */
public class SLNode<E> {
    private E data;
    public int next;
    public void setData(E e){
        this.data = e;
    }
    public E getData(){
        return this.data;
    }
}

/**
 * 静态链表
 * 用一个数组和单链表组成
 * 数组里储存着单链表的节点
 * 实现功能：
 * 1、在空链表头位置添加数据
 * 2、获取表内元素个数
 * 3、删除某一位置元素
 * 4、获取表头元素
 * 5、输出表内所有元素
 * 只是了解一下原理，其他功能就没有去实现
 * @param <E>
 */
public class SLinkedList<E> {
    // 储存节点的数组,没有空的节点，都可以储存数据
    private SLNode<E>[] nodes;
    // 静态链表的头指针位置
    private int head = -1;
    // 空闲链的第一个位置
    private int avail = 0;
    // 全局变量n
    private int n;
    // 初始化的数组长度
    private final static int len = 10;
    // 数组中存储数据的个数
    private int size;
    
    // 初始化数组
    public SLinkedList(){
        this(len);
    }
    // 带参数初始化数组
    public SLinkedList(int len){
        nodes = new SLNode[len];
    }
    // 获取元素个数
    public int getSize(){
        return this.size;
    }

    // 找到链表表尾位置
    private void getLast(){
        n = head;
        while(nodes[n].next != -1){
            n = nodes[n].next;
        }
    }

    // 在空闲链表头位置添加数据
    public void add(E e){
        if(size > nodes.length - 1)
            System.out.println("表已满！没有空余单元");
        else{
            // 判断一下现在空闲链表头的位置是否储存过数据
            if(nodes[avail] == null){ // 没有的话
                // 创建一个新的节点
                SLNode<E> node = new SLNode<>();
                // 节点存入数据
                node.setData(e);
                // 设置表尾标志
                node.next = -1;
                // 将新建的node节点添加到数组内
                nodes[avail] = node;
                // 判断是否为空静态链表
                if(head == -1){
                    // 设置链表头
                    head = avail;
                }
                else{
                    // 找到链表表尾位置
                    this.getLast();
                    // 改变尾节点
                    nodes[n].next = avail;
                }
                // 空链表头
                avail ++;
            }
            else{ // 如果之前储存过数据
                // 判断是否为空静态链表
                if(head == -1){
                    head = avail;
                }
                else{
                    getLast();
                    nodes[n].next = avail;
                }
                nodes[avail].setData(e);
                int next = nodes[avail].next;
                nodes[avail].next = -1;
                avail = next;
            }
            // 储存的数据个数+1
            size ++;
        }
    }

    // 删除某一位置元素
    public E remove(int index){
        E e = null;
        if(size == 0 || index > size - 1)
            System.out.println("删除位置异常！！！");
        else{
            // 如果删除的是表头
            if(index == 0){
                // 1、
                int next = nodes[head].next;
                // 2、
                e = nodes[head].getData();
                nodes[head].setData(null);
                // 3、
                nodes[head].next = avail;
                // 4、
                avail = head;
                // 5、
                head = next;
            }
            else{ // 删除的不是表头
                // 1、找到删除节点的前一个节点位置
                n = head;
                for(int i = 0;i < index - 1;i ++)
                    n = nodes[n].next;
                // 2、找到删除节点位置,还有改变节点指向
                int x = nodes[n].next;
                int next = nodes[x].next;
                nodes[n].next = next;
                // 3、
                e = nodes[x].getData();
                nodes[x].setData(null);
                nodes[x].next = avail;
                avail = x;
            }
            size --;
        }
        return e;
    }
    // 获取表头元素
    public E getTop(){
        E e = null;
        if(size == 0)
            System.out.println("表内没有元素，表头获取失败！！！");
        else{
            e = nodes[head].getData();
        }
        return e;
    }
    // 输出表内所有元素
    public void show(){
        System.out.println("表内所有元素：");
        n = head;
        for(int i = 0;i < size;i ++){
            System.out.print(nodes[n].getData() + "  ");
            n = nodes[n].next;
        }
        System.out.println();
    }

}

/**
 * 静态链表测试类
 */
public class SLDemo {

    // 输出相应的数据
    public static void print(SLinkedList list){
        System.out.println("元素个数：" + list.getSize());
        System.out.println("表头元素：" + list.getTop());

    }
    public static void main(String[] args){
        // 创建可以储存5个元素的静态链表
        SLinkedList<String> list = new SLinkedList<>(5);
        // 添加数据
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        list.add("5");

        print(list);
        list.show();

        // 删除数据
        System.out.println("删除的第0个数据" + list.remove(0));

        print(list);
        list.show();

        System.out.println("删除的第1个数据" + list.remove(1));

        print(list);
        list.show();

        // 添加元素
        list.add("6");
        list.add("7");

        print(list);
        list.show();

        // 把所有元素都删除
        for(int i = 0;i < 5;i ++)
            list.remove(0);

        print(list);

        // 再添加数据
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        list.add("5");

        print(list);
        list.show();

    }
}

测试结果

结果：
元素个数：5
表头元素：1
表内所有元素：
1  2  3  4  5  
删除的第0个数据1
元素个数：4
表头元素：2
表内所有元素：
2  3  4  5  
删除的第1个数据3
元素个数：3
表头元素：2
表内所有元素：
2  4  5  
元素个数：5
表头元素：2
表内所有元素：
2  4  5  6  7  
元素个数：0
表内没有元素，表头获取失败！！！
表头元素：null
元素个数：5
表头元素：1
表内所有元素：
1  2  3  4  5