线性结构

概述

　　线性结构是包含n个相同类型元素的优先序列。在线性结构中，数据元素的前后关系是“一对一”的，即线性关系。

　　对于线性结构L=(a₁, a₂, ..., a_n)：

　　　　a.当1≤i<n且i<j≤n时，a_j是a_i的后继。a_i+1是a_i的直接后继。

　　　　b.当1<i≤n且1≤j<i时，a_j是a_i的前驱。a_i-1是a_i的直接前驱。

　　　　c.a₁是头元素。头元素没有前驱。

　　　　d.a_n是尾元素。尾元素没有后继。

　　线性结构的存储表示主要有两种：

　　　　顺序存储：借助数据元素在存储空间中的相对位置来表示元素之间的逻辑关系。采用顺序存储的线性结构通常使用数组来存储相同类型的元素。

　　　　链式存储：借助指示数据元素存储地址的指针来表示元素之间的逻辑关系。采用链式存储的线性结构通常使用结点来存储元素，该结点中使用指针变量指向其直接前驱或直接后继的结点。

　　典型的线性结构有栈、队列和线性表等。

栈

　　如果只允许在序列末端进行操作，这种线性结构称为栈。栈是一种后进先出的线性结构。

　　对于栈来说，尾元素所在端称为栈顶，头元素所在端称为栈底。不含任何元素的栈称为空栈。

　　栈的插入操作是将新元素压入栈顶，称为入栈；栈的删除操作是将栈顶元素删除，称为出栈。

　　可以将栈的操作定义成如下接口：

public interface Stack<E> {

    /**
     * 销毁栈
     */
    void destroyStack();

    /**
     * 判断栈是否为空
     * @return  若空则返回true，否则返回false
     */
    boolean stackEmpty();

    /**
     * 清空栈
     */
    void clearStack();

    /**
     * 元素压入栈
     * @param e
     */
    void push(E e);

    /**
     * 栈顶元素出栈
     * @return
     */
    E pop();

    /**
     * 取栈顶元素
     * @return
     */
    E getTop();

    /**
     * 栈内元素个数
     * @return
     */
    int stackLength();

}

　　按存储结构分类，栈可以分为顺序栈和链栈。

顺序栈

　　采用顺序存储的栈称为顺序栈。顺序栈的定义如下：

import java.util.Arrays;

public class SqStack<E> implements Stack<E> {

    /**
     * 存储空间
     */
    private Object[] elem = null;

    /**
     * 栈顶位标
     */
    private int top = -1;

    /**
     * 当前分配的存储容量
     */
    private int size = -1;

    /**
     * 初始存储容量
     */
    private int initialSize = -1;

    /**
     * 扩容时，增加的存储容量
     */
    private int increment;

    public SqStack(int size, int inc) {
        elem = new Object[size];
        top = 0;
        initialSize = size;
        this.size = size;
        increment = inc;
    }

    @Override
    public void destroyStack() {
        elem = null;
        top = initialSize = size = increment = -1;
    }

    @Override
    public boolean stackEmpty() {
        if (elem == null) {
            throw new StackException("请先初始化！");
        }
        return top == 0;
    }

    @Override
    public void clearStack() {
        if (elem == null) {
            throw new StackException("请先初始化！");
        }
        elem = new Object[initialSize];
        top = 0;
        size = initialSize;
    }

    @Override
    public void push(E e) {
        if (elem == null) {
            throw new StackException("请先初始化！");
        }
        if (top >= size) {
            Object[] elem = new Object[size + increment];
            System.arraycopy(this.elem, 0, elem, 0, top);
            this.elem = elem;
            size += increment;
        }
        elem[top++] = e;
    }

    @SuppressWarnings("unchecked")
    @Override
    public E pop() {
        if (stackEmpty()) {
            throw new StackException("栈内没有元素！");
        }
        E e = (E) elem[--top];
        elem[top] = null;
        return e;
    }

    @SuppressWarnings("unchecked")
    @Override
    public E getTop() {
        if (stackEmpty()) {
            throw new StackException("栈内没有元素！");
        }
        return (E) elem[top - 1];
    }

    @Override
    public int stackLength() {
        return top;
    }

