2021-05-31LC “阿里题库” 14. 最长公共前缀 19. 删除链表的倒数第 N 个结点

//两两比较，遍历字符串 ,时间复杂度O(字符串长度之和)，空间复杂度O(1)
class Solution {
    public String longestCommonPrefix(String[] strs) {
        if(strs.length == 0){  //空字符串
            return "";
        }
        String res = strs[0];
        for(int i=1 ; i<strs.length;i++){
            //两两进行比较 
            int j=0;
            for(  ; j<res.length() && j<strs[i].length();j++){
                if(res.charAt(j)!=strs[i].charAt(j))//循环头
                    break;
            }
            res = res.substring(0,j);
            //进一步判断
            if(res == ""){
                return res;
            }
        }
        return res;
    }
}
//第二种方法，利用string中的startwith(String s)方法 时间复杂度O(所有字符串的长度) 空间复杂度O(1)
class Solution {
    public String longestCommonPrefix(String[] strs) {
        if(strs.length == 0){  //空字符串
            return "";
        }
        String res = strs[0]; //遍历字符串
        for(String str : strs){
            while(!str.startsWith(res)){
                if(res.length()==0)
                    return "";
                res = res.substring(0,res.length()-1);
            }
        }
        return res;
    }
}

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
//注意的细节：如果删除的是头节点？？？？所以我们要从头节点的前一个结点开始遍历
//时间复杂度O(s) 空间复杂度O(1)
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        //计算链表的长度
        int len = len(head);
        //然后求要删除结点的位置，也就是头结点的前一个结点要走的次数
        int index = len - n;
        ListNode pre = new ListNode(0 , head);
        ListNode pre1 = pre;
        while(index--!=0){
            pre1 = pre1.next;
        }
        //pre1到达了要删除结点的前一个位置
        pre1.next = pre1.next.next;
        return pre.next;
    }
    private int len(ListNode head){
        int res = 0;
        ListNode temp = head;  
        while(temp!=null){
            res++;
            temp = temp.next;
        }
        return res;
    }
}

//思路2：第二种方法，我们可以用栈来解决问题，先入后出，遍历字符串，把每一个字符放入到栈中，然后再拿出n个
//时间复杂度O(n)空间复杂度O(1)
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        //先定义一个栈
        Deque<ListNode> stack = new LinkedList<ListNode>();
        //把包括头结点的前一个结点的所有结点放入到栈中
        ListNode pre = new ListNode(0 , head);
        ListNode pre1 = pre;
        while(pre1 != null){
            stack.push(pre1);
            pre1 = pre1.next;
        }
        //这时候已经全部放入了,然后我们需要去除包括要删除节点所在的后面的所有结点,也就是n个
        while(n--!=0){
            stack.pop();
        }
        //现在栈上的就是要删除结点的前一个结点
        ListNode cur = stack.peek();
        cur.next = cur.next.next;
        return pre.next;
    }
}
//思路3：快慢指针，第一个指针先走n步，然后两个指针一起走，一直到前一个指针遍历结束
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        //定义两个快慢指针
        ListNode pre = new ListNode(0,head);
        ListNode first = head;
        ListNode second = pre;
        //first先走n步
        for(int i=0 ; i<n ; i++){
            first = first.next;
        }
        //一起走
        while(first!=null){
            first = first.next;
            second = second.next;
        }
        //这时候second在要删除结点的前面一个结点
        second.next = second.next.next;
        return pre.next;   
    }
}