数据结构之单链表的反转

1. 分析
   
2. 代码实现

   package com.iamp.admin;
   
   public class Test {
   
       public static void main(String[] args) {
           //先创建几个节点
           HeroNode heroNode1 = new HeroNode(1,"宋江","及时雨");
           HeroNode heroNode2 = new HeroNode(2,"卢俊义","玉麒麟");
           HeroNode heroNode3 = new HeroNode(3,"吴用","智多星");
           HeroNode heroNode4 = new HeroNode(4,"林冲","豹子头");
           //创建链表
           SingleLinkedList singleLinkedList = new SingleLinkedList();
           //加入节点
           singleLinkedList.add(heroNode1);
           singleLinkedList.add(heroNode2);
           singleLinkedList.add(heroNode3);
           singleLinkedList.add(heroNode4);
           //显示链表
           singleLinkedList.show();
           System.out.println("反转=============================");
           reverseList(singleLinkedList.getHead());
           singleLinkedList.show();
       }
   
       //方法：将单链表进行反转
       public static void reverseList(HeroNode head){
           //如果当亲链表为空或者只有一个节点，直接返回
           if(head.next==null ||head.next.next==null){
               return;
           }
           //定义一个辅助变量，遍历原来的链表
           HeroNode cur = head.next;
           HeroNode next = null;//指向当前节点cur的下一个节点
           HeroNode reverseHead = new HeroNode(0,"","");
           //遍历原来的链表，每遍历一个节点，就将其取出，并放在新的节点reverseHead的最前端
           while (cur!=null){
               next = cur.next;//先暂时保存当前节点的下一个节点,下面要使用
               cur.next = reverseHead.next;//将cur的下一个节点指向新的链表的最前端
               reverseHead.next=cur;//将cur连接到新的链表上
               cur = next;//让cur后移
           }
           //将head.next指向reverseHead.next ,实现单量表的反转
           head.next = reverseHead.next;
       }
   
   
   }
   
   class HeroNode{
       public int no;
       public String name;
       public String nickName;
       public HeroNode next;//指向下一个节点
   
       //构造器
       public HeroNode(int no,String name,String nickName){
           this.no = no;
           this.nickName = nickName;
           this.name = name;
       }
   
       @Override
       public String toString() {
           return "HeroNode{" +
                   "no=" + no +
                   ", name='" + name + '\'' +
                   ", nickName='" + nickName + '\'' +
                   '}';
       }
   }
   
   class SingleLinkedList{
       //创建一个头节点
       private HeroNode head = new HeroNode(0,"","");
   
       public HeroNode getHead() {
           return head;
       }
   
       //添加节点到单向链表
       public void add(HeroNode heroNode){
           //定义一个辅助变量指向头结点
           HeroNode temp = head;
           while (true){
               //如果找到了节点的最后就跳出循环
               if(temp.next == null){
                   break;
               }
               //如果没有找到节点最后，就让temp后移
               temp = temp.next;
           }
           //当退出while循环时，temp就指向了链表的最后
           //将最后这个节点的next指向新的节点
           temp.next = heroNode;
       }
   
       //显示链表
       public void show(){
           if(head.next == null){
               System.out.println("链表为空");
               return;
           }
           HeroNode temp = head.next;
           while (true){
               if(temp==null){
                   break;
               }
               //输出节点信息
               System.out.println(temp);
               temp = temp.next;
           }
       }
   }
   
   
   
   

   

3. 主要代码分析

   //方法：将单链表进行反转
       public static void reverseList(HeroNode head){
           //如果当亲链表为空或者只有一个节点，直接返回
           if(head.next==null ||head.next.next==null){
               return;
           }
           //定义一个辅助变量，遍历原来的链表
           HeroNode cur = head.next;
           HeroNode next = null;//指向当前节点cur的下一个节点
           HeroNode reverseHead = new HeroNode(0,"","");
           //遍历原来的链表，每遍历一个节点，就将其取出，并放在新的节点reverseHead的最前端
           while (cur!=null){
               next = cur.next;//先暂时保存当前节点的下一个节点,下面要使用
               cur.next = reverseHead.next;//将cur的下一个节点指向新的链表的最前端
               reverseHead.next=cur;//将cur连接到新的链表上
               cur = next;//让cur后移
           }
           //将head.next指向reverseHead.next ,实现单量表的反转
           head.next = reverseHead.next;
       }

   1）初始化需要反转的链表数据
        head->宋江->卢俊义->吴用->林冲
   2）进入反转的方法中第一次while各个变量的值
         cur:
             宋江->卢俊义->吴用->林冲
         reverseHead:
             head->宋江->null
          
   3）进入反转的方法中第二次while各个变量的值
         cur:
              卢俊义->吴用->林冲
         分析：
              a: next = cur.next;//先暂时保存当前节点的下一个节点,下面要使用
                  next等于：吴用->林冲
              b: cur.next = reverseHead.next;//将cur的下一个节点指向新的链表的最前端
                  reverseHead.next等于：宋江->null
                  cur.next等于： 宋江->null
                  所以cur等于：卢俊义->宋江->null
              c：reverseHead.next=cur;//将cur连接到新的链表上 
                   reverseHead等于：head->卢俊义->宋江->null
              d：cur = next;//让cur后移,最后将之前保存的next赋值给cur重新循环-->
                    cur等于：吴用->林冲
         结果reverseHead：
              head->卢俊义->宋江->null  
   4)  进入反转的方法中第3次while各个变量的值
        cur:
             吴用->林冲
        分析同理......
        reverseHead:
             head->吴用->卢俊义->宋江->null
   .........
   最后：
        reverseHead：
             head->林冲->吴用->卢俊义->宋江