    @Override
    public String toString() {
        if (stackEmpty()) {
            throw new StackException("栈内没有元素！");
        }
        Object[] elem = new Object[top];
        System.arraycopy(this.elem, 0, elem, 0, top);
        return "" + Arrays.asList(elem);
    }

}

　　a.使用泛型来控制入栈的元素类型，保证数组中的元素类型一致。

　　b.采用Object数组来存储元素。

　　c.top为栈顶位标，也可以表示栈中元素的个数。

　　d.size是栈当前的容量。当top == size，即栈中元素个数为栈当前容量时，表示栈已满。

　　e.increment是扩容的增量，元素入栈前判断栈是否已满，已满则扩容。

链栈

　　采用链式存储的栈称为链栈。链栈的定义如下：

import java.util.Arrays;

public class LStack<E> implements Stack<E> {

    private class LSNode {
        private E elem;
        private LSNode prior;

        private LSNode(E elem, LSNode prior) {
            this.elem = elem;
            this.prior = prior;
        }
    }

    /**
     * 栈顶元素
     */
    private LSNode top = null;

    /**
     * 栈内元素个数
     */
    private int length = -1;

    public LStack() {
        length = 0;
    }

    @Override
    public void destroyStack() {
        top = null;
        length = -1;
    }

    @Override
    public boolean stackEmpty() {
        if (length == -1) {
            throw new StackException("请先初始化！");
        }
        return length == 0;
    }

    @Override
    public void clearStack() {
        if (length == -1) {
            throw new StackException("请先初始化！");
        }
        top = null;
        length = 0;
    }

    @Override
    public void push(E e) {
        LSNode elem = new LSNode(e, top);
        top = elem;
        length++;
    }

    @Override
    public E pop() {
        if (stackEmpty()) {
            throw new StackException("栈内没有元素！");
        }
        E e = top.elem;
        top = top.prior;
        length--;
        return e;
    }

    @Override
    public E getTop() {
        if (stackEmpty()) {
            throw new StackException("栈内没有元素！");
        }
        return top.elem;
    }

    @Override
    public int stackLength() {
        if (length == -1) {
            throw new StackException("请先初始化！");
        }
        return length;
    }

    @SuppressWarnings("unchecked")
    @Override
    public String toString() {
        Object[] elems = new Object[length];
        elems[length - 1] = top;
        for (int i = length - 2; i >= 0; i--) {
            elems[i] = ((LSNode) elems[i + 1]).prior;
        }
        return "" + Arrays.asList(elems);
    }

}

　　a.使用泛型来控制入栈的元素类型，保证每一个结点的数据类型一致。

　　b.采用LSNode来表示结点，其中除了数据之外还有一个prior指针指向其直接前驱的结点。

　　c.top存储了栈顶结点。

　　d.length表示元素个数。

队列

　　如果只允许在序列两端进行操作，这种线性结构称为队列。队列是一种先进先出的线性结构。

　　对于队列来说，头元素所在端称为队头，尾元素所在端称为队尾。不含任何元素的队列称为空队列。

　　队列的插入操作是将新元素插入队尾，称为入队；队列的删除操作是将队头元素删除，称为出队。

　　可以将队列的操作定义成如下接口：

public interface Queue<E> {

    /**
     * 销毁队列
     */
    void destroyQueue();

    /**
     * 清空队列
     */
    void clearQueue();

    /**
     * 判断队列是否为空队列
     * @return  若队列为空队列则返回true，否则返回false
     */
    boolean queueEmpty();

    /**
     * 返回队列中元素个数，即队列的长度
     * @return
     */
    int queueLength();

    /**
     * 若队列不空，则返回队列的头元素
     * @return
     */
    E getHead();

    /**
     * 在当前队列的尾元素之后插入元素作为新的尾元素
     * @param e
     */
    void enQueue(E e);

    /**
     * 若队列不空则删除当前队列中的头元素并返回该元素
     * @return
     */
    E deQueue();

}

　　按存储结构分类，队列可以分为顺序队列和链队列。

顺序队列

　　采用顺序存储的队列称为顺序队列。顺序队列的定义如下：

import java.util.Arrays;

public class SqQueue<E> implements Queue<E> {

    /**
     * 存储空间
     */
    private Object[] elem = null;

