单链表反转与合并两个有序的单链表使之后的单链表任然有序的感想

1单链表反转

1. 思路分析：

 1.   主要思路：1遍历以前的单链表将节点取出cur
     *             2cur.next=head.next[让当前节点指向新链表的第一个节点]
     *             3head.next=cur[让新链表的头节点指向当前的节点]：这样子就连接起来了
     *             4让pre的head.next=new的head.next 重新赋值
     *
     *             注意最关键的处理是遍历那么下一个节点要保存cur=next [位置要在最前面保存起来]，
     *             怎样让当前节点=当前节点的下一个节点

2. 代码实现：

  public static void reverse(HeroNode heroNode){

        //没有节点数据或者只有一个数据直接返回
        if (heroNode.next==null || heroNode.next.next==null){
            return ;
        }

        HeroNode newNodeHead = new HeroNode(0, "");
        //当前节点
        HeroNode cur = heroNode.next;
        //当前节点的下一个节点默认值为null
        HeroNode curNext = null;
        while (cur != null){
            //先保存下一个节点【这一步很关键】
            curNext=cur.next;
           //做主要逻辑处理
            cur.next=newNodeHead.next;
            newNodeHead.next=cur;
            //这样做遍历【这一步很关键】
            cur=curNext;
        }
        heroNode.next=newNodeHead.next;

    }

感想：关于保存一个副本的理解。
a =3 b=4 c=5 a=b [a的值为b的值为4] b=c[b的值为5了] 但是此时a的值还是4
即a保存了b的一份副本，即使b之后怎么变化[~~指的是指向了新的地址，如果b的熟悉变化a是会改变的，因为改变的是本地址的数据熟悉]，a都不会变。【如果这个理解不了就做不出来。】
例如：

      /**
         * 第一种
         */
        Boy boy = new Boy(1);
        //备份下一个节点数据
        Boy curNext = boy.getNext();
        //将当前节点得下一个节点改变，curNext值还是不会变，因为改变得是当前节点得数据
        boy.setNext(new Boy(4));

        /**
         * 第二种
         */
        //备份当前节点的数据
        Boy boy1=boy;
        //将当前节点的熟悉next改变，同样boy1值也会改变
        boy.setNext(new Boy(5));

        /**
         * 第三种
         */
        Boy boy3 = new Boy(3);
        Boy cur1 = boy3;
        boy3.setNo(4);

同理：curNext保存了cur.next的一个副本，然后做相应的逻辑操作，最后让cur=curNext,为指针后移。

2单链表合并

1. 思路分析

 /**
     * @Description:合并两个有序的单链表，使之后的链表任然有序
     * @Param: [node1, node2]
     * @return: singlelinkedlist03.HeroNode
     * @Author: zzs
     * @Date: 2020/2/29
     * @Implementation:
     * 1，声名一个存储链表
     * 2，同时遍历两个链表，将小的放在声名的链表中,[同时让next==null],取出元素的链表指针后移
     * 3，返回新的链表
     */

2. 代码实现

 public static HeroNode mergeLinkedList(HeroNode node1,HeroNode node2){
        HeroNode head = new HeroNode(0, "");
        if (node1.next==null && node2.next == null){
            return head;
        }else if (node1.next==null || node2.next == null){
            //返回不为null的链表
            return node1.next == null ? node2.next : node1.next;
        }
        HeroNode cur1 = node1.next;
        HeroNode cur2 = node2.next;
        //要放入的临时变量，放入时候需要遍历放入
        HeroNode tempPut =null;
        while (true){
            if (cur1==null){
                addNode(head,cur2);
                break;
            }else if (cur2 ==null){
                addNode(head,cur1);
                break;
            }
            if (cur1.no<=cur2.no){
                //取出小的保存起来
                tempPut=cur1;
                cur1=cur1.next;


                //需要将保存起来的节点的next=null
                tempPut.next=null;
                /**
                 *做链表的添加操作
                 */
                 addNode(head,tempPut);
            }else {
                //取出cur2保存
                tempPut=cur2;
                cur2=cur2.next;

                tempPut.next=null;
                /**
                 * 做链表的添加操作
                 */
                addNode(head,tempPut);
            }
        }
      return head;
    }

3，感想，【副本】。temPut=cur1；cur1=cur1.next; temput.next=null
先保存一份cur1的副本，然后将cur1后移，最后将副本的.next域变为null,然后再放入新的链表中

总结：思路不重要，副本的理解还是蛮重要的。即，副本有了，即使原来的数据再如何变化，副本永远不会变。

代码地址：https://github.com/Zhouzhongshang/dataStructure/blob/master/src/singlelinkedlist03/SingleLinkedListDemo.java