字节阿里高频50题：135. 分发糖果 143. 重排链表（双指针，注意细节，因为返回值是void） 54. 螺旋矩阵 (细节处理)

/**
解题思路：其实有一道类似题，在前100或者剑指offer里面，我们考虑两个数组，分别以左向右，以右向左规则的两个数组，然后找其中最大值
 */
class Solution {
    public int candy(int[] ratings) {
        int len = ratings.length;
        int res = 0; //返回值
        //两个数组
        int[] lft = new int[len];
        int[] rgt = new int[len];
        //左向右遍历
        lft[0] = 1;
        for(int i=1 ; i<len ; i++){
            if (ratings[i]>ratings[i-1])
                lft[i] = lft[i-1]+1;
            else
                lft[i] = 1;
        }
        //向右遍历
        rgt[len-1] = 1;
        for(int j=len-2 ; j>=0 ; j--){
            if(ratings[j] > ratings[j+1])
                rgt[j] = rgt[j+1]+1;
            else
                rgt[j] = 1;
        }
        //然后重新遍历这两个数组，中最大值
        for(int i=0 ; i<len ; i++){
            res += Math.max(lft[i] , rgt[i]);
        }
        return res;
    }
}
/**
优化：没有必要遍历三次，我们由右向左遍历，直接求最大值即可,这样即可，但是降低了时间复杂度，毕竟每次循环要多判断
 */
 class Solution {
    public int candy(int[] ratings) {
        int len = ratings.length;
        int res = 0; //返回值
        int rgt=1;
        //两个数组
        int[] lft = new int[len];
        //左向右遍历
        for(int i=0 ; i<len ; i++){
            if (i>0 && ratings[i]>ratings[i-1])
                lft[i] = lft[i-1]+1;
            else
                lft[i] = 1;
        }
        //向右遍历
        for(int j=len-1 ; j>=0 ; j--){
            if(j<len-1 && ratings[j] > ratings[j+1])
                rgt++;
            else
                rgt = 1;
            res += Math.max(lft[j] , rgt);
        }
        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; }
 * }
 */

 /**
 解题思路：常规题，就是每次将这个链表的指插到前面来，双指针可以
  */
class Solution {
    public void reorderList(ListNode head) {
        //首先创建一个双向队列
        List<ListNode> list  = new ArrayList<>();
        //创建节点
        ListNode tmp = head;
        while(tmp!=null){
            list.add(tmp);
            tmp = tmp.next;
        }
        //双指针
        int i =0 , j = list.size()-1;
        while(i<j){
            list.get(i).next = list.get(j);
            i++;
            if(i==j)
                break;
            list.get(j).next = list.get(i);
            j--;
        }
        list.get(i).next = null; //避免成环
    }
}

/**
while循环
 */
class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {

        List<Integer> list = new LinkedList<>();

        if(matrix == null || matrix.length == 0 || matrix[0].length == 0)
            return list;

        int left = 0 , right = matrix[0].length-1 , top = 0 , button = matrix.length-1;

        while(left<=right && top<=button){
            //从左向右
            for(int i=left ; i<=right ; i++){
                list.add(matrix[top][i]);
            }
            top++;
            //从上向下
            for(int j = top ; j<=button ; j++){
                list.add(matrix[j][right]);
            }
            right--;
            //从右向左
            for(int i=right ; i>=left && top<=button ; i--){
                list.add(matrix[button][i]);
            }
            button--;
            //从下向上
            for(int j = button ; j>=top && left<=right ; j--){
                list.add(matrix[j][left]);
            }
            left++;
        }
        //到此就结束了
        return  list;
    }
}