双向循环链表构建[Java]

双向循环链表：每个结点都有两个指针域，一个指向前一个结点，一个指向后一个结点，且头节点的前一个指向尾结点，尾结点下一个指向头节点，形成循环。

构建一个双向循环链表同时实现表，栈，循环队列的功能

接口定义

创建接口，继承Iterable，E表示类型选择泛型，定义接口中的方法。

顺序表接口：

package p1.接口;

import java.util.Comparator;

public interface List<E> extends Iterable<E> {
    public void add(E element);//在表尾添加
    public void add(int index, E element);//指定位置添加
    public void remove(E element);
    public E remove(int index);//删除指定角标元素
    public E get(int index);
    public E set(int index, E element);//修改
    public int size();//返回元素总个数
    public int indexOF(E element);//元素查角标
    public boolean contains(E element);//是否包含
    public boolean isEmpty(); //判断表是否为空
    public void clear(); //清空
    public void sort(Comparator<E> c); //排序
    public List<E> subList(int formIndex, int toIndex); //截取表中一段元素
}

栈接口：

package p1.接口;

public interface Stack<E> extends Iterable<E> {
    public int size(); //查看元素个数
    public boolean isEmpty(); //判断栈是否为空
    public void push(E element); //入栈
    public E pop();  //出栈
    public E peek(); //查看栈顶元素
    public void clear(); //清空
}

循环队列接口： 继承自队列接口

package p1.接口;
public interface Deque<E> extends Queue<E> {
    public void addFirst(E element); //从头部添加
    public void addLast(E element); //从队尾添加
    public E removeFirst(); //移除队首元素
    public E removeLast(); //移除队尾元素
    public E getFirst(); //获取队首元素
    public E getLast(); //获取队尾元素
}

队列接口：

package p1.接口;

public interface Queue<E> extends Iterable<E> {
    public void offer(E element); //入队
    public E poll(); //出队
    public E top(); //查看队头元素
    public boolean isEmpty(); //判断队列是否为空
    public void clear(); //清空
    public int size(); //查看队列长度
}

双向循环链表构建

package p3.链式结构;

import com.sun.javafx.scene.NodeHelper;
import p1.接口.Deque;
import p1.接口.List;
import p1.接口.Stack;

import java.util.Comparator;
import java.util.Iterator;

