Leetcode 相关知识点 day1

SavcheNz

已于 2022-09-18 17:22:39 修改

阅读量218

点赞数

分类专栏： leetcode 数据结构与算法文章标签： leetcode java 算法

于 2022-09-14 22:10:32 首次发布

本文链接：https://blog.csdn.net/qq_40783389/article/details/126857436

版权

leetcode 同时被 2 个专栏收录

7 篇文章 0 订阅

订阅专栏

数据结构与算法

6 篇文章 0 订阅

订阅专栏

这篇博客探讨了Java中字符串和字符数组的转换，使用Arrays.sort()方法对字符串排序。此外，还介绍了如何用回溯法解决LeetCode上的单词搜索II问题，优化搜索效率。同时，讲解了Trie数据结构的实现，用于快速查找和插入字符串。最后，提到了StringBuilder的常用方法及其在字符串操作中的应用。

摘要由CSDN通过智能技术生成

Leetcode

/用于作者每日有需所作笔记/

1.字符串和字符数组之间的转换

我们可以使用 Array.sort() 方法对 Java 中的单个字符串进行排序。字符串类没有排序方法。在对字符串进行排序时，主要的思路是使用 toCharArray() 方法将给定的字符串转换为一个字符数组。然后，我们使用 Arrays.sort() 方法对该数组进行排序。

  `import java.util.Arrays;

public class StringSorting
{  
    public static void main(String args[])
    {  
        String STR = "java"; 
        char[] StringtoChar = STR.toCharArray();
        Arrays.sort(StringtoChar);
        String SortedString = new String(StringtoChar);
        System.out.println("The Unsorted String is : " + STR); 
        System.out.println("The Sorted String is : " + SortedString);  
    }  
}`

The Unsorted String is : java
The Sorted String is : aajv

2.单词搜索 II

回溯法思路：
第一部分代码思路是先遍历每个单词，然后将每个单词提出，去表格中进行搜索。
依次取单词的每个字母，在表格中暴力搜索。搜索过程采用回溯法。当但是表较大时，任意造成超时。因此演变第二种方法。

class Solution {
    int n;     //n 行
    int m;     //m 列
    char[][] board;
    boolean[][] visited;

    public List<String> findWords(char[][] board, String[] words) {
        this.n = board.length;
        this.m = board[0].length;
        this.visited = new boolean[n][m];
        this.board = board;

        List<String> result = new ArrayList<>();
        for(int i = 0; i < words.length; i++){
            if( exist(board,words[i])){
                result.add(words[i]);
            }
        }
        return result;
    }

    public boolean exist(char[][] board, String word){
        int w = word.length();
        char[] letter = word.toCharArray();
        for(int i = 0 ; i < n; i++){
            for(int j = 0; j < m; j++){
                boolean res = search(i,j,0,letter,w);
                if(res){
                    return true;
                }
            }
        }
        return false;
    }

    public boolean search(int i, int j, int index, char[] letter, int w){
        if(index >= w){
            return true;
        }
        if(i<0 || i >=n || j<0 || j>=m || visited[i][j] || letter[index]!=board[i][j]){
            return false;
        }
        visited[i][j] = true;
        boolean res = search(i+1,j,index+1,letter,w) || search(i,j+1,index+1,letter,w) 
            ||search(i-1,j,index+1,letter,w) || search(i,j-1,index+1,letter,w);
        visited[i][j] = false;
        return res;

    }

}

第二种方法，与第一个方法类似，也是采用回溯法。但是不同的是，出发点在于表格。首先将单词表因此塞进set 中，其次遍历表格每个字母，每次循环下在依次加一个字母，并且与set进行比较，若此循环下的单词是我们想要的就说明可以拼凑出这个单词，便将此单词假如res结果list中，并从set中将单词删除，以免重复而浪费时间。注意文中说明单词长度不超过10，依次回溯法的结束判断就是搜寻长度大于十或者搜寻无路可走。

class Solution {

    Set<String> set = new HashSet<>();
    List<String> ans = new ArrayList<>();
    char[][] board;
    int m;
    int n;
    boolean[][] visited;