    /**
     * 队头位标
     */
    private int front = -1;

    /**
     * 队尾位标，指示队尾元素的下一位置
     */
    private int rear = -1;

    /**
     * 存储容量
     */
    private int maxSize = -1;

    public SqQueue(int size) {
        elem = new Object[size];
        front = rear = 0;
        maxSize = size;
    }

    @Override
    public void destroyQueue() {
        elem = null;
        front = rear = maxSize = -1;
    }

    @Override
    public void clearQueue() {
        if (elem == null) {
            throw new QueueException("请先初始化！");
        }
        elem = new Object[maxSize];
        front = rear = 0;
    }

    @Override
    public boolean queueEmpty() {
        if (elem == null) {
            throw new QueueException("请先初始化！");
        }
        return elem[front] == null;
    }

    @Override
    public int queueLength() {
        if (elem == null) {
            throw new QueueException("请先初始化！");
        }
        if (front == rear) {
            if (elem[front] == null) {
                return 0;
            } else {
                return maxSize;
            }
        }
        return front > rear ? rear + maxSize - front : rear  - front;
    }

    @SuppressWarnings("unchecked")
    @Override
    public E getHead() {
        if (queueEmpty()) {
            throw new QueueException("队列中没有元素！");
        }
        return (E) elem[front];
    }

    @Override
    public void enQueue(E e) {
        if (elem == null) {
            throw new QueueException("请先初始化！");
        }
        if (elem[rear] != null) {
            throw new QueueException("队列已满！");
        }
        elem[rear] = e;
        rear = (rear + 1) % maxSize;
    }

    @SuppressWarnings("unchecked")
    @Override
    public E deQueue() {
        E e = (E) elem[front];
        elem[front] = null;
        front = (front + 1) % maxSize;
        return e;
    }

    @Override
    public String toString() {
        int len = queueLength();
        Object[] elem = new Object[len];
        for (int i = 0, j = front; i < len; i++, j = (j + 1) % maxSize) {
            elem[i] = this.elem[j];
        }
        return "" + Arrays.asList(elem);
    }

}

　　a.使用泛型来控制入队的元素类型，保证数组中的元素类型一致。

　　b.front和rear分别为队头和队尾位标。

　　c.maxSize为队列的容量。

　　d.新元素入队，rear循环加1；头元素出队，front循环加1。

　　e.front指向的位置没有元素，则队列为空；rear指向的位置有元素，则队列已满。

链队列

　　采用链式存储的队列称为链队列。链队列的定义如下：

import java.util.Arrays;

public class LQueue<E> implements Queue<E> {

    private class LQNode {
        private E elem;
        private LQNode next;

        private LQNode(E elem, LQNode next) {
            this.elem = elem;
            this.next = next;
        }
    }

    /**
     * 队头指针
     */
    private LQNode front = null;

    /**
     * 队尾指针
     */
    private LQNode rear = null;

    /**
     * 队列中元素个数
     */
    private int length = -1;

    /**
     * 类型
     * 带头结点（true）、不带头结点（false）
     */
    private boolean type;

    public LQueue(boolean type) {
        if (type) {
            front = rear = new LQNode(null, null);
        }
        length = 0;
        this.type = type;
    }

    @Override
    public void destroyQueue() {
        front = rear = null;
        length = -1;
    }

    @Override
    public void clearQueue() {
        if (length == -1) {
            throw new QueueException("请先初始化！");
        }
        if (type) {
            front = rear = new LQNode(null, null);
        } else {
            front = rear = null;
        }
        length = 0;
    }

    @Override
    public boolean queueEmpty() {
        if (length == -1) {
            throw new QueueException("请先初始化！");
        }
        return length == 0;
    }

    @Override
    public int queueLength() {
        if (length == -1) {
            throw new QueueException("请先初始化！");
        }
        return length;
    }

    @Override
    public E getHead() {
        if (queueEmpty()) {
            throw new QueueException("队列中没有元素！");
        }
        return type ? front.next.elem : front.elem;
    }

    @Override
    public void enQueue(E e) {
        if (length == -1) {
            throw new QueueException("请先初始化！");
        }
        if (length == 0 && ! type) {
            front = rear = new LQNode(e, null);
        } else {
            rear.next = new LQNode(e, null);
            rear = rear.next;
        }
        length++;
    }