//双向循环链表（可同时实现表，栈，循环队列的功能）
public class LinkedList<E> implements List<E>, Deque<E>, Stack<E> {

//内部类定义结点
    private class Node{
        E data;
        Node pre;
        Node next;
        public Node(){
            this(null, null, null);
        }
        public Node(E data){
            this(data, null, null);
        }
        public Node(E data, Node pre, Node next){
            this.data = data;
            this.pre = pre;
            this.next = next;
        }
        @Override
        public String toString() { //重写输出形式，只输出结点的data
            return data.toString();
        }
    }
    //定义链表类中的变量
    private Node head;
    private Node tail;
    private int size;
    //构造函数
    public LinkedList() {
        head = null;
        tail = null;
        size = 0;
    }
    public LinkedList(E[] arr) {
        if (arr == null) {
            throw new IllegalArgumentException("arr can not be null");
        }
        for (E e : arr) {
            add(e);
        }
    }
    //以下是线性表的方法
    //在末尾添加元素
    @Override
    public void add(E element) {
        add(size, element);
    }
    //在指定下标出添加元素
    @Override
    public void add(int index, E element) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("add index out of range");
        }
        Node n = new Node(element);
        if (size == 0) {
            head = n;
            tail = n;
            tail.next = head;
            head.pre = tail;
        } else if (index == 0) {
            n.pre = head.pre;
            n.next = head;
            head.pre = n;
            head = n;
            tail.next = head;
        } else if (index == size) {
            n.next = tail.next;
            tail.next = n;
            n.pre = tail;
            tail = n;
            head.pre = tail;
        } else {
            Node p,q;
            if (index <= size / 2) {
                p = head;
                for (int i = 0; i < index - 1; i++) {
                    p = p.next;
                }
                q = p.next;
                p.next = n;
                n.pre = p;
                q.pre = n;
                n.next = q;
            } else {
                p = tail;
                for (int i = size - 1; i > index; i--) {
                    p = p.pre;
                }
                q = p.pre;
                q.next = n;
                n.pre = q;
                n.next = p;
                p.pre = n;
            }
        }
        size++;
    }
    //根据元素值移除元素
    @Override
    public void remove(E element) {
        int index = indexOF(element); //查找元素下标
        if (index != -1) {
            remove(index);
        }
    }
    //移除指定下标的元素
    @Override
    public E remove(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("remove index out of range");
        }
        E ret = null;
        Node node;
        if (size == 1) {
            ret = head.data;
            head = null;
            tail = null;
        } else if (index == 0) {
            ret = head.data;
            node = head.next;
            head.next = null;
            node.pre = head.pre;
            head.pre = null;
            head = node;
            tail.next = head;
        } else if (index == size - 1) {
            ret = tail.data;
            node = tail.pre;
            tail.pre = null;
            node.next = tail.next;
            tail.next = null;
            tail = node;
            head.pre = tail;
        } else { //在中间删除
            Node p,q,r;
            if (index <= size / 2) { //如果删除的下标偏左
                p = head;
                for (int i = 0; i < index - 1; i++) {
                    p = p.next;
                }
                q = p.next;
                r = q.next;
                ret = q.data;
                p.next = r;
                r.pre = p;
                q.next = null;
                q.pre = null;
            } else { //删除下标偏右
                p = tail;
                //p要从尾移动到删除下标的next
                for (int i = size - 1; i > index + 1; i--) {
                    p = p.pre;
                }
                q = p.pre;
                r = q.pre;
                ret = q.data;
                r.next = p;
                p.pre = r;
                q.next = null;
                q.pre = null;
            }
        }
        size--;
        return ret;
    }
    //获取指定下标的元素
    @Override
    public E get(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("get index out of range");
        }
        if (index == 0) {
            return head.data;
        } else if (index == size - 1) {
            return tail.data;
        } else {
            Node p = head;
            for (int i = 0; i < index; i++) {
                p = p.next;
            }
            return p.data;
        }
    }
    //改变指定下标的元素值
    @Override
    public E set(int index, E element) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("set index out of range");
        }
        E ret = null;
        if (index == 0) {
            ret = head.data;
            head.data = element;
        } else if (index == size - 1) {
            ret = tail.data;
            tail.data = element;
        } else {
            Node p = head;
            for (int i = 0; i < index; i++) {
                p = p.next;
            }
            ret = p.data;
            p.data = element;
        }
        return ret;
    }
    //求元素个数
    @Override
    public int size() {
        return size;
    }
    //查找元素位置
    @Override
    public int indexOF(E element) {
        Node p = head;
        int index = 0;
        while (!p.data.equals(element)) {
            p = p.next;
            index++;
            if (p == head) {
                return -1;
            }
        }
        return index;
    }
    //判断元素是否在表中
    @Override
    public boolean contains(E element) {
        return indexOF(element) != -1;
    }
    //判断表是否为空
    @Override
    public boolean isEmpty() {
        return size == 0 && head == null && tail == null;
    }
    //清空
    @Override
    public void clear() {
        head = null;
        tail = null;
        size = 0;
    }
    //排序
    @Override
    public void sort(Comparator<E> c) {
        if (c == null) {
            throw new IllegalArgumentException("comparator can not be null");
        }
        //插入排序来做
        if (size == 0 || size == 1) {
            return;
        }
        for (Node nodeA = head.next; nodeA != head; nodeA = nodeA.next) {
            E e = nodeA.data;
            Node nodeB;
            Node nodeC;
            for (nodeB = nodeA, nodeC = nodeB.pre; nodeC != tail && c.compare(nodeC.data, e) > 0; nodeB = nodeB.pre, nodeC = nodeC.pre) {
                nodeB.data = nodeC.data;
            }
            nodeB.data = e;
        }
    }
    //截取表中一段元素
    @Override
    public List<E> subList(int formIndex, int toIndex) {
        if (formIndex < 0 || toIndex >= size || formIndex > toIndex) {
            throw new IllegalArgumentException("0 <= fromIndex <= toIndex < size");
        }
        Node nodeA = head;
        for (int i = 0; i < formIndex; i++) {
            nodeA = nodeA.next;
        }
        Node nodeB = head;
        for (int i = 0; i < toIndex; i++) {
            nodeB = nodeB.next;
        }
        Node p = nodeA;
        LinkedList<E> list = new LinkedList<>();
        while (true) {
            list.add(p.data);
            if (p == nodeB) {
                break;
            }
            p = p.next;
        }
        return list;
    }
    //重写输出形式
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append('[');
        if (isEmpty()) {
            sb.append(']');
        } else {
            Node p = head;
            while (true) {
                sb.append(p.data);
                if (p == tail) {
                    sb.append(']');
                    break;
                }
                sb.append(',');
                sb.append(' ');
                p = p.next;
            }
        }
        return sb.toString();
    }
    //迭代器
    @Override
    public Iterator<E> iterator() {
        return new LinkedListIterator();
    }

    class LinkedListIterator implements Iterator<E> {
        private Node cur = head;
        private boolean flag = true; //是否在第一圈

        @Override
        public boolean hasNext() {
            if (isEmpty()) {
                return false;
            }
            return flag;
        }

        @Override
        public E next() {
            E ret = cur.data;
            cur = cur.next;
            if (cur == head) {
                flag = false;
            }
            return ret;
        }
    }

    //双端队列方法
    @Override
    public void addFirst(E element) {
        add(0, element);
    }

    @Override
    public void addLast(E element) {
        add(size, element);
    }

    @Override
    public E removeFirst() {
        return remove(0);
    }

    @Override
    public E removeLast() {
        return remove(size);
    }

    @Override
    public E getFirst() {
        return get(0);
    }

    @Override
    public E getLast() {
        return get(size-1);
    }

    //队列方法
    @Override
    public void offer(E element) {
        addFirst(element);
    }

    @Override
    public E poll() {
        return removeFirst();
    }

    @Override
    public E top() {
        return getFirst();
    }
    //栈的方法
    @Override
    public void push(E element) {
        addLast(element);
    }

    @Override
    public E pop() {
        return removeLast();
    }

    @Override
    public E peek() {
        return getLast();
    }
}

测试链表功能是否实现

可以定义双向循环链表类对象测试各个方法。
以下通过遍历文件夹问题线性队列遍历文件夹，将队列类对象改成双向循环链表类进行测试。

package p2.线性结构;

import p3.链式结构.LinkedList;

import java.io.File;

public class DirectoryTraversal {
    public static void main(String[] args) {
        File dir = new File("C:\\Users\\86138\\Desktop\\DS");
        LinkedList<File> queue = new LinkedList<>();
        queue.offer(dir);
        while (!queue.isEmpty()){
            File file = queue.poll();
            System.out.println("【" + file.getName() + "】");
            File[] files = file.listFiles(); //将出队的目录展开
            for (File f:files){
                if (f.isFile()){
                    System.out.println(f.getName());
                }else {
                    queue.offer(f);
                }
            }
        }
    }
}