重刷leedcode（21-30）

21. 合并两个有序链表

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode result=new ListNode(0);  //他相当于记录的是temp的头指针的地址
        ListNode temp=result;             //temp是实际操作的链表，又因为操作完temp指向的是尾节点的位置，所以需要result始终记录头节点的位置，方便查找
        while(l1!=null&&l2!=null){
            if(l1.val<l2.val){
                temp.next=l1;
                l1=l1.next;
              
            }else{
                temp.next=l2;
                l2=l2.next;
              
            }
            temp=temp.next;
        }
        temp.next=l1!=null?l1:l2;
        return result.next;
        }
}

22. 括号生成

ps
$注意在递归函数里面：i++和++i，以及i+1作为参数的区别是很大的。$
$如果是i++，则在整个递归过程里面，i值是不变的.++i的变量的作用域大于i+1的.$

public void backtrack(int i){
   //假设传过来的i值1
   backtrack(i+1);  //i的作用域是到这行代码结束。因此i+1在这里具有实时性
   System.out.println(i);   //结果为i，即1
}

public void backtrack(int i){
   backtrack(++i);
   System.out.println(i);   //结果为i+1，即2
}
//i的作用域是到}代码后才结束。因此++i在这里具有滞后性

这个题对我来说，收获颇多。让我对（递归式）回溯算法的编程有了进一步的认识和了解。也纠正了我的递归式编程上的一些编码误区（在递归函数里面传参时要小心使用++i和–i）以为二者都有滞后效应。比如
backtrack(record + “)”, Lcount, ++Rcount, result, n);
当你的程序回溯到上一步的时候。就会发生record和Rcount的对应值不同步的情况：如下： ((()) Lcount为3，Rcount为2 如果再往上回溯一步就为((() Lcount为3，Rcount为1

程序使用的是深度优先搜索；算法执行的过程描述如下：
优先选择一条路走到黑（底），然后跳回上一节点，走另一条未走过的路。它行进的原则是走过的路不会走，不满足条件的路不会走。

class Solution {
    public List<String> generateParenthesis(int n) {
        List<String> result = new ArrayList<>();
        backtrack("", 0, 0, result, n);
        return result;
    }

    public void backtrack(String record, int Lcount, int Rcount, List<String> result, int n) {
        if (Lcount == n && Rcount == n) {
            // if(record.length()==n*2){
            result.add(record);
            System.out.println(record);
            return;
        }
        if (Lcount < n) {
            //切记这里不能用Lcount++，要用，也是++Lcount
            //还有这里不能用record+c,因为首次传进来的是“ ”,这样写就会在统计时把+“ ”作为一个（而使得Lcount比实际值偏大

            backtrack(record + "(", Lcount + 1, Rcount, result, n);
            System.out.println(record + "当前L和R的情况(Lcount<n分支)" + Lcount + "    " + Rcount);
        }
        //也不能使用 if(Rcount<n){}这样）数量会较（少1
        //这里也不能写成 if(Rcount<Lcount){} 否则会出现 (()))( 和  )))(((  ......
        if (Rcount < Lcount) {
            //这里也不能写Rcount+1，而要写成Rcount+1，否则 会出现 ((())  Lcount为3，Rcount为2
            backtrack(record + ")", Lcount, Rcount + 1, result, n);
            System.out.println(record + "当前L和R的情况(Rcount<n分支)" + Lcount + "    " + Rcount);

        }
    }
}

23. 合并K个排序链表

ps
这道题我主要调用了java的priority优先队列的接口，从而简化了代码的实现的难度。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        /**
        * 对于一个数组里面包含多个数组/链表的情况，解决思路一般有一下几种：
        * 1.两两比较后再两两合并，依次下去
        * 2. 将多个数组合并成一个数组
        * 3.将他们装入优先队列中
        */
        if(lists==null||lists.length==0) return null;
        ListNode result=new ListNode(0);
        ListNode temp=result;
        PriorityQueue<ListNode> q=new PriorityQueue<>(new Comparator<ListNode>(){
            @Override
            public int compare(ListNode l1,ListNode l2){ return l1.val-l2.val;}
        });
        for(ListNode node:lists){
            if(node!=null) q.add(node);
        }
       
        while(!q.isEmpty()){
             ListNode first=q.poll();

             temp.next=first;
             temp=temp.next;

             first=first.next;
             if(first!=null)  q.add(first);
        }
        return result.next;

    }
}

24. 两两交换链表中的节点

ps
代码执行的效率不算太高。但是发现了链表错误赋值造成的死循环的一种错误的编码。他是通过编辑器的调试测出来的。在后面的编码中需要多多注意。通过这题也收获了如何将想法编成代码的小小进步。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode swapPairs(ListNode head) {
        if(head==null||head.next==null) return head; 
        List<Integer>list=new ArrayList<>(); 
             ListNode result=new ListNode(0);
             ListNode temp=result;
        while(head!=null){
            list.add(head.val);
            head=head.next;
            /**
            * while(head!=null){
            * result.next=head.next;
            * result.next.next=head;
            * 以上两行是一个死循环的赋值，要注意
            * 它等价于 head.next.next=head;
            */
        }
        for(int i=0;i<list.size();i++){

           if(i+1<list.size()){ 
               temp.next=new ListNode(list.get(i+1));
               temp.next.next=new ListNode(list.get(i));
           }
           else temp.next=new ListNode(list.get(i));
        //    result=temp;
           temp=temp.next.next;
           i++;
        }
        return result.next;
    }
}

25. K 个一组翻转链表

ps

转自：https://leetcode-cn.com/problems/reverse-nodes-in-k-group/solution/tu-jie-kge-yi-zu-fan-zhuan-lian-biao-by-user7208t/

这题我知识上出现的盲点是:如何解决已反转的链表和未反转的链表连接的问题。
想了半天，想的那些办法都没有解决这个问题。后面参考了题解。大神是用哑节点+记录反转后链表的头指针解决的。中间是发现了一些想法可能存在问题。应该想办法解决问题，才能接着采用这个想法做下去（或者直接抛弃有问题得想法，另寻它路）。可我存在侥幸心理。觉得可能存在得问题如果不发生，我得代码就通过了。结果就困在里面出不来了

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        if(head==null||head.next==null) return head;
        ListNode dummy=new ListNode(0);
        dummy.next=head;
        ListNode e=head;
        ListNode s=head;
        ListNode n=head;
        ListNode pre=dummy;
        while(n!=null&&n.next!=null){
        //指针移动n-1次
        for(int i=0;i<k-1;i++){
            if(e.next==null) return dummy.next;;
            e=e.next;
        }
        n=e.next;
        e.next=null;
        ListNode r=reverse(s);
        pre.next=r;
        pre=s;
           s.next=n;
           s=n;
           e=n;
        }
       return dummy.next;
    }
    public ListNode reverse(ListNode h){
        ListNode c=h;
        ListNode n=h.next;
        ListNode p=null;
        while(n!=null){
             c.next=p;
             p=c;
             c=n;
             n=n.next;
        }
        c.next=p;
        return c;
    }
}