剑指offer基础版 ----- 第25天

class Solution {
    
    public int[] spiralOrder(int[][] matrix) {
    
        if(matrix.length == 0){
    
            return new int[0];
        }
        int[] arr = new int[matrix.length * matrix[0].length];
        List<Integer> list= new ArrayList<>();
        int left = 0;
        int right = matrix[0].length -1;
        int high = 0;
        int low = matrix.length -1;
        while(true){
    
            int a = left;
            while(a <= right){
    
                list.add(matrix[high][a++]);
            }
            if(++high > low){
    
                break;
            }
            int b = high;
            while(b <= low){
    
                list.add(matrix[b++][right]);
            }
            if(--right < left){
    
                break;
            }
            
            int c  = right;
            while(c >= left){
    
                list.add(matrix[low][c--]);
            }
            if(--low < high){
    
                break;
            }
            int d  = low;
            while(d >= high){
    
                list.add(matrix[d--][left]);
            }
            if(++left > right){
    
                break;
            }
        }
        int j = 0;
        for(int i : list){
    
            arr[j] = i;
            j++;
        }
        return arr;
    }
}

class Solution {
    
    public boolean validateStackSequences(int[] pushed, int[] popped) {
    
        Stack<Integer> stack = new Stack<>();
        int i = 0;
        for(int num : pushed) {
    
            stack.push(num); // num 入栈
            while(!stack.isEmpty() && stack.peek() == popped[i]) {
     // 循环判断与出栈
                stack.pop();
                i++;
            }
        }
        return stack.isEmpty();
    }
}