    @Override
    public E deQueue() {
        if (queueEmpty()) {
            throw new QueueException("队列中没有元素！");
        }
        E e;
        if (type) {
            e = front.next.elem;
            front.next = front.next.next;
        } else {
            e = front.elem;
            front = front.next;
        }
        length--;
        return e;
    }

    @Override
    public String toString() {
        Object[] elem = new Object[length];
        LQNode node = type ? front.next : front;
        for (int i = 0; i < length; i++, node = node.next) {
            elem[i] = node.elem;
        }
        return "" + Arrays.asList(elem);
    }

}

　　a.使用泛型来控制入队的元素类型，保证每一个结点的数据类型一致。

　　b.采用LQNode来表示结点，其中除了数据之外还有一个next指针指向其直接后继的结点。

　　c.front和rear分别为队头和队尾结点。

　　d.length表示队中元素个数。

　　e.type区分该队列是否带头结点。链队列又分为带头结点和不带头结点两种。头结点是一个空结点，带头结点指front指向该头结点，其next指针指向队列头元素的结点；不带头结点指front指向队列头元素的结点。

线性表

　　如果允许在序列任意位置进行操作，这种线性结构称为线性表。

　　线性表中所含元素的个数称为线性表的长度，长度为0的线性表称为空表。

　　线性表允许在任意位置插入、删除，以及查询和修改任意位置的元素等。

　　可以将线性表的操作定义成如下接口：

public interface List<E> {

    /**
     * 销毁表
     */
    void destroyList();

    /**
     * 清空表
     */
    void clearList();

    /**
     * 判断表是否为空表
     * @return  表为空表则返回true，否则返回false
     */
    boolean listEmpty();

    /**
     * 返回表中元素个数
     * @return
     */
    int listLength();

    /**
     * 返回表中第i个元素
     * @param i
     * @return
     */
    E getElem(int i);

    /**
     * 在表中顺序查找元素
     * @param e
     * @return  成功时返回该元素在表中第一次出现的位置，否则返回-1
     */
    int search(E e);

    /**
     * 遍历表
     */
    void listTraverse();

    /**
     * 为表中第i个元素赋值
     * @param i
     * @param e
     */
    void putElem(int i, E e);

    /**
     * 在表中第i个位置插入元素
     * @param i
     * @param e
     */
    void appendElem(int i, E e);

    /**
     * 删除表中第i个元素
     * @param i
     */
    E deleteElem(int i);

}

　　按存储结构分类，线性表可分为顺序表和链表。

顺序表

　　采用顺序存储的线性表称为顺序表。顺序表的定义如下：

import java.util.Arrays;

public class SqList<E> implements List<E> {

    /**
     * 存储空间
     */
    private Object[] elem = null;

    /**
     * 当前长度
     */
    private int length = -1;

    /**
     * 初始存储容量
     */
    private int initialSize = -1;

    /**
     * 存储容量
     */
    private int size = -1;

    /**
     * 扩容的增量
     */
    private int increment = -1;

    public SqList(int size, int inc) {
        elem = new Object[size];
        length = 0;
        initialSize = size;
        this.size = size;
        increment = inc;
    }

    @Override
    public void destroyList() {
        elem = null;
        length = initialSize = size = increment = -1;
    }

    @Override
    public void clearList() {
        elem = new Object[initialSize];
        length = 0;
        size = initialSize;
    }

    @Override
    public boolean listEmpty() {
        if (elem == null) {
            throw new ListException("请先初始化！");
        }
        return length == 0;
    }

    @Override
    public int listLength() {
        if (elem == null) {
            throw new ListException("请先初始化！");
        }
        return length;
    }

    @SuppressWarnings("unchecked")
    @Override
    public E getElem(int i) {
        if (listEmpty()) {
            throw new ListException("表中没有元素！");
        }
        if (i < 0 || i >= length) {
            throw new ListException("位标不在范围内！");
        }
        return (E) elem[i];
    }

    @Override
    public int search(E e) {
        if (listEmpty()) {
            throw new ListException("表中没有元素！");
        }
        for (int i = 0; i < length; i++) {
            if (e.equals(elem[i])) {
                return i;
            }
        }
        return -1;
    }

