LeetCode刷题(最多水的容器、链表问题)

题目一 盛最多水的容器

题目描述

给一个非负整数a1…an，每一个数代表坐标中的一个点(i,ai)，在坐标内画n条垂直线，垂直线的两端分别为(i,ai)(i,0)，找出其中的两条线，使得该线与x轴构成的容器有更多的水。

例如 [1,8,6,2,5,4,8,3,7]
输出：49

题目分析

作为算法新手，我总是想着使用之前学过的算法接问题，因为之前在左神的算法课中听过一个单调栈结构，该数据结构的具体使用，维护一个容器(可以使栈也可以是队列)，遍历数组，将当前大于栈顶的元素地址加入栈中，如果不大于就对其进行归结，不加入栈中，简单的说就是自己可能能够存放更多的水，但是如果后面有比自己大的那么自己就不可能最大，因为后面的元素长、高都大。
其实这个方法是由缺点的，在遍历的时候没有做更多的事情，知识将大的元素加入栈中，因此时间复杂度和空间复杂度比较高，在评论区看到了使用双指针或者是快排的思想。

代码如下

public int method2(int[] height){
        if(height.length<=1)return 0;
        //栈中维持从大到小的顺序，存放的是数组的下标
        LinkedList<Integer> queue = new LinkedList<>();
        int res = Integer.MIN_VALUE;
        for(int i=0;i<height.length;i++){
            if(queue.isEmpty())queue.push(i);//空栈将元素直接加入
            else if(height[i]>height[queue.peek()]){
            //当前元素大于栈顶元素，直接加入
                queue.push(i);
            }else{
            //当前元素小，那就将其归结，也就是将其能够容纳的水容量计算出来
               for(int j=0;j<queue.size();j++){
                   Integer temp = queue.get(j);
                   int area = (i-temp)*Math.min(height[temp],height[i]);
                   res = res>area?res:area;
               }
            }
        }
        int n = queue.size();
        int val = queue.getFirst();
        //最后计算栈中剩余的元素
        for(int j=0;j<n;j++){
            Integer temp = queue.get(j);
            int area = (val - temp) * height[temp];
            res = res>area?res:area;
        }
        return res;
    }

类似于快排思想的排序算法

public int maxArea(int[] height) {
        int left = 0;
        int right = height.length-1;
        int res = 0;
        while(left<right){
        //左边小就将左边归结，右边小就将右边归结
            if(height[left]<height[right]){
                int area = (right-left)*height[left];
                res = res>area?res:area;
                left++;
            }else{
                int area = (right-left)*height[right];
                res = res>area?res:area;
                right--;
            }
        }
        return res;
    }

题目二 合并k个升序的链表

题目描述

给定一组链表，每一个链表是升序排列，将所有的链表合并为单链表，返回合并后的链表。

例如
输入：lists = [[1,4,5],[1,3,4],[2,6]]
输出: [1,1,2,3,4,4,5,6]
题目链接,快去刷题吧

题目分析

简单思想：每次从数组中取出一个链表与已经合并的链表进行合并
利用二分法：将数组左边合并，再将数组右边合并，合并后的链表再进行合并
其中涉及的问题是，合并后的链表会越来越长，时间复杂度是一个问题

代码如下

class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        if(lists.length==0)return null;
        //将合并后的链表放置在数组的第一个位置上，每次合并第一个位置和当前位置的链表
        for(int i=1;i<lists.length;i++){
           lists[0] = mergeList(lists[0],lists[i]);
        }
        return lists[0];
    }
    //合并两个链表，使用插入排序的思想，将两个链表合并起来
    public ListNode mergeList(ListNode l1,ListNode l2){
        if(l1==null)return l2;
        if(l2==null)return l1;
        ListNode ll1 = l1;
        ListNode ll2 = l2;
        ListNode res = new ListNode(-1);
        ListNode temp = res;
        while(ll1!=null&&ll2!=null){
            if(ll1.val<ll2.val){
                temp.next = ll1;
                ll1 = ll1.next;
                temp = temp.next;
            }else{
                temp.next = ll2;
                ll2 = ll2.next;
                temp = temp.next;
            }
        }
        while(ll1!=null){
            temp.next = ll1;
            ll1 = ll1.next;
            temp = temp.next;
        }
        while(ll2!=null){
            temp.next = ll2;
            ll2 = ll2.next;
            temp = temp.next;
        }
        return res.next;
    }
}

对于分支法的算法可以参考评论区的一些大牛。

题目三 两两交换链表中的节点

题目描述

给定一个链表，将链表中相邻的两个节点进行交换

例如：
输入：1->2->3->4
输出：2->1->4->3

去刷题

题目分析

对于链表我个人的总结是需要记住关键的几个信息:

1.头结点root
2.当前节点cur
3.当前节点的下一个节点pos
4.当前节点的前一个节点pre
当前节点是必须需要的信息
如果需要返回整个链表就需要将头结点记录，因此需要一个指针root
如果需要删除当前节点，那么就需要有一个指针是当前节点的前一个节点pre

代码如下

class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode root = new ListNode(-1);
        root.next = head;
        ListNode pre = root;
        ListNode cur = head;
        ListNode pos = cur;

        while(cur != null&&cur.next != null){
            pos = cur.next;
            pre.next = pos;
            cur.next = pos.next;
            pos.next = cur;
            pre = cur;
            cur = cur.next;
        }

        return root.next;
    }
}