Java基础——链表

• 链表是一系列的存储数据元素的单元通过指针串接起来形成的，因此每个单元至少有两个域，一个域用于数据元素的存储，另一个或两个域是指向其他单元的指针。这里具有一个数据域和多个指针域的存储单元通常称为节点（node）。
• 链表的第一个节点和最后一个节点，分别称为链表的头节点和尾节点。尾节点的特征是其 next 引用为空（null）。链表中每个节点的 next 引用都相当于一个指针，指向另一个节点，借助这些 next 引用，我们可以从链表的头节点移动到尾节点。
• 链表数据结构中主要包含单向链表、双向链表及循环链表。

单向链表

　　单向链表只有一个指针域，在整个节点中数据域用来存储数据元素，指针域用于指向下一个具有相同结构的节点。

 单向链表中，每个节点的数据域都是通过一个 Object 类的对象引用来指向数据元素的，与数组类似，单向链表中的节点也具有一个线性次序，即如果节点 a1 的 next 引用指向节点 a2，则 a1 就是 a2 的直接前驱，a2 是 a1 的直接后续。只能通过前驱节点找到后续节点，而无法从后续节点找到前驱节点。
特点：
　　数据元素的存储对应的是不连续的存储空间，每个存储结点对应一个需要存储的数据元素。每个结点是由数据域和指针域组成。 元素之间的逻辑关系通过存储节点之间的链接关系反映出来。
　　逻辑上相邻的节点物理上不必相邻。
缺点：
1、比顺序存储结构的存储密度小 (每个节点都由数据域和指针域组成，所以相同空间内假设全存满的话顺序比链式存储更多)。
2、查找结点时链式存储要比顺序存储慢（每个节点地址不连续、无规律，导致按照索引查询效率低下）。
优点：
1、插入、删除灵活 (不必移动节点，只要改变节点中的指针，但是需要先定位到元素上)。
2、有元素才会分配结点空间，不会有闲置的结点。

单链表完整代码

package day14.linkedlist_;



public class MyLink {
    /**
     * 创建节点
     */

     class Node{
        /**
         * 真正的数据
         */
        private Object data;
        /**
         * 下一个节点
         */
        private Node next;
        //构造器
        public Node(){
            this.data = 0;
            this.next = null;
        }
        public Node(Object data){
            this.data = data;
            this.next = null;
        }
        //为了显示方法，我们重新创建toString
        @Override
        public String toString() {
            return "Node{ data=" + data+" }";
        }
    }



    /**
     * 头结点
     */
    private Node head;
    /**
     * 链表中节点的个数
     */
    private int size;

    /**
     * 获取链表中元素的个数
     * @return
     */
    public int getSize() {
        return size;
    }

    public void setSize(int size) {
        this.size = size;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        Node curNode = head;
        while(curNode != null){
            sb.append(curNode + "-->");
            curNode = curNode.next;
        }
        return sb.toString();
    }

    public MyLink(){
        this.head = null;
        this.size = 0;
    }

    /**
     * 判断链表是否为空
     * @return
     */
    public boolean isEmpty(){
        return head.next == null;
    }

    /**
     * 无虚拟头结点
     * index下标上增加元素
     * @param o
     * @param index
     */

    /*
    public void add(Object o,int index){
        if(index < 0 || index > this.size){
            throw new ArrayIndexOutOfBoundsException("index 下标越界");
        }

        Node node = new Node(o);
        //链表里没有值
        if(head == null){
            head = node;
        }

        //index == 0，从头结点前插入
        if(index == 0){
             node.next = head;
             head = node;
             this.size++;
             return;
        }
        Node prev = head;
        for(int i = 0;i < index - 1;i++){
            prev = prev.next;
        }
        node.next = prev.next;
        prev.next = node;

        this.size++;
    }
     */

    /**
     * 从头部增加元素
     * @param o
     */

    /*
    public void addFirst(Object o){
        add(o,0);
    }
     */

    /**
     * 从尾部增加元素
     * @param o
     */
    /*
    public void addLast(Object o){
        add(o,size);
    }

    public Object get(int index){
        return get(index);
    }
     */

    /**
     * 使用虚拟头结点
     * @param o
     * @param index
     */
    public void add(Object o,int index){
        if(index < 0 || index > this.size){
            throw new ArrayIndexOutOfBoundsException("index超出范围");
        }

        Node dummyHead = new Node(null);

        Node node = new Node(o);

        dummyHead.next = head;
        Node prev = dummyHead;
        for(int i = 0;i < index;i++){
            prev = prev.next;
        }
        node.next = prev.next;
        prev.next = node;

        this.size++;
        head = dummyHead.next;
    }