    @Override
    public void listTraverse() {
        if (listEmpty()) {
            throw new ListException("表中没有元素！");
        }
        Object[] elem = new Object[length];
        System.arraycopy(this.elem, 0, elem, 0, length);
        System.out.println(Arrays.asList(elem));
    }

    @Override
    public void putElem(int i, E e) {
        if (listEmpty()) {
            throw new ListException("表中没有元素！");
        }
        if (i < 0 || i >= length) {
            throw new ListException("位标不在范围内！");
        }
        elem[i] = e;
    }

    @Override
    public void appendElem(int i, E e) {
        if (elem == null) {
            throw new ListException("请先初始化！");
        }
        if (i < 0) {
            throw new ListException("位标不能为负数！");
        }
        if (length >= size) {
            size += increment;
            Object[] elem = new Object[size];
            System.arraycopy(this.elem, 0, elem, 0, length);
            this.elem = elem;
        }
        if (i >= length) {
            i = length;
        } else {
            System.arraycopy(elem, i, elem, i + 1, length - i);
        }
        elem[i] = e;
        length++;
    }

    @SuppressWarnings("unchecked")
    @Override
    public E deleteElem(int i) {
        if (listEmpty()) {
            throw new ListException("表中没有元素！");
        }
        if (i < 0) {
            throw new ListException("位标不能为负数！");
        }
        if (i >= length - 1) {
            i = length - 1;
        }
        E e = (E) elem[i];
        if (i < length - 1) {
            System.arraycopy(elem, i + 1, elem, i, length - 1 - i);
        }
        elem[--length] = null;
        return e;
    }

}

　　a.使用泛型来控制插入的元素类型，保证数组中的元素类型一致。

　　b.采用Object数组来存储元素。

　　c.length表示栈中元素的个数。

　　d.size是栈当前的容量。当length == size，即栈中元素个数为栈当前容量时，表示栈已满。

　　e.increment是扩容的增量，元素入栈前判断栈是否已满，已满则扩容。

　　f.位标i必须是[0, length - 1)的范围内。

链表

　　采用链式存储的线性表称为链表。链表分为以下几类：

单链表

　　单链表是结点只有一个指向直接后继结点的指针的链表。单链表的定义为：

import java.util.Arrays;

public class LinkList<E> implements List<E> {

    private class LNode {
        E elem;
        LNode next;

        private LNode(E elem, LNode next) {
            this.elem = elem;
            this.next = next;
        }
    }

    /**
     * 头结点
     */
    private LNode head = null;

    /**
     * 当前长度
     */
    private int length = -1;

    public LinkList() {
        length = 0;
    }

    @Override
    public void destroyList() {
        head = null;
        length = -1;
    }

    @Override
    public void clearList() {
        if (length == -1) {
            throw new ListException("请先初始化！");
        }
        head = null;
        length = 0;
    }

    @Override
    public boolean listEmpty() {
        if (length == -1) {
            throw new ListException("请先初始化！");
        }
        return length == 0;
    }

    @Override
    public int listLength() {
        if (length == -1) {
            throw new ListException("请先初始化！");
        }
        return length;
    }

    @Override
    public E getElem(int i) {
        if (listEmpty()) {
            throw new ListException("表中没有元素！");
        }
        if (i < 0 || i >= length) {
            throw new ListException("位标不在范围内！");
        }
        LNode node = head;
        while (i > 0) {
            node = node.next;
            i--;
        }
        return node.elem;
    }

    @Override
    public int search(E e) {
        if (listEmpty()) {
            throw new ListException("表中没有元素！");
        }
        LNode node = head;
        for (int i = 0; i < length; i++, node = node.next) {
            if (e.equals(node.elem)) {
                return i;
            }
        }
        return -1;
    }

    @Override
    public void listTraverse() {
        if (listEmpty()) {
            throw new ListException("表中没有元素！");
        }
        Object[] elem = new Object[length];
        LNode node = head;
        for (int i = 0; i < length; i++, node = node.next) {
            elem[i] = node.elem;
        }
        System.out.println(Arrays.asList(elem));
    }

