JAVA双向队列实现（链表）

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/u011350550/article/details/83210817

队列是很常见的一种数据存储结构，今天，介绍下如何用链表实现双向队列。

首先定义节点接口如下：

public interface Node<E> {
    //设置数据元素
    public void setData(E o);
    //获取节点元素
    public E getData();
}

根据需求不同，实现该接口，双向链表节点的实现如下：

public class DLNode<E> implements Node<E> {

    private E element;

    private DLNode<E> pre;

    //下一个节点
    private DLNode<E> next;

    //比较策略对象，用于比较两个对象是否相等，在查找，插值等情况下使用
    private Strategy strategy;

    //无参构造函数
    public DLNode() {
        this(new DefaultStrategy());
    }

    //有参构造函数
    public DLNode(Strategy strategy) {
        this.strategy = strategy;
        this.pre = null;
        this.next = null;
    }

    //赋值
    @Override
    public void setData(E o) {
        this.element = o;
    }

    //获取值
    @Override
    public E getData() {
        return this.element;
    }

    //比较元素是否相等
    public boolean equal(E o) {
        if (this.strategy.equals(o, this.element)) {
            return true;
        } else {
            return false;
        }
    }

    //设置节点前置节点
    public void setPre(DLNode<E> pre) {
        this.pre = pre;
    }

    //设置后续节点
    public void setNext(DLNode<E> next) {
        this.next = next;
    }

    //获取前置节点
    public DLNode<E> getPre() {
        return this.pre;
    }

    //获取后续节点
    public DLNode<E> getNext() {
        return this.next;
    }
}

代码应该没有比较难理解的地方，简单说明一下：双向链表节点DLNode几个属性含义分别为element是数据元素（存储节点数据），pre是前一个节点的引用，next是下一个节点的引用，Strategy是比较策略接口，用来比较两个数据元素是否相等，在后面的例子中会有使用，Strategy和DefaultStrategy代码。

//Strategy接口
public interface Strategy {
    //比较两个元素是否相等
    public boolean equals(Object obj1, Object obj2);
}

//DefaultStrategy实现类
public class DefaultStrategy implements Strategy {
    @Override
    public boolean equals(Object obj1, Object obj2) {
        if (null != obj1 && null != obj2) {
            return obj1.equals(obj2);
        }
        return false;
    }
}

接下来就是双向链表的实现了，链表的应该有一下几个功能，查询，删除，插入等等，代码如下：

public class DoubleLinkedList<E> {

    //双向链表头结点
    private DLNode<E> header;

    //双向链表尾节点
    private DLNode<E> tail;

    //比较策略对象，用于比较两个对象是否相等，在查找，插值等情况下使用
    private Strategy strategy;

    //链表大小
    private int size;

    public DoubleLinkedList() {
        this.size = 0;
        this.header = null;
        this.tail = null;
        this.strategy = null;
    }

    public DoubleLinkedList(Strategy strategy) {
        this.size = 0;
        this.header = null;
        this.tail = null;
        this.strategy = strategy;
    }

    //是否是空链表
    public boolean isEmpty() {
        return this.size == 0;
    }

    //获取链表大小
    public int getSize() {
        return this.size;
    }

    //链表尾加入链表
    public void push(E o) {
        DLNode<E> node = this.strategy != null ? new DLNode(this.strategy) : new DLNode();
        node.setData(o);
        if (this.size == 0) {
            this.header = node;
            this.tail = node;
            node.setPre(null);
        } else {
            node.setPre(this.tail);
            this.tail.setNext(node);
            this.tail = node;
        }
        node.setNext(null);
        this.size++;
    }

    //链表尾加入链表
    public void unshift(E o) {
        DLNode<E> node = this.strategy != null ? new DLNode( this.strategy) : new DLNode();
        node.setData(o);
        if (this.size == 0) {
            this.header = node;
            this.tail = node;
            node.setNext(null);
        } else {
            node.setNext(this.header);
            this.header.setPre(node);
            this.header = node;
        }
        node.setPre(null);
        this.size++;
    }

    //在特定值之前插入值
    public boolean insertBefore(E target, E src) {
        if (this.size == 0) {
            return false;
        } else {
            DLNode<E> headerP = this.header;
            while (headerP != null) {
                if (headerP.equal(target)) {
                    DLNode<E> node = this.strategy != null ? new DLNode( this.strategy) : new DLNode();
                    node.setData(src);
                    DLNode<E> preNode = headerP.getPre();
                    headerP.setPre(node);
                    node.setPre(preNode);
                    node.setNext(headerP);
                    this.size++;
                    return true;
                }
                headerP = headerP.getNext();
            }
            return false;
        }
    }

    //在特定值之前插入值
    public boolean insertAfter(E target, E src) {
        if (this.size == 0) {
            return false;
        } else {
            DLNode<E> headerP = this.header;
            while (headerP != null) {
                if (headerP.equal(target)) {
                    DLNode<E> node = this.strategy != null ? new DLNode(this.strategy) : new DLNode();
                    node.setData(src);
                    DLNode<E> nextNode = headerP.getNext();
                    headerP.setNext(node);
                    node.setPre(headerP);
                    node.setNext(nextNode);
                    this.size++;
                    return true;
                }
                headerP = headerP.getNext();
            }
            return false;
        }
    }

