LeetCode刷题笔记之k个链表合并、删除链表中倒数第n个元素以及字符串检查

题目一描述：

合并k个已排序的链表并将其作为一个已排序的链表返回。分析并描述其复杂度。

题目一思路：

给定一个集合，是k个有序的链表，将有序的链表进行合并，将已经排好序的链表与集合中取出一个链表进行合并，类似于插入排序的方式。对于这种复杂度个人认为是最好的情况下是k个链表的长度和，最差的情况下是n的k次幂

代码如下：

import java.util.ArrayList;
public class Solution {
    public ListNode mergeKLists(ArrayList<ListNode> lists) {
        if(lists.size()<=0) return null;//边界判断，集合为空时，返回null
        ListNode head = new ListNode(-1);//给链表加一个头结点
        head.next = lists.get(0);
        for(int i = 1;i<lists.size();i++){//循环遍历集合，每次将集合中的链表与已排好序的链表进行合并
            head = addList(head,lists.get(i));
        }
        return head.next;
    }
    public  ListNode addList(ListNode list1,ListNode list2){
        ListNode prenode = list1;//记录排好序链表的当前节点的前一个节点
        ListNode curnode = list1.next;//排好序链表的当前节点
        ListNode l2curnode =list2;//带排序的链表的当前节点
        while(curnode!=null && l2curnode!=null){
            ListNode l2nextnode =l2curnode.next;//临时节点，当前节点的下一个节点
            if(curnode.val>l2curnode.val){//list1的当前元素大，将其插入排好序的链表中
                prenode.next=l2curnode;
                l2curnode.next=curnode;
                prenode=prenode.next;
                l2curnode=l2nextnode;
            }else{//list2当前元素大，list2的当前元素不懂，链表1的元素后移直到找到适合的位置
                prenode=prenode.next;
                curnode=curnode.next;
            }
        }
        //当链表走到尾部，依旧还有元素没有插入，那么就应该讲元素插入有序链表的最后
        if(curnode==null&&l2curnode!=null){
            prenode.next=l2curnode;
        }
        return list1;
    }
}

题目二描述：

给定一个链表，删除链表的倒数第n个节点并返回链表的头指针

题目二思路：

设计一个长度为n+1的窗，窗头的下一个位置就是要删除的节点，这样就能够实现一步将元素删除。具体是使用两个指针，left与right，right=left+n+1，当right到达链表的末尾时，left的下一个节点就是要删除的节点。

代码如下：

public class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
    	//自定义链表头结点
         ListNode root = new ListNode(-1);
         //条件的边界，当之有一个节点时，返回为null
        if(head.next==null&&n==1)return head.next;
        //定义窗，左右指针，右指针比左指针先走n+1个位置
        ListNode left = root;
        ListNode right = head;
        root.next = head;
        for(int i=1;i<n;i++){
           if(right!=null) {
               right = right.next;
           }else{
               return null;
           }
        }
        //当形成窗时，两个指针一起走，直到右指针走到结尾位置
        while(right.next!=null){
            right = right.next;
            left = left.next;
        }
        //左指针的下一个位置就是要删除的位置
        left.next=left.next.next;
        return root.next;
    }
}

题目三描述：

给出一个仅包含字符’(’,’)’,’{’,’}’,’[‘和’]’,的字符串，判断给出的字符串是否是合法的括号序列
括号必须以正确的顺序关闭，"()“和”()[]{}“都是合法的括号序列，但”(]“和”([)]"不合法。

题目三思路：

根据提示是栈，可以想到使用栈进行对这样特殊的字符串进行处理，如果是符合条件的字符串最后的结果已定义将栈中所有元素进行了归结，栈的大小为0，否则，栈中有元素没有被归结，说明不合格的字符串。

代码如下：

import java.util.Stack;
public class Solution {
    public boolean isValid(String s) {
         Stack<Character> stack = new Stack<>();
        stack.push(s.charAt(0));
        for(int i = 1;i < s.length();i++){
           // if(stack.isEmpty()) stack.push(s.charAt(i));
//            if(!stack.isEmpty()&&stack.peek()=='('&&s.charAt(i)==')'){
//                stack.pop();
//            }else if(!stack.isEmpty()&&stack.peek()=='{'&&s.charAt(i)=='}'){
//                stack.pop();
//            }else if(!stack.isEmpty()&&stack.peek()=='['&&s.charAt(i)==']'){
//                stack.pop();
//            } else{
//                stack.push(s.charAt(i));
//            }
            if(!stack.isEmpty()&&((stack.peek()=='('&&s.charAt(i)==')')||(stack.peek()=='['&&s.charAt(i)==']')||(stack.peek()=='{'&&s.charAt(i)=='}'))){
                stack.pop();
            }else{
                stack.push(s.charAt(i));
            }
        }
        return stack.isEmpty()?true:false;
    }
}