1.简化路径

解题思路:

根据题意，使用栈进行模拟即可。

具体的，从前往后处理 path，每次以 item 为单位进行处理（有效的文件名），根据 item 为何值进行分情况讨论：

1. item 为有效值 ：存入栈中；
2. item 为 .. ：弹出栈顶元素（若存在）；
3. item 为 . ：不作处理。

class Solution {
    public String simplifyPath(String path) {
        Deque<String> stack =new LinkedList<>();
        for(String item:path.split("/")){
            if(item.equals("..")){
                if(!stack.isEmpty())stack.pop();
            }else if(!item.isEmpty()&&!item.equals(".")) stack.push(item);
        }
        String res ="";
        for(String d:stack) res="/"+d+res;
        return res.isEmpty() ?"/":res;

    }
}

这里其实可以再优化一下：因为有拼接的过程，用String的效率不高，我们可以换成StringBuffer

class Solution {
    public String simplifyPath(String path) {
        Stack<String> stack = new Stack<>();
        StringBuilder ret = new StringBuilder();
        for (String p : path.split("/")) {
            if (!stack.empty() && p.equals("..")) {
                stack.pop();
            } else if (!" ..".contains(p)) {
                stack.push(p);
            }
        }
        for (String i : stack) {
            ret.append("/" + i);
        }
        return ret.length() == 0 ? "/" : ret.toString();
    }
}

2.螺旋矩阵

解题思路：

初始化一个 n×n 大小的矩阵 mat，然后模拟整个向内环绕的填入过程：

1. 定义当前左右上下边界 l,r,t,b，初始值 num = 1，迭代终止值 tar = n * n；
2. 当 num <= tar 时，始终按照 从左到右 从上到下 从右到左 从下到上 填入顺序循环，每次填入后：
3. 执行 num += 1：得到下一个需要填入的数字；
4. 更新边界：例如从左到右填完后，上边界 t += 1，相当于上边界向内缩 1。
5. 使用num <= tar而不是l < r || t < b作为迭代条件，是为了解决当n为奇数时，矩阵中心数字无法在迭代过程中被填充的问题。
6. 最终返回 mat 即可。

 

class Solution {
    public int[][] generateMatrix(int n) {
        int l =0,r=n-1,t=0,b=n-1;
        int[][] mat =new int[n][n];
        int num =1,tar =n*n;
        while(num<=tar){
            for(int i =l;i<=r;i++){
                mat[t][i]=num++;
            }
             t++;
            for(int i =t;i<=b;i++){
                mat[i][r]=num++;
            }
             r--;
            for(int i =r;i>=l;i--){
                mat[b][i]=num++;
            }
              b--;
            for(int i =b;i>=t;i--){
                mat[i][l]=num++;
            }
            l++;
        }
        return mat;

    }
}

3.下一个排列

解题思路：

 

 

 

 

 

class Solution {
    public void nextPermutation(int[] nums) {
      int i =nums.length-2;
      while(i>=0&&nums[i]>nums[i+1]){
        i--;
      }
      if(i>=0){
        int j =nums.length-1;
        while(j>=0&&nums[i]>=nums[j]){
            j--;
        }
        swap(nums,i,j);
      }
      reverse(nums,i+1);
    }
    public void swap(int[] nums,int i ,int j ){
        int temp =nums[i];
        nums[i]=nums[j];
        nums[j]=temp;
    }
    public void reverse(int[] nums,int start){
        int left=start,right=nums.length-1;
        while(left<right){
            swap(nums,left,right);
            left++;
            right--;
        }
    }

}