LeetCode刷題筆記9.2-9.9

CandyWang-發表於2024-09-09
LeetCode筆記

leetCode刷題筆記(9.2-9.9）

48.旋轉影像(9.3）

1）影像即二維陣列，影像的旋轉本質上是二維陣列的旋轉變換
2）二維陣列從外層來看，是若干個子陣列的集合，子陣列內部維護各自的元素，即若干個row裡是row.length個column
3）由此可理解下面幾個關於二維陣列的函式：

  • 建立二維陣列並初始化
int[][] a = new int[3][4];
// 多維陣列的每個元素都是陣列本身。而且，與C/C++不同，Java中多維陣列的每一行可以具有不同的長度。
a = {
      {1, 2, 3}, 
      {4, 5, 6, 9}, 
      {7}, 
    };

  • 計算每個子陣列的長度即row裡column的數目
//計算每行的長度
System.out.println("第1行的長度: " + a[0].length);
System.out.println("第2行的長度: " + a[1].length);
System.out.println("第3行的長度: " + a[2].length);
  • 使用迴圈列印2維陣列的所有元素
for (int i = 0; i < a.length; ++i) {
     for(int j = 0; j < a[i].length; ++j) {
          System.out.println(a[i][j]);
     }
}
  • 使用for-each迴圈列印二維陣列元素
//首先for ... each迴圈訪問單個陣列
//在二維陣列中
for (int[] innerArray: a) {
    //第二次for ... each迴圈訪問行內的每個元素
    for(int data: innerArray) {
        System.out.println(data);
    }
}

151. 反轉字串中的單詞(9.4）

1）JAVA中的String類，不同於c語言中的字串型別：

  • 經過String宣告過的變數，不可以再對本身作修改，修改時必須賦值給另一個變數
  • 建立一個新的字串有多種方式
    //使用new的方式來獲取一個字串物件
    //空參構造：可以獲取一個空白的字串物件
    String s2 = new String();
    System.out.println("@" + s2 + "!");//""

    //傳遞一個字串，根據傳遞的字串內容再建立一個新的字串物件
    String s3 = new String("abc");
    System.out.println(s3);

    //傳遞一個字元陣列，根據字元陣列的內容再建立一個新的字串物件
    char[] chs = {'a', 'b', 'c', 'd'};
    String s4 = new String(chs);
    System.out.println(s4);//abcd

    //傳遞一個位元組陣列，根據位元組陣列的內容再建立一個新的字串物件
    //應用場景：以後在網路當中傳輸的資料其實都是位元組資訊
   //我們一般要把位元組資訊進行轉換，轉成字串，此時就要用到這個構造了。
    byte[] bytes = {97, 98, 99, 100};
    String s5 = new String(bytes);
    System.out.println(s5);//abcd

}
  • 常用的幾個字串方法：
        String str2 = "Hello";
        String str1 = "hello";

        // 返回字串長度
        System.out.println(str1.length); //5

        //字串比較
        System.out.println(str1.equals(str2)); //false

        // 忽略大小寫比較
        boolean  b = str1.equalsIgnoreCase(str2);
        System.out.println(b); //true

        // 字串轉換成小寫
        String s = str2.toLowerCase();
        System.out.println(s); //hello

        // 轉換成大寫
        System.out.println(str1.toUpperCase()); //HELLO

        // 返回第一次出現 l 的索引，從左往右找
        int index = str1.indexOf("l");
        System.out.println(index); //2

        int index1 = str1.indexOf(1);
        System.out.println(index1); //找不到 返回-1

        // 返回最後出現 l 的索引，從右往左找
        int index2 = str1.lastIndexOf("l");
        System.out.println(index2); //3

        // 從3索引提取元素，預設到末尾
        String substring = str1.substring(3);
        System.out.println(substring); //lo

        // 從3索引提取元素，到末尾
        String substring1 = str1.substring(3, str1.length());
        System.out.println(substring1); //lo

        // 提取1到3索引的元素，包左不包右
        String substring2 = str1.substring(1, 3);
        System.out.println(substring2); //el

        // 返回前後不含空格的字串，中間的不算
        String str3 = "  ni hao ";
        String trim = str3.trim();
        System.out.println(trim); //ni hao

        // concat拼接字串
        String concat = str1.concat(str2);
        System.out.println(concat); //helloHello

        // 擷取郵箱字尾
        String email = "666@qq.c.om";
        //先找到最後一個.出現的位置，再加一
        int index5 = email.lastIndexOf(".") + 1;
        String substring3 = email.substring(index5);
        System.out.println(substring3); //om
      
      // replace(被替換字串 ,字串)：替換字串
        String str4 = "今天天氣很好,天氣萬里無雲";
        String str5 = str4.replace("天氣", "**");
        System.out.println(str5); //今天**很好,**萬里無雲

        // replaceAll(正規表示式/字串，字串): 全部替換
        String str6 = "今天1天氣2很好3";
        String newStr6 = str6.replaceAll("\\d", "\\$");
        System.out.println(newStr6);//今天$天氣$很好$

        // split(分隔符號) 返回的是子字串陣列
        String str7 = "張三,小明,李四";
        String[] splits = str7.split(",");
        System.out.println(Arrays.toString(splits));
        //[張三, 小明, 李四]
      
       // charAt(索引)：字串根據索引轉成 單個字元
        char c = str7.charAt(0);
        System.out.println(c);//張
      
       // toCharArray():將字串中的字元轉換為字元陣列
        char[] chars = str7.toCharArray();
        System.out.println(Arrays.toString(chars));
        //[張, 三, ,, 小, 明, ,, 李, 四]
      
       // endsWith(字串)：判斷尾部是否包含該字串
        String str8 = "11.png";
        boolean png = str8.endsWith("png");
        System.out.println(png);//true

        // startsWith(字串)：判斷頭部是否包含該字串
        boolean b1 = str8.startsWith("1");
        System.out.println(b1);//true

    }
}
  • 當使用雙引號直接賦值時，系統會檢查該字串常量在串池（堆空間）中是否存在，如果存在會複用此時字串常量的地址值，如果執行String s1 ="hello"; String s2 = "hello";此時s1和s2指向同一個地址值；如果不存在會建立新的地址空間，如果存在則複用。
  • 每new一次會會在堆中開闢一小塊空間，儲存的是堆中地址，不同new出來的變數指向不同堆地址
  • 使用雙等號來比較字串：
