用链表实现线性表

在实现的时候我们先来说说什么是链表？

其实,链表就像是解密游戏一样,只有到达一个地点,才会有NPC给你下一个地点的地图,从而才能知道下个地点的位置
所以链表也是一样,对于一个链表,一个结点除了要保存结点自身的值以外,还需要保存下一个结点的地址.

这是一个简单链表的单个结点,val代表当前结点存储的值,next是一个引用,指向下一个结点
由于Java中不存在指针,所以结点通常为一个类,而next则是一个结点类实例的引用

可以看到,每一结点都保存了下一个节点的地址,所以,链表不要求每个结点中的地址空间连续
所以如何创建一个链表呢？那么下面我们就来实现

方法接口

定义一个方法接口

public interface ListMethods<T> {
    void clear();
    boolean isEmpty();
    int length();
    T get(int i);
    void insert(T t);
    void insert(int i, T t);
    T remove(int i);
    int indexOf(T t);
}

创建链表类

public class LinkList<T> {
    private Node head; // 头节点
    private int N; // 链表元素统计数

    // 在类中创建一个私有类
    private class Node {
        T item; // 用来存储数据元素
        Node next; // 定一个Node对象来指向下一个类的地址

        public Node(T item, Node next) {
            this.item = item;
            this.next = next;
        }
    }

    public LinkList() {
        this.head = new Node(null, null);
        this.N = 0;
    }
}

清空链表

    public void clear() {
        head.next = null;
        this.N = 0;
    }

判断链表是否为空

    public boolean isEmpty() {
        return N == 0;
    }

获取链表长度

    public int length() {
        return N;
    }

获取指定位置的元素

    public T get(int i) {
        if(head.next == null) {
            return null;
        }
        Node n = head.next;
        for (int index = 0; index < i; index++) {
            n = n.next;
        }
        return n.item;
    }

向线性表中添加元素t

    public void insert(T t) {
        Node n = head;  // 把头节点复制给一个新元素
        while (n.next != null) {
            n = n.next;
        }
        n.next = new Node(t, null);
        N++;
    }

在i元素处插入元素t

    public void insert(int i, T t) {
        Node n = head;
        for (int index = 0; index < i; index++) {
            n = n.next;
        }
        n.next = new Node(t, n.next);
        N++;
    }

删除线性表中下标为i的元素

    public T remove(int i) {
        Node n = head;
        for (int index = 0; index < i; index++) {
            n = n.next;
        }
        Node name = n.next;
        n.next = name.next;
        N--;
        return name.item;
    }

查找元素t是否在线性表中，如果在则返回下标

    public int indexOf(T t) {
        Node n = head;
        for (int i = 0; n.next != null; i++) {
            n = n.next;
            if (n.item.equals(t)) {
                return i;
            }
        }
        return -1;
    }

反转整个链表

    /**
     * 用来反转整个链表
     */
    public void reverse() {
        // 判断当前链表是否为空链表
        if (isEmpty()) {
            return;
        }
        reverse(head.next);
    }

    /**
     * 反转指定的结点curr， 并把反转后的结点返回
     *
     * @param curr
     * @return
     */
    public Node reverse(Node curr) {
        if (curr.next == null) {
            head.next = curr;
            return curr;
        }
        // 递归的反转当前结点curr的下一个结点，返回值就是链表反转后，当前结点的上一个结点
        Node pre = reverse(curr.next);
        // 让返回结点的下一个结点变味当前结点curr
        pre.next = curr;
        // 把当前结点的下一个结点变为null
        curr.next = null;
        return curr;
    }

遍历整个链表

public class LinkList<T> implements ListMethods<T>, Iterable<T> {
    .....
    @Override
    public Iterator<T> iterator() {
        return new LIterator();
    }

    private class LIterator implements Iterator {
        private Node n;

        public LIterator() {
            this.n = head;
        }

        @Override
        public boolean hasNext() {
            return n.next != null;
        }

        @Override
        public Object next() {
            n = n.next;
            return n.item;
        }
    }
}

完整代码

package DataStrues.ListTable;

import java.util.Iterator;

public class LinkList<T> implements ListMethods<T>, Iterable<T> {
    private Node head;
    private int N;

    private class Node {
        T item;
        Node next;

        public Node(T item, Node next) {
            this.item = item;
            this.next = next;
        }
    }

    public LinkList() {
        this.head = new Node(null, null);
        this.N = 0;
    }

    @Override
    public void clear() {
        head.next = null;
        this.N = 0;
    }

    @Override
    public boolean isEmpty() {
        return N == 0;
    }

    @Override
    public int length() {
        return N;
    }

    @Override
    public T get(int i) {
        if(head.next == null) {
            return null;
        }
        Node n = head.next;
        for (int index = 0; index < i; index++) {
            n = n.next;
        }
        return n.item;
    }

    @Override
    public void insert(T t) {
        Node n = head;  // 把头节点复制给一个新元素
        while (n.next != null) {
            n = n.next;
        }
        n.next = new Node(t, null);
        N++;
    }

    @Override
    public void insert(int i, T t) {
        Node n = head;
        for (int index = 0; index < i; index++) {
            n = n.next;
        }
        n.next = new Node(t, n.next);
        N++;
    }

    @Override
    public T remove(int i) {
        Node n = head;
        for (int index = 0; index < i; index++) {
            n = n.next;
        }
        Node name = n.next;
        n.next = name.next;
        N--;
        return name.item;
    }

    @Override
    public int indexOf(T t) {
        Node n = head;
        for (int i = 0; n.next != null; i++) {
            n = n.next;
            if (n.item.equals(t)) {
                return i;
            }
        }
        return -1;
    }

    /**
     * 用来反转整个链表
     */
    public void reverse() {
        // 判断当前链表是否为空链表
        if (isEmpty()) {
            return;
        }
        reverse(head.next);
    }

    /**
     * 反转指定的结点curr， 并把反转后的结点返回
     *
     * @param curr
     * @return
     */
    public Node reverse(Node curr) {
        if (curr.next == null) {
            head.next = curr;
            return curr;
        }
        // 递归的反转当前结点curr的下一个结点，返回值就是链表反转后，当前结点的上一个结点
        Node pre = reverse(curr.next);
        // 让返回结点的下一个结点变味当前结点curr
        pre.next = curr;
        // 把当前结点的下一个结点变为null
        curr.next = null;
        return curr;
    }

    @Override
    public Iterator<T> iterator() {
        return new LIterator();
    }

    private class LIterator implements Iterator {
        private Node n;

        public LIterator() {
            this.n = head;
        }

        @Override
        public boolean hasNext() {
            return n.next != null;
        }

        @Override
        public Object next() {
            n = n.next;
            return n.item;
        }
    }
}