    @Override
    public void putElem(int i, E e) {
        if (listEmpty()) {
            throw new ListException("表中没有元素！");
        }
        if (i < 0 || i >= length) {
            throw new ListException("位标不在范围内！");
        }
        LNode node = head;
        while (i > 0) {
            node = node.next;
            i--;
        }
        node.elem = e;
    }

    @Override
    public void appendElem(int i, E e) {
        if (length == -1) {
            throw new ListException("请先初始化！");
        }
        if (i < 0) {
            throw new ListException("位标不能为负数！");
        }
        if (length == 0 || i == 0) {
            head = new LNode(e, head);
        } else {
            if (i > length) {
                i = length;
            }
            LNode node = head;
            while (i > 1) {
                node = node.next;
                i--;
            }
            node.next = new LNode(e, node.next);
        }
        length++;
    }

    @Override
    public E deleteElem(int i) {
        if (listEmpty()) {
            throw new ListException("表中没有元素！");
        }
        if (i < 0) {
            throw new ListException("位标不能为负数！");
        }
        E e;
        if (i == 0) {
            e = head.elem;
            head = head.next;
        } else {
            if (i >= length - 1) {
                i = length - 1;
            }
            LNode node = head;
            while (i > 1) {
                node = node.next;
                i--;
            }
            e = node.next.elem;
            node.next = node.next.next;
        }
        length--;
        return e;
    }

}

双向链表

　　双向链表是结点有两个指针，一个指向直接后继结点，一个指向直接前驱结点的链表。双向链表的定义为：

import java.util.Arrays;

public class DuLinkList<E> implements List<E> {

    private class DuLNode {
        E elem;
        DuLNode prior;
        DuLNode next;

        private DuLNode(E elem, DuLNode prior, DuLNode next) {
            this.elem = elem;
            this.prior = prior;
            this.next = next;
        }
    }

    /**
     * 头结点
     */
    private DuLNode head = null;

    /**
     * 当前长度
     */
    private int length = -1;

    public DuLinkList() {
        length = 0;
    }

    @Override
    public void destroyList() {
        head = null;
        length = -1;
    }

    @Override
    public void clearList() {
        if (length == -1) {
            throw new ListException("请先初始化！");
        }
        head = null;
        length = 0;
    }

    @Override
    public boolean listEmpty() {
        if (length == -1) {
            throw new ListException("请先初始化！");
        }
        return length == 0;
    }

    @Override
    public int listLength() {
        if (length == -1) {
            throw new ListException("请先初始化！");
        }
        return length;
    }

    @Override
    public E getElem(int i) {
        if (listEmpty()) {
            throw new ListException("表中没有元素！");
        }
        if (i < 0 || i >= length) {
            throw new ListException("位标不在范围内！");
        }
        return get(i).elem;
    }

    @Override
    public int search(E e) {
        if (listEmpty()) {
            throw new ListException("表中没有元素！");
        }
        DuLNode node = head;
        for (int i = 0; i < length; i++, node = node.next) {
            if (e.equals(node.elem)) {
                return i;
            }
        }
        return -1;
    }

    @Override
    public void listTraverse() {
        if (listEmpty()) {
            throw new ListException("表中没有元素！");
        }
        Object[] elem = new Object[length];
        DuLNode node = head;
        for (int i = 0; i < length; i++, node = node.next) {
            elem[i] = node.elem;
        }
        System.out.println(Arrays.asList(elem));
    }

    @Override
    public void putElem(int i, E e) {
        if (listEmpty()) {
            throw new ListException("表中没有元素！");
        }
        if (i < 0 || i >= length) {
            throw new ListException("位标不在范围内！");
        }
        get(i).elem = e;
    }

    @Override
    public void appendElem(int i, E e) {
        if (i < 0) {
            throw new ListException("位标不能为负数！");
        }
        if (listEmpty()) {
            head = new DuLNode(e, null, head);
        } else if (i == 0) {
            DuLNode node = new DuLNode(e, null, head);
            head.prior = node;
            head = node;
        } else if (i >= length) {
            DuLNode prior = get(length - 1);
            DuLNode node = new DuLNode(e, prior, null);
            prior.next = node;
        } else {
            DuLNode next = get(i);
            DuLNode prior = next.prior;
            DuLNode node = new DuLNode(e, prior, next);
            next.prior = node;
            prior.next = node;
        }
        length++;
    }