    //判断是否存在某个元素
    public boolean isExist(E o) {
        if (this.size == 0) {
            return false;
        } else {
            DLNode<E> headerP = this.header;
            while (headerP != null) {
                if (headerP.equal(o)) {
                    return true;
                }
                headerP = headerP.getNext();
            }
            return false;
        }
    }

    //判断元素在链表中的位置
    public int indexOf(E o) {
        if (this.size == 0) {
            return -1;
        } else {
            DLNode<E> headerP = this.header;
            int index = 0;
            while (headerP != null) {
                if (headerP.equal(o)) {
                    return index;
                }
                headerP = headerP.getNext();
                index++;
            }
            return -1;
        }
    }

    public boolean remove(E o) {
        if (this.size == 0) {
            return false;
        } else {
            DLNode<E> headerP = this.header;
            while (headerP != null) {
                if (headerP.equal(o)) {
                    DLNode<E> pre = headerP.getPre();
                    DLNode<E> next = headerP.getNext();
                    if (pre == null) {
                        this.header = next;
                    } else {
                        pre.setNext(next);
                    }
                    if (next == null) {
                        this.tail = pre;
                    } else {
                        next.setPre(pre);
                    }
                    this.size--;
                    return true;
                }
                headerP = headerP.getNext();
            }
            return false;
        }
    }

    //获取头节点
    public DLNode<E> getHeader() {
        return this.header;
    }

    //获取尾节点
    public DLNode<E> getTail() {
        return this.tail;
    }

    //返回队列尾节点，并将尾节点从链表中删除
    public E pop() {
        if (this.size == 0) {
            return null;
        } else {
            E result = this.tail.getData();
            if (this.tail.getPre() != null) {
                this.tail.getPre().setNext(null);
                this.tail = this.tail.getPre();
            } else {
                this.tail = null;
                this.header = null;
            }
            this.size--;
            return result;
        }
    }

    //返回队链表首节点数据，并将首节点从链表中删除
    public E shift() {
        if (this.size == 0) {
            return null;
        } else {
            E result = this.header.getData();
            if (this.header.getNext() != null) {
                this.header.getNext().setPre(null);
                this.header = this.header.getNext();
            } else {
                this.tail = null;
                this.header = null;
            }
            this.size--;
            return result;
        }
    }
}

每个方法属性的含义在代码中已经注释，没有特别需要讲解的地方，如有疑问，请给我留言。

下面测试一下链表功能：
有学生类（Student）如下：

package LinkedNode;

public class Student {

    private String name;

    private int age;

    private String stuId;

    public Student(String name, int age, String id) {
        this.name = name;
        this.age = age;
        this.stuId = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getStuId() {
        return stuId;
    }

    public void setStuId(String stuId) {
        this.stuId = stuId;
    }

    public String toString() {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("姓名：");
        stringBuilder.append(this.name);
        stringBuilder.append(",年龄：");
        stringBuilder.append(this.age);
        stringBuilder.append(",学号：");
        stringBuilder.append(this.stuId);
        return stringBuilder.toString();
    }
}

学生类之间的比较策略实现如下：

public class StudentStrategy implements Strategy {

    @Override
    public boolean equals(Object obj1, Object obj2) {
        if (obj1 instanceof Student && obj2 instanceof Student) {
            Student student1 = (Student)obj1;
            Student student2 = (Student)obj2;
            return student1.getStuId().equals(student2.getStuId());
        } else {
            return false;
        }
    }

}

只要两个类的stuId是相等的，就认为类是相等的，可以理解为，每个学生都有一个学号，学号一致，则认为就是同一个人。
测试代码如下,输出在代码下面：

public class TestDLNode {
    public static void main(String [] args) {
        DoubleLinkedList<Student> doubleLinkedList = new DoubleLinkedList<>(new StudentStrategy());
        for (int i = 0; i < 5; i++){
            Student student = new Student("sutdenet" + i, 20, String.valueOf(i));
            doubleLinkedList.push(student);
        }
        DLNode<Student> header = doubleLinkedList.getHeader();
        Student student1 = new Student("", 0, "3");
        Student student2 = new Student("this is insert", 10, "10");
        doubleLinkedList.insertAfter(student1, student2);
        System.out.println(doubleLinkedList.getSize());
        while (header != null) {
            System.out.println(header.getData());
            header = header.getNext();
        }
        System.out.println(doubleLinkedList.indexOf(student1));
        System.out.println(doubleLinkedList.pop());
        System.out.println(doubleLinkedList.getSize());
    }
}
/*
输出如下：
6
姓名：sutdenet0,年龄：20,学号：0
姓名：sutdenet1,年龄：20,学号：1
姓名：sutdenet2,年龄：20,学号：2
姓名：sutdenet3,年龄：20,学号：3
姓名：this is insert,年龄：10,学号：10
姓名：sutdenet4,年龄：20,学号：4
3
姓名：sutdenet4,年龄：20,学号：4
5
*/

对比代码和输出，可看到双向队列的基本功能都已经实现。