java-实现链表的反转

单向链表的反转

public class reverseList {
    /**
     * 单向链表
     */
    static class Node{
        int value;
        Node next;
        public Node(int value) {
            this.value = value;
        }
    }

    /**
     * 单向链表反转
     * @param head
     * @return
     */
    public static Node reverseLinkedList(Node head){
        Node pre = null;  //反转后的链表
        //链表中每一个Node都是一个对象
        while (head != null){
            Node next = head.next;  // 用来记录下次循环的节点,（新对象）
            head.next = pre;  //将当前节点的next 节点 设置为 上一次的 pre
            pre = head; // 将 pre 设置位当前节点，用于下次循环
            head = next; // 设置下次循环的节点，赋值后 head 指向的是一个新对象
        }
        return pre;
    }

    public static void main(String[] args) {
        Node head = new Node(1);
        Node node1 = new Node(2);
        Node node2 = new Node(3);
        Node node3 = new Node(4);
        Node node4 = new Node(5);
        head.next = node1;
        node1.next = node2;
        node2.next = node3;
        node3.next=node4;
//       while (head != null){
//           System.out.println(head.value);
//           head = head.next;
//       }

       head = reverseLinkedList(head);
       while (head != null){
            System.out.println(head.value);
            head = head.next;
       }
       
    }
}

双向链表的反转

public class ReverseDoubleLinkedList{
    public static void main(String[] args) {      
        System.out.println("==================");
        DoubleNode doubleNode = generateRandomDoubleList(10, 10);
       System.out.println("==================");
        DoubleNode doubleNode = generateRandomDoubleList(10, 10);
        DoubleNode sourceNode = doubleNode;
        while (sourceNode != null){
            System.out.println(sourceNode.value + ",前一个节点："+ (null != sourceNode.pre ? sourceNode.pre.value :null)  + ",下一个节点：" + (null != sourceNode.next ? sourceNode.next.value :null) );
            sourceNode = sourceNode.next;
        }
        System.out.println("反转后==================");
        doubleNode = reverseDouble(doubleNode);
        while (doubleNode != null){
            System.out.println(doubleNode.value + ",前一个节点："+ (null != doubleNode.pre ? doubleNode.pre.value :null)  + ",下一个节点：" + (null != doubleNode.next ? doubleNode.next.value :null) );
            doubleNode = doubleNode.next;
        }
    }

    /**
     * 双向链表
     *
     */
    public static class DoubleNode {
        public int value;
        public DoubleNode pre;
        public DoubleNode next;

        public DoubleNode(int data) {
            value = data;
        }

    }

    /**
     * 双向链表反转
     * @param head
     * @return
     */
    public static DoubleNode reverseDoubleLinkedList(DoubleNode head){
        DoubleNode pre = null;//反转后的链表
        while (head != null){
            DoubleNode next = head.next; // 保存下一次要执行的node节点
            head.next = pre;  //将当前Node节点的next节点，设为pre
            head.pre = next;  //将当前Node节点的pre节点，设为next
            pre = head;  // 将当前节点 赋值 给 pre
            head = next; // 将next 节点 赋值给head，以便下次循环执行
        }
        return pre;
    }

	/**
	* 生成随机双向链表
	*/
    public static DoubleNode generateRandomDoubleList(int len, int value) {
        int size = (int) (Math.random() * (len + 1));
        if (size == 0) {
            return null;
        }
        size--;
        DoubleNode head = new DoubleNode((int) (Math.random() * (value + 1)));
        DoubleNode pre = head;
        while (size != 0) {
            DoubleNode cur = new DoubleNode((int) (Math.random() * (value + 1)));
            pre.next = cur;
            cur.pre = pre;
            pre = cur;
            size--;
        }
        return head;
    }
}