1.最后一个单词的长度(简单)

58. 最后一个单词的长度 - 力扣（LeetCode）

给你一个字符串 s，由若干单词组成，单词前后用一些空格字符隔开。返回字符串中 最后一个 单词的长度。

单词 是指仅由字母组成、不包含任何空格字符的最大子字符串

子字符串

子字符串 是字符串中连续的 非空 字符序列。

class Solution {
    public int lengthOfLastWord(String s) {
        int n=s.length()-1;
        //先要把最后部分的空格整完
        while(s.charAt(n)==' '){
            n--;
        }
        int count=0;
        while(n>=0&&s.charAt(n)!=' '){
            count++;
            n--;
        }
        return count;
    }
}

 2.螺旋矩阵2

59. 螺旋矩阵 II - 力扣（LeetCode）

给你一个正整数 n ，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。

方法一：模拟

public int[][] generateMatrix(int n) {
        int l=0,r=n-1,t=0,b=n-1;//左右上下分别对应的
        int[][] matrix=new int[n][n];
        int num=1,target=n*n;
        while(num<=target){
            for(int i=l;i<=r;i++){
                matrix[t][i]=num++;
            }
            t++;//模拟从左到右
            for(int i=t;i<=b;i++){
                matrix[i][r]=num++;
            }
            r--;
            //模拟从右到左
            for(int i=r;i>=l;i--){
                matrix[b][i]=num++;
            }
            b--;
            //模拟从下到上
            for(int i=b;i>=t;i--){
                matrix[i][l]=num++;
            }
            l++;
        }
        return matrix;
    }

 3.旋转链表

61. 旋转链表 - 力扣（LeetCode）

方法一：闭合为环

思路及算法

/**
 * 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 ListNode rotateRight(ListNode head, int k) {
        if(k==0||head==null||head.next==null){
            return head;
        }
        int n=1;
        ListNode iter=head;
        //找到iter
        //看一共有几个节点
        while(iter.next!=null){
            iter=iter.next;
            n++;
        }
        int add=n-k%n;
        if(add==n){
            return head;
        }
        //化成环
        iter.next=head;
        while(add-->0){
            iter=iter.next;
        }
        ListNode ret=iter.next;//头节点
        iter.next=null;
        return ret;
    }
}

 4.不同路径

62. 不同路径 - 力扣（LeetCode）

方法一：动态规划

class Solution {
    public int uniquePaths(int m, int n) {
        int[][] f = new int[m][n];
        for (int i = 0; i < m; ++i) {
            f[i][0] = 1;
        }
        for (int j = 0; j < n; ++j) {
            f[0][j] = 1;
        }
        for (int i = 1; i < m; ++i) {
            for (int j = 1; j < n; ++j) {
                f[i][j] = f[i - 1][j] + f[i][j - 1];
            }
        }
        return f[m - 1][n - 1];
    }
}

5.不同路径2

63. 不同路径 II - 力扣（LeetCode）

方法一：动态规划

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int n = obstacleGrid.length, m = obstacleGrid[0].length;
        int[] f = new int[m];

        f[0] = obstacleGrid[0][0] == 0 ? 1 : 0;
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < m; ++j) {
                if (obstacleGrid[i][j] == 1) {
                    f[j] = 0;
                    continue;
                }
                if (j - 1 >= 0 && obstacleGrid[i][j - 1] == 0) {
                    f[j] += f[j - 1];
                }
            }
        }
        
        return f[m - 1];
    }
}