算法基础篇 — 单向链表、双向链表

单向链表

什么是单向链表？

如上图，每一个节点单向存储并引用下一个节点，每个节点存放你的对象或者数值，通过头节点就能得到一个链表这就是单向链表的特征。

数据结构的实现

@Data
@AllArgsConstructor
public static class Node<T> {
    // 节点数据
    T data;
    // 下一个节点
    Node<T> next;
}

这里举个例子：

public static void main(String[] args) {
	Node<Integer> tail = new Node<>(3, null);
	Node<Integer> pre = new Node<>(2, tail);
	Node<Integer> head = new Node<>(1, pre);
	System.out.println(head);
}

打印结果如下：

Test.Node(data=1, next=Test.Node(data=2, next=Test.Node(data=3, next=null)))

结构相当的清晰明了，我就不过多的解释了。

链表反转

实现思路

很简单，就是把原来的引用反过来就好了，因为尾部节点始终下一个节点指向null。使用一个循环，每次把头部节点的下一个节点作为新头部节点保留，然后把节点的引用反向指向上一个节点，直至新头部节点等于原来尾部节点的null，那么循环停止。

code

	/**
     * 反转单链表
     * @param head 单链表的头节点
     * @return 新的头节点
     */
    public static Node reverseNode(Node head) {
        // 临时存储上一个节点
        Node prev = null;
        // 临时存储下一个节点
        Node next = null;
        // 当头部节点跳转到尾部节点null时，即反转完成
        while (head != null) {
            // 记录头节点的下一个节点
            next = head.next;
            // 新头节点指向上一个节点
            head.next = prev;
            // 临时存储上一个节点信息（如果是尾部节点，那么就是新头部节点）
            prev = head;
            // 新头部为当前节点的下一个节点
            head = next;
        }
        return prev;
    }

跑一个案例：

	public static void main(String[] args) {
        Node<Integer> tail = new Node<>(3, null);
        Node<Integer> pre = new Node<>(2, tail);
        Node<Integer> head = new Node<>(1, pre);

        System.out.println(head);
        System.out.println("-----------------");
        System.out.println(reverseNode(head));
    }

输出结果：

Test.Node(data=1, next=Test.Node(data=2, next=Test.Node(data=3, next=null)))
-----------------
Test.Node(data=3, next=Test.Node(data=2, next=Test.Node(data=1, next=null)))

双链表

什么是双向链表？

如上图，每个节点都会存储上一个节点，下一个节点的引用节点。每个节点存放你的对象或者数值，通过头节点就能得到一个链表这就是双向链表的特征。

数据结构的实现

	@AllArgsConstructor
    public static class DoubleNode<T> {
        // 节点数据
        T data;
        // 上一个节点
        DoubleNode<T> prev;
        // 下一个节点
        DoubleNode<T> next;

        public T getData() {
            return data;
        }

        public void setData(T data) {
            this.data = data;
        }

        public DoubleNode<T> getPrev() {
            return prev;
        }

        public void setPrev(DoubleNode<T> prev) {
            this.prev = prev;
        }

        public DoubleNode<T> getNext() {
            return next;
        }

        public void setNext(DoubleNode<T> next) {
            this.next = next;
        }

        @Override
        public String toString() {
            return "DoubleNode{" +
                    "data=" + data +
                    ", prev=" + prev +
//                    ", next=" + next +
                    '}';
        }
    }

链表反转

实现思路

很简单，就是把原来的引用反过来就好了，因为尾部节点始终下一个节点指向null。使用一个循环，每次把头部节点的下一个节点作为新头部节点保留，然后把节点的引用反向指向上一个节点和下一个节点，直至新头部节点等于原来尾部节点的null，那么循环停止。

code

	/**
     * 反转双链表
     * @param head 双链表的头节点
     * @return 新的头节点
     */
    public static DoubleNode reverseDoubleNode(DoubleNode head) {
        // 临时存储上一个节点
        DoubleNode nowPrev = null;
        // 临时存储下一个节点
        DoubleNode next = null;
        // 当头部节点跳转到尾部节点null时，即反转完成
        while (head != null) {
            // 记录头节点的下一个节点
            next = head.next;
            // 新头节点指向上一个节点
            head.next = nowPrev;
            // 新头节点指向下一个节点
            head.prev = next;
            // 临时存储上一个节点信息（如果是尾部节点，那么就是新头部节点）
            nowPrev = head;
            // 新头部为当前节点的下一个节点
            head = next;
        }
        return nowPrev;
    }

应用场景

在Java中，LinkedList就是一个双向链表的集合。链表的优势在于定点删除／插入元素，因为链表影响的最多就是给定元素的左右的两个链。在数组中，是通过索引访问元素的。但是链表不能，只能通过链一个一个的找是线性的。