    /**
     * 返回index处的内容
     * @param index
     * @return
     */
    public Node get(int index){
        if(index < 0 || index > this.size){
            throw new ArrayIndexOutOfBoundsException("index 超出范围");
        }
        Node curNode = head;
        for(int i = 0;i < index;i++){
            curNode = curNode.next;
        }
        return curNode;
    }

    /**
     * 获得头节点
     */
    public void getFirst(){
        get(0);
    }

    /**
     * 获得尾结点
     */
    public void getLast(){
        get(size - 1);
    }

    /**
     * 链表中是否存在o
     * @param o
     * @return
     */
    public boolean isContains(Object o){
        Node node = head;
        for(int i = 0;i < size;i++){
            if(this.get(i).data.equals(o)){
                return true;
            }
        }
        return false;
    }

    /**
     * 移除头节点
     */
    public void removeFirst(){
        remove(0);
    }

    /**
     * 移除尾节点
     */
    public void removeLast(){
        remove(size-1);
    }
    public void remove(int index) {
        if(index < 0 || index > this.size){
            throw new IllegalArgumentException("参数index不合法");
        }
        Node dummyNode = new Node(null);
        dummyNode.next = head;
        Node prev = dummyNode;

        for(int i = 0;i < index;i++){
            prev = prev.next;
        }

        /* 要删除的节点 */
        Node delNode = prev.next;

        /* 删除操作 */
        prev.next = delNode.next;
        delNode.next = null;

        /* 更新size */
        this.size--;

        /* 更新head */
        dummyNode.next = head;
    }

}

双向链表

　　要在单向链表中找到某个节点的前驱节点，必须从链表的头节点出发依次向后寻找，但是需要Ο(n)时间。为此我们可以扩展单向链表的节点结构，使得通过一个节点的引用，不但能够访问其后续节点，也可以方便的访问其前驱节点。扩展单向链表节点结构的方法是，在单链表节点结构中新增加一个域，该域用于指向节点的直接前驱节点。该链表称为双向链表。单向链表只能从一个方向遍历，双向链表可以从两个方向遍历。

　　在使用双向链表实现链接表时，为使编程更加简洁，我们使用带两个哑元节点的双向链表来实现链接表。其中一个是头节点，另一个是尾节点，它们都不存放数据元素，头节点的pre 为空，而尾节点的 Next 为空。

　　在具有头尾节点的双向链表中插入和删除节点，无论插入和删除的节点位置在何处，因为首尾节点的存在，插入、删除操作都可以被归结为某个中间节点的插入和删除；并且因为首尾节点的存在，整个链表永远不会为空，因此在插入和删除节点之后，也不用考虑链表由空变为非空或由非空变为空的情况下 head 和 tail 的指向问题；从而简化了程序。

在使用双向链表实现链接表时，为使编程更加简洁，我们使用带两个哑元节点的双向链表来实现链接表。其中一个是头节点，另一个是尾节点，它们都不存放数据元素，头节点的pre 为空，而尾节点的 Next 为空。

在具有头尾节点的双向链表中插入和删除节点，无论插入和删除的节点位置在何处，因为首尾节点的存在，插入、删除操作都可以被归结为某个中间节点的插入和删除；并且因为首尾节点的存在，整个链表永远不会为空，因此在插入和删除节点之后，也不用考虑链表由空变为非空或由非空变为空的情况下 head 和 tail 的指向问题；从而简化了程序。
 

双链表完整代码

 

package day16.doublelinkedlist;

public class DoubleLinkedList {
    /*组装节点的数据结构*/
    class Node{
        /*真正的数据*/
        Object data;
        /*前驱结点*/
        Node prev;
        /*后继结点*/
        Node next;

        public Node(Object data){
            this.data = data;
            this.prev = null;
            this.next = null;
        }

        @Override
        public String toString() {
            StringBuilder stringBuilder = new StringBuilder();
            stringBuilder.append("Node : { data = " + data);
            if(prev != null){
                stringBuilder.append(" , prev = " + prev.data);
            }
            if(next != null){
                stringBuilder.append(" , prev = " + next.data);
            }
            stringBuilder.append(" }");
            return stringBuilder.toString();
        }
    }

