数据结构学习----线性表的链式表示之循环单链表(Java实现)

线性表接口LList：

package com.clarck.datastructure.linked;

/**
 * 线性表接口LList，描述线性表抽象数据类型，泛型参数T表示数据元素的数据类型
 * 
 * @author clarck
 *
 */
public interface LList<T> {
    /**
     * 判断线性表是否空
     * @return
     */
    boolean isEmpty();
    
    /**
     * 返回线性表长度
     * @return
     */
    int length();
    
    /**
     * 返回第i（i≥0）个元素
     * @param i
     * @return
     */
    T get(int i);
    
    /**
     * 设置第i个元素值为x
     * @param i
     * @param x
     */
    void set(int i, T x);
    
    /**
     * 插入x作为第i个元素
     * @param i
     * @param x
     */
    void insert(int i, T x);
    
    /**
     * 在线性表最后插入x元素
     * @param x
     */
    void append(T x);
    
    /**
     * 删除第i个元素并返回被删除对象
     * @param i
     * @return
     */
    T remove(int i);
    
    /**
     * 删除线性表所有元素
     */
    void removeAll();
    
    /**
     * 查找，返回首次出现的关键字为key元素
     * @param key
     * @return
     */
    T search(T key);
}

单链表结点类：

package com.clarck.datastructure.linked;

/**
 * 单链表结点类，T指定结点的元素类型
 * 
 * @author clarck
 *
 * @param <T>
 */
public class Node<T> {
    /**
     * 数据域，保存数据元素
     */
    public T data;
    
    /**
     * 地址域，引用后继结点
     */
    public Node<T> next;

    /**
     * 构造结点，data指定数据元素，next指定后继结点
     * 
     * @param data
     * @param next
     */
    public Node(T data, Node<T> next) {
        this.data = data;
        this.next = next;
    }

    /**
     * 构造节点
     */
    public Node() {
        this(null, null);
    }

    /**
     * 返回结点元素值对应的字符串
     */
    @Override
    public String toString() {
        return this.data.toString();
    }

    /**
     * 比较两个结点值是否相等，覆盖Object类的equals(obj)方法
     */
    @SuppressWarnings("unchecked")
    @Override
    public boolean equals(Object obj) {
        return obj == this || obj instanceof Node && this.data.equals(((Node<T>)obj).data);
    }
    
}

线性表的链式表示之循环单链表：

package com.clarck.datastructure.linked;

/**
 * 循环单链表类，实现线性表接口
 * 
 * @author clarck
 * 
 * @param <T>
 */
public class CirSinglyLinkedList<T> implements LList<T> {
    /**
     * 头指针，指向循环单链表的头结点
     */
    public Node<T> head;

    /**
     * 默认构造方法，构造空循环单链表
     */
    public CirSinglyLinkedList() {
        this.head = new Node<T>();
        this.head.next = this.head;
    }

    /**
     * 判断循环单链表是否空
     */
    @Override
    public boolean isEmpty() {
        return this.head.next == this.head;
    }

    /**
     * 返回循环单链表长度，单链表遍历算法，O(n)
     */
    @Override
    public int length() {
        int i = 0;
        for (Node<T> p = this.head.next; p != this.head; p = p.next) {
            i++;
        }
        return i;
    }

    /**
     * 返回第i（≥0）个元素，若i<0或大于表长则返回null，O(n)
     */
    @Override
    public T get(int i) {
        if (i >= 0) {
            Node<T> p = this.head.next;
            for (int j = 0; p != this.head && j < i; j++)
                p = p.next;
            if (p != this.head)
                return p.data; // p指向第i个结点
        }
        return null;
    }

    /**
     * 设置第i（≥0）个元素值为x。若i<0或大于表长则抛出序号越界异常；若x==null，不操作。O(n)
     */
    @Override
    public void set(int i, T x) {
        // 不能设置空对象
        if (x == null)
            return;
        Node<T> p = this.head.next;
        for (int j = 0; p != this.head && j < i; j++)
            p = p.next;
        // p指向第i个结点
        if (i >= 0 && p != this.head)
            p.data = x;
        else
            throw new IndexOutOfBoundsException(i + ""); // 抛出序号越界异常
    }

    @Override
    public void insert(int i, T x) {
        // 不能插入空对象
        if (x == null) 
            return;

        // p指向头结点
        Node<T> p = this.head;
        // 寻找插入位置
        for (int j = 0; p.next != this.head && j < i; j++) {
            // 循环停止时，p指向第i-1结点或最后一个结点
            p = p.next;
        }
        // 插入x作为p结点的后继结点，包括头插入（i<=0）、中间/尾插入（i>0）
        p.next = new Node<T>(x, p.next);
    }

    @Override
    public void append(T x) {
        insert(Integer.MAX_VALUE, x);
    }

    /**
     * 删除第i（≥0）个元素，返回被删除对象。若i<0或i大于表长，不删除，返回null。O(n)
     */
    @Override
    public T remove(int i) {
        if (i >= 0) {
            Node<T> p = this.head;
            for (int j = 0; p.next != this.head && j < i; j++) {
                p = p.next;
            }

            if (p != null) {
                // 获得原对象
                T old = p.next.data;
                // 删除p的后继结点
                p.next = p.next.next;
                return old;
            }
        }
        return null;
    }

    /**
     * 删除单链表所有元素 Java将自动收回各结点所占用的内存空间
     */
    @Override
    public void removeAll() {
        this.head.next = this.head;
    }

    /**
     * 顺序查找关键字为key元素，返回首次出现的元素，若查找不成功返回null
     * key可以只包含关键字数据项，由T类的equals()方法提供比较对象相等的依据
     */
    @Override
    public T search(T key) {
        if (key == null)
            return null;
        for (Node<T> p = this.head.next; p != this.head; p = p.next)
            if (p.data.equals(key))
                return p.data;
        return null;
    }

    /**
     * 返回循环单链表所有元素的描述字符串
     */
    @Override
    public String toString() {
        String str = "(";
        Node<T> p = this.head.next;
        // 遍历单链表的循环条件改变了
        while (p != this.head) {
            str += p.data.toString();
            if (p != this.head)
                str += ", "; // 不是最后一个结点时后加分隔符
            p = p.next;
        }
        return str + ")";
    }
    
    /**
     * 比较两条单链表是否相等
     */
    @SuppressWarnings("unchecked")
    @Override
    public boolean equals(Object obj) {
        if (obj == this)
            return true;

        if (obj instanceof SinglyLinkedList) {
            CirSinglyLinkedList<T> list = (CirSinglyLinkedList<T>) obj;
            return equals(this.head.next, list.head.next);
        }
        return false;
    }
    
    /**
     * 比较两条单链表是否相等，递归方法
     * 
     * @param p
     * @param q
     * @return
     */
    private boolean equals(Node<T> p, Node<T> q) {
        return p == null && q == null || p != null && q != null
                && p.data.equals(q.data) && equals(p.next, q.next);
    }
}

源码：https://github.com/clarck/DataStructure/tree/master/LinkedList/src/com/clarck/datastructure/linked