数据结构之双链表

注：本文内容总结自《数据结构》
（1）双链表特点：
a.双链表也是线性表的一种。单链表有两个存储单元：一个数据元素，一个后继结点。单链表有一个弊端，就是要查找某个节点的先驱节点需要从头结点开始遍历，时间复杂度是O(n)。双链表在单链表的基础上，增加了一个指向前驱节点的指针。
b.单链表如果想要在指定节点之前插入元素，需要从头遍历找到指定节点的前驱节点，然后将这个前驱节点的next指针指向添加的节点，将这个新添加的节点的next指针指向指定节点，时间复杂度是O（n）。而双链表则不需要再遍历查找前驱节点，它有一个指向前驱节点的指针。
c.循环双链表：头结点的前驱指针指向最后一个节点，最后一个节点的后继指针指向头结点。
d.排序循环双链表:排序循环双链表 = 排序双链表 + 循环双链表 排序双链表的原理和排序单链表是一致的。都是将插入节点的数据元素与已排序的链表中的节点比较，将新元素放在第一个比它大的元素前面，修改前后节点指针的指向。
(2)代码实现:
a.双链表结点

/**
 * @date 2017-06-07
 * @author liufeifei
 * @description 双链表
 */
public class DLinkNode<T> {
    public T data;//数据元素
    public DLinkNode<T> prev,next;//前驱节点，后继节点

    public DLinkNode(T data,DLinkNode<T> prev,DLinkNode<T> next){
        this.data = data;
        this.prev =prev;
        this.next = next;
    }

    public DLinkNode(){
        this(null,null,null);
    }
}

b.双链表

/**
 * @date 2017-06-07
 * @author liufeifei
 * @description 实现双链表
 */
public class DoublyLinkedList<T> implements LList<T>{

    private DLinkNode<T> head;//头结点

    public DoublyLinkedList(){
        head = new DLinkNode<T>();
    }

    @Override
    public boolean isEmpty() {
        //循环双链表是双链表的特殊情况
        return head.next == null && head.prev == null;
    }

    @Override
    public void insert(int i, T t) {
        DLinkNode<T> p = this.head.next;
        for(int j = 0;j < i && p != null;j++){
            p = p.next;
        }
        if(p != null){
            //建立数据元素为t,p.prec为前驱节点，p为后继节点的新元素
            DLinkNode<T> q= new DLinkNode<T>(t,p.prev,p);
            p.prev.next = q;
            p.prev = q;

        }
    }

    @Override
    public void set(int i, T t) {
        DLinkNode<T> p = this.head.next;
        for(int j = 0;j < i && p != null ; j++ ){
            p = p.next;
        }
        if(p != null){
            p.data = t;
        }
    }

    @Override
    public T get(int i) {
        DLinkNode<T> p = this.head.next;
        for(int j = 0;j < i && p != null;j++){
            p = p.next;
        }
        if(p != null){
            return p.data;
        }
        return null;
    }

    @Override
    public int length() {
        int len = 0;
        DLinkNode<T> p = this.head.next;
        while(p != null){
            len++;
            p = p.next;
        }
        return len;
    }

    @Override
    public T remove(int i) {
        DLinkNode<T> p = this.head.next;
        for(int j = 0;j < i && p != null;j++){
            p = p.next;
        }
        if(p != null){
            T old = p.data;
            p.prev.next = p.next;
            if(p.next != null){
                p.next.prev = p.prev;
            }
            return old;
        }
        return null;
    }

    @Override
    public void removeAll() {
        this.head.next =null;
    }

    @Override
    public T search(T key) {
        return null;
    }

    @Override
    public void append(T t) {
        DLinkNode<T> p = this.head.next;
        DLinkNode<T> rear = this.head;//记录前驱节点

        while(p != null){
            rear = rear.next;
            p = p.next;
        }
        DLinkNode<T> q = new DLinkNode<T>(t,rear,null);
        rear.next = q;      
    }
}

c.循环双链表

/**
 * @date 2017-06-07
 * @author liufeifei
 * @description 循环双链表
 *
 * @param <T>
 */
public class CirDoublyLinkedList<T> implements LList<T> {

    public DLinkNode<T> head;