    @Override
    public E deleteElem(int i) {
        if (listEmpty()) {
            throw new ListException("表中没有元素！");
        }
        if (i < 0) {
            throw new ListException("位标不能为负数！");
        }
        DuLNode node;
        if (i == 0) {
            node = head;
            head = head.next;
            head.prior = null;
        } else if (i >= length - 1) {
            node = get(length - 1);
            node.prior.next = null;
        } else {
            node = get(i);
            node.prior.next = node.next;
            node.next.prior = node.prior;
        }
        length--;
        return node.elem;
    }

    private DuLNode get(int i) {
        DuLNode node = head;
        while (i > 0) {
            node = node.next;
            i--;
        }
        return node;
    }

}

单循环链表

　　单循环链表是尾元素的直接后继为头元素的单链表。

import java.util.Arrays;

public class CirLinkList<E> implements List<E> {

    private class LNode {
        E elem;
        LNode next;

        private LNode(E elem, LNode next) {
            this.elem = elem;
            this.next = next;
        }
    }

    /**
     * 头结点
     */
    private LNode head = null;

    /**
     * 尾结点
     */
    private LNode tail = null;

    /**
     * 当前长度
     */
    private int length = -1;

    public CirLinkList() {
        length = 0;
    }

    @Override
    public void destroyList() {
        head = null;
        tail = null;
        length = -1;
    }

    @Override
    public void clearList() {
        if (length == -1) {
            throw new ListException("请先初始化！");
        }
        head = null;
        tail = null;
        length = 0;
    }

    @Override
    public boolean listEmpty() {
        if (length == -1) {
            throw new ListException("请先初始化！");
        }
        return length == 0;
    }

    @Override
    public int listLength() {
        if (length == -1) {
            throw new ListException("请先初始化！");
        }
        return length;
    }

    @Override
    public E getElem(int i) {
        if (listEmpty()) {
            throw new ListException("表中没有元素！");
        }
        if (i < 0 || i >= length) {
            throw new ListException("位标不在范围内！");
        }
        LNode node = head;
        while (i > 0) {
            node = node.next;
            i--;
        }
        return node.elem;
    }

    @Override
    public int search(E e) {
        if (listEmpty()) {
            throw new ListException("表中没有元素！");
        }
        LNode node = head;
        for (int i = 0; i < length; i++, node = node.next) {
            if (e.equals(node.elem)) {
                return i;
            }
        }
        return -1;
    }

    @Override
    public void listTraverse() {
        if (listEmpty()) {
            throw new ListException("表中没有元素！");
        }
        Object[] elem = new Object[length];
        LNode node = head;
        for (int i = 0; i < length; i++, node = node.next) {
            elem[i] = node.elem;
        }
        System.out.println(Arrays.asList(elem));
    }

    @Override
    public void putElem(int i, E e) {
        if (listEmpty()) {
            throw new ListException("表中没有元素！");
        }
        if (i < 0 || i >= length) {
            throw new ListException("位标不在范围内！");
        }
        LNode node = head;
        while (i > 0) {
            node = node.next;
            i--;
        }
        node.elem = e;
    }

    @Override
    public void appendElem(int i, E e) {
        if (length == -1) {
            throw new ListException("请先初始化！");
        }
        if (i < 0) {
            throw new ListException("位标不能为负数！");
        }
        if (length == 0) {
            head = new LNode(e, null);
            head.next = head;
            tail = head;
        } else if (i == 0) {
            head = new LNode(e, head);
            tail.next = head;
        } else if (i >= length) {
            tail.next = new LNode(e, head);
            tail = tail.next;
        } else {
            LNode node = head;
            while (i > 1) {
                node = node.next;
                i--;
            }
            node.next = new LNode(e, node.next);
        }
        length++;
    }

    @Override
    public E deleteElem(int i) {
        if (listEmpty()) {
            throw new ListException("表中没有元素！");
        }
        if (i < 0) {
            throw new ListException("位标不能为负数！");
        }
        E e;
        if (i == 0) {
            e = head.elem;
            head = head.next;
            tail.next = head;
        } else if (i >= length - 1) {
            LNode node = head;
            while (i > 1) {
                node = node.next;
                i--;
            }
            e = node.next.elem;
            node.next = head;
            tail = node;
        } else {
            LNode node = head;
            while (i > 1) {
                node = node.next;
                i--;
            }
            e = node.next.elem;
            node.next = node.next.next;
        }
        length--;
        return e;
    }

}

