线性表的Java实现--链式存储（双向链表）

有了单向链表的基础，双向链表的实现就容易多了。

双向链表的一般情况：

 增加节点：

 

删除节点：

 

双向链表的Java实现：

package com.liuhao.algorithm;  
  
public class DuLinkList<T> {  
  
    /** 
     * 内部类：链表中的一个节点 
     *  
     * @author liuhao data 节点中的数据 prev 指向前一个节点的引用 next 指向下一个节点的引用 
     */  
    private class Node {  
  
        private T data;// 保存的数据元素  
        private Node prev;// 指向上一个节点  
        private Node next;// 指向下一个节点  
  
        public Node() {  
        }  
  
        public Node(T data, Node prev, Node next) {  
            super();  
            this.data = data;  
            this.prev = prev;  
            this.next = next;  
        }  
    }  
  
    private Node header;// 头结点  
    private Node tail;// 尾节点  
    private int size;// 链表中元素个数  
  
    // 创建空链表  
    public DuLinkList() {  
        header = null;  
        tail = null;  
    }  
  
    // 已指定数据元素创建链表，只有一个元素  
    public DuLinkList(T element) {  
  
        header = new Node(element, null, null);  
        // 只有一个节点，header,tail都指向该节点  
        tail = header;  
        size++;  
    }  
  
    // 返回链表长度  
    public int length() {  
        return size;  
    }  
  
    // 获取指定位置的数据元素  
    public T get(int index) {  
        return this.getNodeByIndex(index).data;  
    }  
  
    // 获取指定位置的节点  
    private Node getNodeByIndex(int index) {  
  
        if (index < 0 || index > size - 1) {  
            throw new IndexOutOfBoundsException("索引超出线性表范围");  
        }  
  
        if (index < size / 2) {  
            Node current = header;  
            for (int i = 0; i < size / 2 && current != null; i++, current = current.next) {  
                if (i == index) {  
                    return current;  
                }  
            }  
        } else {  
            Node current = tail;  
            for (int i = size - 1; i >= size / 2 && current != null; i--, current = current.prev) {  
                if (i == index) {  
                    return current;  
                }  
            }  
        }  
        return null;  
    }  
  
    // 按值查询所在的位置  
    public int locate(T element) {  
        Node current = header;  
  
        for (int i = 0; i < size - 1 && current != null; i++, current = current.next) {  
            if (element.equals(current.data)) {  
                return i;  
            }  
        }  
  
        return -1;  
    }  
  
    // 向指定位置插入元素  
    public void insert(T element, int index) {  
        if (index < 0 || index > size) {  
            throw new IndexOutOfBoundsException("索引超出线性表范围");  
        }  
  
        if (header == null) {  
            this.add(element);  
        } else {  
            if (0 == index) {  
                this.addAtHead(element);  
            } else {  
                Node prev = this.getNodeByIndex(index - 1);// 获取插入节点的前一个节点  
                Node next = prev.next;// 待插索引处的节点  
                Node newNode = new Node(element, prev, next);// 新增节点，让它的prev指向之前的节点。next指向之后的节点  
  
                prev.next = newNode;// 之前的节点的next指向当前节点  
                next.prev = newNode;// 之后节点的prev指向当前节点  
  
                size++;  
            }  
        }  
    }  
  
    // 采用尾插法添加新节点  
    public void add(T element) {  
  
        // 若还是空表，则将header和tail都指向该元素即可  
        if (header == null) {  
            header = new Node(element, null, null);  
            tail = header;  
        } else {  
            // 创建信节点，prev指向tail  
            Node newNode = new Node(element, tail, null);  
            // 令tail的next指向新节点  
            tail.next = newNode;  
            tail = newNode;// 把新节点设为尾节点  
        }  
  
        size++;  
    }  
  
    // 采用头插发添加新节点  
    public void addAtHead(T element) {  
        Node newNode = new Node(element, null, header);  
        header.prev = newNode;  
        header = newNode;  
  
        // 如果插入之前是空表  
        if (tail == null) {  
            tail = header;  
        }  
  
        size++;  
    }  
  
    // 删除指定索引处的元素  
    public T delete(int index) {  
  
        if (index < 0 || index > size - 1) {  
            throw new IndexOutOfBoundsException("索引超出线性表范围");  
        }  
  
        Node del = null;  
  
        if (index == 0) {  
            del = header;  
            header = header.next;  
            header.prev = null;  
        } else {  
            Node prev = this.getNodeByIndex(index - 1);// 获取索引处之前的节点  
            del = prev.next;// 获取索引处的节点  
  
            // 让之前的节点的next指向下一个节点  
            prev.next = del.next;  
  
            // 有可能删除的是最后一个元素，若直接调用next.prev可能会出错  
            if (del.next != null) {  
                del.next.prev = prev;  
            }  
  
            //若删除的是最后一个元素，那么就要重置tail;  
            tail = prev;  
              
            del.prev = null;  
            del.next = null;  
  
        }  
        size--;  
        return del.data;  
    }  
  
    // 删除最后一个元素  
    public T remove() {  
        return this.delete(size - 1);  
    }  
  
    // 判断是否为空  
    public boolean isEmpty() {  
        return size == 0;  
    }  
  
    // 清空线性表  
    public void clear() {  
        header = null;  
        tail = null;  
        size = 0;  
    }  
  
    public String toString() {  
        if (size == 0) {  
            return "[]";  
        } else {  
            StringBuilder sb = new StringBuilder("[");  
            for (Node current = header; current != null; current = current.next) {  
                sb.append(current.data.toString() + ", ");  
            }  
            sb.append("]");  
  
            int len = sb.length();  
  
            // 删除多余的“,”和空格  
            return sb.delete(len - 3, len - 2).toString();  
        }  
    }  
}  

测试代码：

package com.liuhao.test;

import org.junit.Test;

import com.liuhao.algorithm.DuLinkList;

public class DuLinkListTest {

    @Test
    public void test() {
        
        //测试构造函数
        DuLinkList<String> duList = new DuLinkList("好");
        System.out.println(duList);
        
        //测试添加元素
        duList.add("ni");
        duList.add("没");
        System.out.println(duList);
        
        //在头部添加
        duList.addAtHead("五月");
        System.out.println(duList);
        
        //在指定位置添加
        duList.insert("摩卡", 2);
        System.out.println(duList);
        
        //获取指定位置处的元素
        System.out.println("第2个元素是（从0开始计数）：" + duList.get(2));
        
        //返回元素索引
        System.out.println("摩卡在的位置是：" + duList.locate("摩卡"));
        System.out.println("moka所在的位置：" + duList.locate("moka"));
        
        //获取长度
        System.out.println("当前线性表的长度：" + duList.length());
        
        //判断是否为空
        System.out.println(duList.isEmpty());
        
        //删除最后一个元素
        duList.remove();
        System.out.println("调用remove()后：" + duList);
        
        //获取长度
        System.out.println("当前线性表的长度：" + duList.length());
        
        //删除指定位置处元素
        duList.delete(3);
        System.out.println("删除第4个元素后：" + duList);
        
        //获取长度
        System.out.println("当前线性表的长度：" + duList.length());
        
        //清空
        duList.clear();
        System.out.println(duList);
        
        //判断是否为空
        System.out.println(duList.isEmpty());
    }

}