Java单链表的逆序

首先需要一个node，来实现单链表。

package com.lxk.linkedList.oneWay;

/**
 * @author lxk on 2017/8/1
 */
public class Node<K, V> {
    private final K key;
    private V value;
    private Node<K, V> next;

    public Node(K key, V value, Node<K, V> next) {
        this.key = key;
        this.value = value;
        this.next = next;
    }

    public K getKey() {
        return key;
    }

    public V getValue() {
        return value;
    }

    public void setValue(V value) {
        this.value = value;
    }

    public Node<K, V> getNext() {
        return next;
    }

    public void setNext(Node<K, V> next) {
        this.next = next;
    }
}

然后，就是怎么实现逆序啦。

第一种实现，简单好理解。

    /**
     * 逆序单链表
     *
     * @param head 单链表
     */
    public static Node<Integer, Integer> reverse1(Node<Integer, Integer> head) {
        Node<Integer, Integer> reverse = null;
        Node<Integer, Integer> current = head;
        while (current != null) {
            Node<Integer, Integer> temp = current;
            current = current.getNext();
            temp.setNext(reverse);
            reverse = temp;
        }
        return reverse;
    }

第二种实现。递归，不好理解。

    /**
     * 逆序单链表（递归）
     *
     * @param head 单链表
     */
    public static Node<Integer, Integer> reverse2(Node<Integer, Integer> head) {
        //当为空或者本节点为末尾节点的时候
        if (head == null || head.getNext() == null) {
            return head;
        }
        Node<Integer, Integer> reversedHead = reverse2(head.getNext());
        //获取先前的下一个节点，让该节点指向自身
        head.getNext().setNext(head);
        //破坏以前自己指向下一个节点
        head.setNext(null);
        //层层传递给最上面的
        return reversedHead;
    }

这里再多放2个方法。

一个是初始化单链表。一个是输出单链表。

    /**
     * 获得单向链表（头插法生成的单向链表--后来的在链表头部）
     */
    public static Node<Integer, Integer> getOneWayLinkedList(int length) {
        Node<Integer, Integer> temp = null;
        for (int i = 1; i <= length; i++) {
            //头插法：先来的在链尾
            temp = new Node<>(i, i, temp);
        }
        return temp;
    }

    /**
     * 输出单向链表
     *
     * @param linkedList 单向链表，链表头的位置开始。
     */
    public static void forLinkedList(Node<Integer, Integer> linkedList) {
        StringBuilder sb = new StringBuilder();
        sb.append("{");
        while (linkedList != null) {
            sb.append("[k：").append(linkedList.getKey()).append(" v：").append(linkedList.getValue()).append("]");
            linkedList = linkedList.getNext();
        }
        sb.append("}");
        System.out.println(sb.toString());
    }

然后就是main方法，实际运行，看结果。

        Node<Integer, Integer> linkedList = getOneWayLinkedList(6);
        forLinkedList(linkedList);
        //Node<Integer, Integer> node = reverse1(linkedList);
        Node<Integer, Integer> node = reverse2(linkedList);
        forLinkedList(node);

然后就是运行结果啦。