流程图：

image.png

代码示例

单向列表反转代码
  1.     public static class Node{
  2.         public int value;
  3.         public Node next;
  5.         public Node(int value){
  6.             this.value = value;
  7.         }
  8.     }
  10.     public static Node reverseNode(Node head){
  11.         Node next = null;
  12.         Node prev = null;
  14.         while (head != null){
  15.             next = head.next;
  16.             head.next= prev;
  17.             prev = head;
  18.             head = next;
  19.         }
  20.         return prev;
  21.     }

单向链表反转包含测试的代码
  1. package com.ss.class02;
  3. import java.util.Random;
  5. /**
  6.  * <p>
  7.  * 反转列表
  8.  * </P>
  9.  *
  10.  * @author: zhangss
  11.  * @since: 2021-01-07
  12.  **/
  13. public class ReverseList {
  14.     /**
  15.      * 单向链表
  16.      */
  17.     public static class Node{
  18.         public int value;
  19.         public Node next;
  21.         public Node(int value){
  22.             this.value = value;
  23.         }
  24.     }
  26.     /**
  27.      * 双向链表
  28.      */
  29.     class DoubleNode{
  30.         public int value;
  31.         public DoubleNode prevNode;
  32.         public DoubleNode nextNode;
  33.         public DoubleNode(int value){
  34.             this.value = value;
  35.         }
  36.     }
  38.     /**
  39.      * 反转单向链表，反转以后返回新的头部
  40.      * @param head
  41.      * @return
  42.      */
  43.     public static Node reverseNode(Node head){
  44.         Node next = null;
  45.         Node prev = null;
  47.         while (head != null){
  48.             next = head.next;
  49.             head.next= prev;
  50.             prev = head;
  51.             head = next;
  52.         }
  53.         return prev;
  54.     }
  56.     /**
  57.      * 生成单向链表
  58.      * @return
  59.      */
  60.     public static Node generateNode(){
  61.         Random random = new Random();
  62.         Node head = new Node(random.nextInt(1000));
  63.         Node tail = head;
  65.         int length = random.nextInt(100);
  66.         for (int i = 0; i < length; i++) {
  67.             tail.next = new Node(random.nextInt(100));
  68.             tail = tail.next;
  69.         }
  70.         return head;
  71.     }
  73.     /**
  74.      * 反转双向链表
  75.      * @param doubleNode
  76.      * @return
  77.      */
  78.     public static DoubleNode reverseDoubleNode(DoubleNode doubleNode) {
  79.         return null;
  80.     }
  82.     /**
  83.      * 测试单向链表反转
  84.      * @param args
  85.      */
  86.     public static void main(String[] args) {
  87.         for(int i=0;i< 50_0000;i++){
  88.             Node head = generateNode();
  89.             // 反转两次和原来的单向链表一致，说明反转方法是正确的
  90.             Node newHead = reverseNode(reverseNode(head));
  92.             if(!nodeEquals(head, newHead)){
  93.                 System.out.println("reverse failed.");
  94.             }
  95.         }
  96.     }
  98.     /**
  99.      * 判断两个单向链表是否相等
  100.      * 转成string进行判断
  101.      * @param head1
  102.      * @param head2
  103.      * @return
  104.      */
  105.     private static boolean nodeEquals(Node head1, Node head2){
  106.         String head1Val = nodeToString(head1);
  107.         String head2Val = nodeToString(head2);
  108.         if (head1Val.equals(head2Val)) {
  109.             return true;
  110.         }else {
  111.             return false;
  112.         }
  113.     }
  115.     /**
  116.      * 单向链表转string
  117.      * @param head
  118.      * @return
  119.      */
  120.     private static String nodeToString(Node head){
  121.         String value = "";
  122.         while (head != null) {
  123.             value = value + head.value;
  124.             head = head.next;
  125.         }
  126.         return value;
  127.     }
  129.     public static void print(Node head){
  130.         Node next = head;
  131.         while (next != null) {
  132.             System.out.println(next.value);
  133.             next = next.next;
  134.         }
  135.     }
  136. }