    /**
     * 头结点
     */
    private Node first;
    /**
     * 尾结点
     */
    private Node last;
    /**
     * 链表中结点的个数
     */
    private int size;

    /**
     * 头结点
     * @return
     */
    public Node getFirst() {
        if(isEmpty()){
            return null;
        }
        return first;
    }

    public void setFirst(Node first) {
        this.first = first;
    }

    /**
     * 尾结点
     * @return
     */
    public Node getLast() {
        if(isEmpty()){
            return null;
        }
        return last;
    }

    public void setLast(Node last) {
        this.last = last;
    }

    public int getSize() {
        return size;
    }

    public void setSize(int size) {
        this.size = size;
    }

    /**
     * 无参构造
     */
    public DoubleLinkedList(){
        this.size = 0;
        this.first = this.last = null;
    }

    public boolean isEmpty(){
        return this.size == 0;
        //return this.first = null;
    }
    /**
     * 头部添加
     * @param val
     */
    public void addFirst(int val){
        Node node = new Node(val);
        if(isEmpty()){
            last = node;
        }else{
            node.next = first;
            first.prev = node;
        }
        first = node;
        this.size++;
    }

    /**
     * 尾部添加
     * @param val
     */
    public void addLast(int val){
        Node node = new Node(val);
        if(isEmpty()){
            first = node;
        }else{
            node.prev = last;
            last.next = node;
        }
        last = node;
        this.size++;
    }

    /**
     * 将val插入到内容为key的结点之后
     * @param key
     * @param val
     */
    public void add(int key,int val){
        /* 1.找到内容为key的结点 */
        Node node = find(key);
        Node newLink = new Node(val);
        /* 2.跟后继结点的连接 */
        if(node == last){
            newLink.next = null;
            last = newLink;
        }else{
            newLink.next = node.next;
            node.next.prev = newLink;
        }
        node.next = newLink;
        newLink.prev = node;

        this.size++;
    }

    /**
     * 返回val的索引
     * @param val
     * @return
     */
    public int indexOf(int val){
        int index = 0;
        for(Node node = first;node != null;node = node.next){
            if(node.data.equals(val)){
                return index;
            }
            index++;
        }
        return -1;
    }

    /**
     * 判断某一个内容是否存在
     * @param val
     * @return
     */
    public boolean isContains(int val){
        return indexOf(val) != -1;
    }

    /**
     * 找到内容为val的结点
     * @param val
     * @return
     */
    public Node find(Object val){
        for(Node node = first; node != null;node = node.next){
            if(node.data.equals(val)){
                return node;
            }
        }
        return null;
    }

    /**
     * 从前往后输出
     * @return
     */
    public String stringForward(){
        StringBuilder sb = new StringBuilder();
        for(Node node = first;node != null;node = node.next){
            sb.append(node);
        }
        return sb.toString();
    }

    public Node removeFirst(){
        Node temp = first;
        if(isEmpty()){
            return null;
        }
        if(first.next == null){
            last = null;
        }else {
            first.next.prev = null;
        }
        first = first.next;
        this.size--;
        return temp;
    }

    public Node removeLast(){
        Node temp = last;
        if(isEmpty()){
            return null;
        }
        if(last.prev == null){
            first = null;
        }else{
            last.prev.next = null;
        }
        last = last.prev;
        this.size--;
        return temp;
    }
    public Node remove(Object val){
        //1.找到要删除的结点
        Node node = find(val);
        //2.如果这个节点是first
        if(node == first){
            first = first.next;
       }else{
            //2.1 否则 node的前一个的next指向 node的下一个结点
            node.prev.next = node.next;
        }
        //3.如果这个节点是last
        if(node == last){
            last = last.prev;
        }else{
            //3.1 否则 node的下一个的prev指向 node的上一个结点
            node.next.prev = node.prev;
        }
        return node;
    }

    /**
     * 根据索引查找结点
     * @param index
     * @return
     */
    public Node getByIndex(int index){
        /* 二分查找 */
        Node node = null;
        if(index < size >> 1){
            node = first;
            for(int i = 0;i < index;i++){
                node = node.next;
            }
        }else{
            node = last;
            for(int i = size - 1;i > index;i --){
                node = node.prev;
            }
        }
        return node;
    }


    /**
     * 从后往前输出
     * @return
     */
    public String stringBack(){
        StringBuilder sb = new StringBuilder();
        for(Node node = last;node != null;node = node.prev){
            sb.append(node);
        }
        return sb.toString();
    }
}