    public CirDoublyLinkedList(){
        this.head = new DLinkNode<T>();
        this.head.prev = this.head;
        this.head.next = this.head;
    }

    public CirDoublyLinkedList(CirDoublyLinkedList<T> list){
        if(list == null){
            return;
        }
        DLinkNode<T> p = list.head.next;
        DLinkNode<T> q = this.head;
        q = list.head;
        while(p != null){
            q.next = p;
            p = p.next;
            q = q.next;
        }
    }

    @Override
    public boolean isEmpty() {
        return this.head.next == this.head && this.head.prev == this.head;
    }

    @Override
    public void insert(int i, T t) {
        if(t == null){
            return;
        }
        DLinkNode<T> p = this.head.next;
        for(int j = 0;j < i && p != this.head;j++){
            p = p.next;
        }
        DLinkNode<T> q = new DLinkNode<T>(t,p.prev ,p);
        p.prev.next = q;
        p.prev = q;
    }

    @Override
    public void set(int i, T t) {
        if(t == null){
            return;
        }
        DLinkNode<T> p = this.head.next;
        for(int j = 0;j < i && p != this.head;j++){
            p = p.next;
        }
        p.data = t;
    }

    @Override
    public T get(int i) {
        DLinkNode<T> p = this.head.next;
        for(int j = 0;j < i && p != this.head;j++){
            p = p.next;
        }
        if(p != this.head){
            return p.data;
        }
        return null;
    }

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

    @Override
    public T remove(int i) {
        if(i > 0){
            DLinkNode<T> p = this.head.next;
            for(int j = 0;j < i && p != this.head;j++){
                p = p.next;
            }
            if(p != this.head){
                T old =p.data;
                p.prev.next = p.next;
                p.next.prev = p.prev;
                return old;
            }
        }
        return null;
    }

    @Override
    public void removeAll() {
        this.head.prev = this.head;
        this.head.next = this.head;
    }

    @Override
    public T search(T key) {
        return null;
    }

    @Override
    public void append(T t) {
        if(t == null){
            return;
        }
        DLinkNode<T> p = new DLinkNode<T>(t,this.head.next,this.head);
        this.head.prev.next = p;
        this.head.prev = p;
    }

    //输出双链表，从后向前沿着前驱域，
    public String printPrevious(){
        DLinkNode<T> p = this.head.prev;
        StringBuffer sb = new StringBuffer("(");
        while(p != null){
            sb.append(p.data);
            sb.append(",");
            p = p.prev;
        }
        sb.deleteCharAt(sb.length()-1);
        return sb.toString();
    }
}

d.排序双链表

/**
 * @date 2017-06-09
 * @author liufeifei
 * @description 排序双链表
 * @param <T>
 */
public class SortedDoublyLinkedList<T extends Comparable<T>> extends CirDoublyLinkedList<T> {

    public SortedDoublyLinkedList(){
        super();
    }

    public SortedDoublyLinkedList(T[] element){
        super();
        for(int i = 0;i < element.length;i++){
            this.insert(i, element[i]);
        }
    }

    public SortedDoublyLinkedList(SortedDoublyLinkedList list){
        super(list);
    }

    //向链表里面插入元素
    public void insert(T x){
        if(x == null){
            return;
        }
        if(this.head.prev != this.head && this.head.prev.data.compareTo(x)< 0){
            DLinkNode<T> p = new DLinkNode<T>(x,this.head.prev,this.head);
            this.head.prev.next = p;
            this.head.prev = p;
        }
        DLinkNode<T> p = this.head.next;
        while(p != null && p.data.compareTo(x) < 0){
            p = p.next;
        }
        DLinkNode<T> q = new DLinkNode<T>(x,p.prev,p);
        p.prev.next = q;
        p.next.prev = q;
    }

    //删除首次出现的结点，若未找到则不删除
    public void remove(T x){
        if(x == null){
            return;
        }
        DLinkNode<T> p = this.head.next;
        while(p != null && p.data.compareTo(x) < 0){//将p定位到待删除的元素
            p = p.next;
        }
        if(p!= this.head && p.data.compareTo(x) == 0){//删除p结点自己
            p.prev.next = p.next;
            p.next.prev = p.prev;
        }
    }
}