双向循环链表

　　双向循环链表是尾元素的直接后继为头元素，头元素的直接前驱为尾元素的双向链表。

import java.util.Arrays;

public class DuCirLinkList<E> implements List<E> {

    private class DuLNode {
        E elem;
        DuLNode prior;
        DuLNode next;

        private DuLNode(E elem, DuLNode prior, DuLNode next) {
            this.elem = elem;
            this.prior = prior;
            this.next = next;
        }
    }

    /**
     * 头结点
     */
    private DuLNode head = null;

    /**
     * 尾结点
     */
    private DuLNode tail = null;

    /**
     * 当前长度
     */
    private int length = -1;

    public DuCirLinkList() {
        length = 0;
    }

    @Override
    public void destroyList() {
        head = null;
        tail = null;
        length = -1;
    }

    @Override
    public void clearList() {
        if (length == -1) {
            throw new ListException("请先初始化！");
        }
        head = null;
        tail = null;
        length = 0;
    }

    @Override
    public boolean listEmpty() {
        if (length == -1) {
            throw new ListException("请先初始化！");
        }
        return length == 0;
    }

    @Override
    public int listLength() {
        if (length == -1) {
            throw new ListException("请先初始化！");
        }
        return length;
    }

    @Override
    public E getElem(int i) {
        if (listEmpty()) {
            throw new ListException("表中没有元素！");
        }
        if (i < 0 || i >= length) {
            throw new ListException("位标不在范围内！");
        }
        return get(i).elem;
    }

    @Override
    public int search(E e) {
        if (listEmpty()) {
            throw new ListException("表中没有元素！");
        }
        DuLNode node = head;
        for (int i = 0; i < length; i++, node = node.next) {
            if (e.equals(node.elem)) {
                return i;
            }
        }
        return -1;
    }

    @Override
    public void listTraverse() {
        if (listEmpty()) {
            throw new ListException("表中没有元素！");
        }
        Object[] elem = new Object[length];
        DuLNode node = head;
        for (int i = 0; i < length; i++, node = node.next) {
            elem[i] = node.elem;
        }
        System.out.println(Arrays.asList(elem));
    }

    @Override
    public void putElem(int i, E e) {
        if (listEmpty()) {
            throw new ListException("表中没有元素！");
        }
        if (i < 0 || i >= length) {
            throw new ListException("位标不在范围内！");
        }
        get(i).elem = e;
    }

    @Override
    public void appendElem(int i, E e) {
        if (i < 0) {
            throw new ListException("位标不能为负数！");
        }
        if (listEmpty()) {
            head = new DuLNode(e, null, null);
            tail = head;
            head.prior = head;
            head.next = head;
        } else if (i == 0) {
            DuLNode node = new DuLNode(e, tail, head);
            head.prior = node;
            tail.next = node;
            head = node;
        } else if (i >= length) {
            DuLNode node = new DuLNode(e, tail, head);
            tail.next = node;
            head.prior = node;
            tail = node;
        } else {
            DuLNode next = get(i);
            DuLNode prior = next.prior;
            DuLNode node = new DuLNode(e, prior, next);
            next.prior = node;
            prior.next = node;
        }
        length++;
    }

    @Override
    public E deleteElem(int i) {
        if (listEmpty()) {
            throw new ListException("表中没有元素！");
        }
        if (i < 0) {
            throw new ListException("位标不能为负数！");
        }
        DuLNode node;
        if (i == 0) {
            node = head;
            head = head.next;
            head.prior = tail;
            tail.next = head;
        } else if (i >= length - 1) {
            node = tail;
            tail = tail.prior;
            tail.next = head;
            head.prior = tail;
        } else {
            node = get(i);
            node.prior.next = node.next;
            node.next.prior = node.prior;
        }
        length--;
        return node.elem;
    }

    private DuLNode get(int i) {
        DuLNode node = head;
        while (i > 0) {
            node = node.next;
            i--;
        }
        return node;
    }

}