//引用資料型別比較的是地址值,如：
 String s1 = new String("abc");
 String s2 = new String("abc"); //s1和s2分別指向不同堆地址
System.out.print(s1==s2);// false

String s1 = "abc";
String s2 = "abc";
//s1 和s2指向同一塊記憶體地址空間。
System.out.print(s1==s2);// true
  • StringBuilder類：
    使用場景：字串拼接、字串反轉
    概述：StringBuilder可以看成一個容器，建立之後裡面的內容是可變的。
    構造方法：
//呼叫無參構造
StringBuilder sb = new StringBuilder();

//呼叫有參構造
StringBuilder sb = new StringBuilder("abc");

內部方法：

以上內容參考
https://blog.csdn.net/weixin_54555405/article/details/141892992

2）陣列反轉問題：使用左右指標可以輕鬆解決

void reverseString(char[] s) {
    // 一左一右兩個指標相向而行
    int left = 0, right = s.length - 1;
    while (left < right) {
        // 交換 s[left] 和 s[right]
        char temp = s[left];
        s[left] = s[right];
        s[right] = temp;
        left++;
        right--;
    }
}

5. 最長迴文串(9.5）

1）判斷一個字串是否是迴文串，也可以用左右指標來對應位置比較，因為迴文串可以看作是軸對稱的字串，所以換個思路來遍歷：
思路1：left=0,right=s.length(),left++,right--向中心遍歷
思路2：找一箇中心位置，向兩端遍歷
那麼問題來了，軸對稱可以是關於中心一個元素，也可以是關於中心兩個元素，所以如果採取向兩端遍歷的搜尋方式，兩種軸對稱都要嘗試搜尋！
2）向中心遍歷：

boolean isPalindrome(String s) {
    // 一左一右兩個指標相向而行
    int left = 0, right = s.length() - 1;
    while (left < right) {
        if (s.charAt(left) != s.charAt(right)) {
            return false;
        }
        left++;
        right--;
    }
    return true;
}

3）向兩端遍歷：

// 在 s 中尋找以 s[l] 和 s[r] 為中心的最長迴文串
String palindrome(String s, int l, int r) {
    // 防止索引越界
    while (l >= 0 && r < s.length()
            && s.charAt(l) == s.charAt(r)) {
        // 雙指標，向兩邊展開
        l--; r++;
    }
    // 返回以 s[l] 和 s[r] 為中心的最長迴文串
    // 注意此處返回的子串邊界為[l+1,r)
    return s.substring(l + 1, r);
}

相關文章