    public List<String> findWords(char[][] board, String[] words) {
        this.m = board.length;
        this.n = board[0].length;
        this.visited = new boolean[m][n];
        this.board = board;

        for (String w : words){
            set.add(w);
        }
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++){
                visited[i][j] = true;
                sb.append(board[i][j]);
                dfs(i,j,sb);
                visited[i][j] = false;
                sb.deleteCharAt(sb.length()-1);
            }
        }
        return ans;
    }

    void dfs(int i, int j, StringBuilder sb){
        if (sb.length() > 10){
            return;
        }
        if(set.contains(sb.toString())){
            ans.add(sb.toString());
            set.remove(sb.toString());
        }
/*四个方向的搜寻算法有两种写法*/
/*********************方法一****************************************/
        if(i+1>=0 && i+1< m && !visited[i+1][j]){
            visited[i+1][j] = true;
            sb.append(board[i+1][j]);
            dfs(i+1,j,sb);
            visited[i+1][j] = false;
            sb.deleteCharAt(sb.length() - 1);
        }
        if(i-1>=0 && i-1< m && !visited[i-1][j]){
            visited[i-1][j] = true;
            sb.append(board[i-1][j]);
            dfs(i-1,j,sb);
            visited[i-1][j] = false;
            sb.deleteCharAt(sb.length() - 1);
        }
        if(j+1>=0 && j+1< n && !visited[i][j+1]){
            visited[i][j+1] = true;
            sb.append(board[i][j+1]);
            dfs(i,j+1,sb);
            visited[i][j+1] = false;
            sb.deleteCharAt(sb.length() - 1);
        }
        if(j-1>=0 && j-1< n && !visited[i][j-1]){
            visited[i][j-1] = true;
            sb.append(board[i][j-1]);
            dfs(i,j-1,sb);
            visited[i][j-1] = false;
            sb.deleteCharAt(sb.length() - 1);
        }
/*****************方法二******************************************/
		int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};
        for (int[] d : dirs) {
            int dx = i + d[0], dy = j + d[1];
            if (dx < 0 || dx >= m || dy < 0 || dy >= n) continue;
            if (visited[dx][dy]) continue;
            visited[dx][dy] = true;
            sb.append(board[dx][dy]);
            dfs(dx, dy, sb);
            visited[dx][dy] = false;
            sb.deleteCharAt(sb.length() - 1);
        }
/*************************************************************/
    }
}

注意： 回溯法，回溯后需要回滚！
如sb.deleteCharAt(sb.length() - 1); 和 visited[i-1][j] = false;

3.实现 Trie (前缀树)

在这里插入图片描述

class Trie {

    class TrieNode{
        boolean isword = false;
        TrieNode[] children=new TrieNode[26];

    }

    TrieNode root;

    public Trie() {
        root = new TrieNode();
    }
    
    public void insert(String word) {
        TrieNode curr = root;
        for (int i = 0; i< word.length();i++){
            char c = word.charAt(i);
            int index = c - 'a';
            if(curr.children[index]==null){
                curr.children[index] = new TrieNode();

            }
            curr = curr.children[index];
        }
        curr.isword =true;
    }
    
    public boolean search(String word) {
        TrieNode curr = root;
        for (int i = 0; i< word.length();i++){
            char c = word.charAt(i);
            int index = c - 'a';
            if(curr.children[index]==null){
                return false;

            }
            curr = curr.children[index];
        }
        return curr.isword;
    }
    
    public boolean startsWith(String prefix) {
        TrieNode curr = root;
        for (int i = 0; i< prefix.length();i++){
            char c = prefix.charAt(i);
            int index = c - 'a';
            if(curr.children[index]==null){
                return false;

            }
            curr = curr.children[index];
        }
        return true;
    }
}

/**
 * Your Trie object will be instantiated and called as such:
 * Trie obj = new Trie();
 * obj.insert(word);
 * boolean param_2 = obj.search(word);
 * boolean param_3 = obj.startsWith(prefix);
 */

4.StringBuilder常用方法

StringBuilder sb = new StringBuilder();
// 对象名.length() 序列长度
System.out.println(sb.length());  // 0
// 对象名.append() 追加到序列
sb.append("hello");
System.out.println(sb);  // hello
// 97代表的是是'a'
sb.appendCodePoint(97);
System.out.println(sb);  // helloa
// 链式编程
sb.append(1).append("world").append(2);
System.out.println(sb);  // helloa1world2
// 索引是5的位置替换成空格
sb.setCharAt(5, ' ');
System.out.println(sb);  // hello 1world2
// 指定位置0前插入0
sb.insert(0, 0);
System.out.println(sb);  // 0hello 1world2
// 删除索引6(包含)至索引14(不包含)的字符串
sb.delete(6, 14);
System.out.println(sb);  // 0hello
// StringBuilder类型转换成String类型
String s = sb.toString();
System.out.println(s);  // 0hello

// 以及还有截取、反转、替换等方法



**StringBuilder和String相互转换**

// string转换成StringBuilder
String str = "hello";
StringBuilder sb = new StringBuilder(str);
System.out.println(sb);  // hello
// StringBuilder转换成String
String s = sb.toString();
System.out.println(s);  // hello

***字符串取出***
s.substring(begin，end)
包含begin，不包含end

求字符串中的字符
String word;
char c = word.charAt(i);
int index = c - 'a';

5.Java中Map的getOrDefault()方法

    Map<Integer,Integer> map = new HashMap<>();
    map.put(1,11);
    
    // 存在Key1，返回11
    System.out.println(map.getOrDefault(1,22));
    // 不存在Key3，返回默认值33
    System.out.println(map.getOrDefault(3,33));

	//输出
	11
	33

*## 找字符串中只出现一次的字母*

class Solution {
    public int firstUniqChar(String s) {
        Map<Character, Integer> frequency = new HashMap<Character, Integer>();
        for (int i = 0; i < s.length(); ++i) {
            char ch = s.charAt(i);
            frequency.put(ch, frequency.getOrDefault(ch, 0) + 1);
        }
        for (int i = 0; i < s.length(); ++i) {
            if (frequency.get(s.charAt(i)) == 1) {
                return i;
            }
        }
        return -1;
    }
}