Java编程刷题常用

最新推荐文章于 2024-05-19 16:52:56 发布

萌萌滴太阳

最新推荐文章于 2024-05-19 16:52:56 发布

阅读量1k

点赞数 2

分类专栏：剑指offer 文章标签： java

本文链接：https://blog.csdn.net/qq_42647047/article/details/117392082

版权

剑指offer 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

文章目录

String
堆
栈、队列、双端队列
集合
- LinkedList

String

String与基本数据类型转换

字符串转换成基本类型：
parseXxx(String s)：将字符串s解析成Xxx

String s1 = "123";
int num = Integer.parseInt(s1);
double num1 = Double.parseDouble(s1);

基本类型转换成字符串：
1、String.valueOf(num)：将num转换成字符串
2、使用 + ，和“” 拼接

String s1 = "123";
int num = 123;
String s2 = String.valueOf(num);
String s3 = num + "";

String与字符数组转换

String-----> 字符数组，toCharArray()

String s1 = "123";
char[] charArray = s1.toCharArray();

字符数组-----> String，String str = new String(char[])

char[] arr = {'1', '2', '3'};
String s2 = new String(arr);

compareTo字符串比较大小

compareTo比较数据的大小

int compareTo(String str)
//忽略大小写【不忽略时，小写大于大写】
int compareToIgnoreCase(String str)
int compareTo(object str)

通过使用上面的函数比较两个字符串，并返回一个int类型。

若字符串等于参数字符串、则返回0，
字符串小于参数字符串、则返回值小于0，
字符串大于参数字符串、返回值大于0。（ASCII码）

String a = "a";
String b = "b";
int res = a.compareTo(b)//res = 1 ,大于0

判断字符串大小的依据是根据他们在字典中的顺序决定的。

使用equals()

equals比较的是内容是否相等，但它只能判断相不相等，无法知道哪个大。
相等返回true或false

使用操作符==

比较的是引用的变量地址是否相等。
例如：
System.out.println(s1 == s2);
System.out.println(s2 == s3);
System.out.println(s3 == s4);

返回true 或false

StringBuilder/StringBuffer删除指定位置的字符

StringBuffer path = new StringBuffer();
path.deleteCharAt(path.length() - 1);

String.join()

字符串类型的集合或数组，使用String.join() 以某拼接符拼接到一起形成新的字符串。

List<String> list = new ArrayList<>();
list.add("Mxy");
list.add("String");
list.add("join");
String join = String.join("-",list);//传入String类型的List集合，使用"-"号拼接
System.out.println(join);

String[] s = new String[]{"Yuan","Mxy"};//传入String类型的数组，使用"-"号拼接
String join2 = String.join("-",s);
System.out.println(join2);

Mxy-StringUtils-join
Yuan-Mxy

s.contains()

s[r , s.length - 1]中是否包含子串s[l , r - 1]
str.substring(r).contains(str.substring(l, r))

位图

对于字符串的题目，常常用数组的下标表示字符a~z，eg：0–a , 1–b…

下标0--a , 1--b.....，num[i]一般是对应字符出现的次数等；
int[] num = new int[26];

split

对于'.'、'|'隔开的字符串，进行分割，需使用转义字符即：

a.split("\\.")
a.split("\\|")

其它，直接分割即可：(eg：，隔开)

a.split(",")

堆

Java 中提供了现成的类 PriorityQueue，默认是小根堆，实现大根堆需要重写一下比较器。PriorityQueue<Integer> pq = new PriorityQueue<>((v1 , v2) -> v2 - v1);

在这里插入图片描述

栈、队列、双端队列

参考

栈、队列、双端队列的具体方法

LinkedList实现了Deque和Queue接口，可以按照队列、栈和双端队列的方式进行操作，所以栈、队列、双端队列都用new LinkedList<>();创建

Queue<> q = new LinkedList<>();
Deque<> dq = new LinkedList<>();//双端队列和栈

之所以双端队列和栈都用Deque<> dq = new LinkedList<>();表示；
Java中有一个类Stack，用于表示栈，但这个类已经过时了。Java中没有单独的栈接口，栈相关方法包括在了表示双端队列的接口Deque中

队列

Queue<> q = new LinkedList<>();
q.add(i);
q.remove();
q.isEmpty();
q.peek();//返回队头元素
q.poll();//弹出队头，并返回队头元素；

双端队列

Deque<> q = new LinkedList<>();

q.addLast(i);
q.addFirst(i);
q.removeFirst();
q.removeLast();
q.isEmpty();
q.peekFirst();
q.peekLast();

栈

Deque<> stack = new LinkedList<>();
stack.peek();获取队头元素，如果队列为null将返回null。
stack.push(i);栈顶添加一个元素。
stack.pop(); 移除栈顶元素，返回移除的元素，如果栈没有元素抛出异常。

集合

LinkedList<int[]> 转换成int[][]

LinkedList<int[]> 转换成int[][]
面试题57 - II. 和为s的连续正数序列

class Solution {
    public int[][] findContinuousSequence(int target) {
        if(target < 3) return new int[0][0];
        LinkedList<int[]> res = new LinkedList<>();
        int i = 1 , j =2 , sum = 3;
        while(i < j){
            if(sum == target){
                int[] temp = new int[j - i + 1];
                for(int k = i ; k <= j ; k++){
                    temp[k - i] = k;
                }
                res.add(temp);
            }
            if(sum >= target){
                sum -= i;
                i++;
            }else{
                j++;
                sum += j;
            }
        }

        return res.toArray(new int[res.size()][]);

    }
}

集合初始化时添加元素

ArrayList的构造函数，即，可以添加Collection的实现类进行初始化
public ArrayList(Collection<? extends E> c){}

eg:
List<Integer> path = new ArrayList<>();
List<Integer> newPath = new ArrayList<>(path);

ArrayList<Integer> res = new ArrayList<Integer>(Arrays.asList(1, 2, 3);
eg：
要求返回List<List<Integer>>：
 List<List<Integer>> res = new ArrayList<>();
 res.add(new ArrayList<Integer>(Arrays.asList(nums[k], nums[i], nums[j])));

`HashMap`中`Entry`的使用

347. 前 K 个高频元素
类似于上道题215，上题是求 “数组中的第K个最大元素”，进而也可以求出前k大元素，这里求“出现频率前 k 高的元素” 若将各数字出现的频率形成数组，则和上题一样

参考

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        HashMap<Integer , Integer> map = new HashMap<>();
        for (int num : nums) {
            map.put(num, map.getOrDefault(num, 0) + 1);
        }

        PriorityQueue<int[]> pq = new PriorityQueue<>(new Comparator<int[]>() {
            public int compare(int[] a , int[] b){
                return a[1] -  b[1];
            }
        });

        for(Map.Entry<Integer , Integer> entry : map.entrySet()){
            int num = entry.getKey();
            int count = entry.getValue();
            if(pq.size() == k){
                if(count > pq.peek()[1]){
                    pq.poll();
                    pq.add(new int[]{num , count});
                }else continue;
            }else{
                pq.add(new int[]{num , count});
            }
        }
        int[] res = new int[k];
        int i = 0;
        for(int[] arry : pq){
            res[i++] = arry[0];
        }

        return res;
    }
}

List集合转数组

一、集合转数组的时候，集合提供了两种方法

1，toArray的不带参方法但是其返回值类型为Object

2，toArray的带参方法，在创建数组的时候指定数组的长度，最好与集合size保持一致，否则集合长度大于数组长度，原数组江北重置为null

在这里插入图片描述

Collections工具类

Collections和Array一样也有sort排序方法
在这里插入图片描述

Collections.sort(arr , (a , b) -> a[0]- b[0]);

多重数组集合创建

//外面一层是数组，用new创建了，里面是ArrayList<Integer>，声明了它，但还没创建，所以下面要创建；
ArrayList<Integer>[] adjacency = new ArrayList[n];

字符

字符转数字

两个字符相减，实际是两个字符的ASCII相减；

c的范围是：[0 , 9]:【'0'--0 , '1'--1...】
int x = c - '0';

c的范围是：[a , z]:【a--0 , b--1...】
int x = c - 'a';

c的范围是：[A , Z]:【A--0 , B--1...】
int x = c - 'A';

字符大小写转换

用包装类Character

Character.isLetter(c)//c是否是字母a~z||A~Z
Character.isDigit(c))//c是否是数字
Character.toUpperCase(c)
Character.toLowerCase(c)

用数字

(char)('a' - 32)--------A
(char)('A' + 32)--------a

(char)('a' ^ 32)--------A
(char)('A' ^ 32)--------a

Java中int ，long的最大值表示

Integer.MAX_VALUE
Integer.MIN_VALUE

Long.MAX_VALUE
Long.MIN_VALUE

PriorityQueue & Arrays.sort中比较器的重写

两个一样

//按数组0号下标元素，升序排序
Arrays.sort(num, new Comparator<int[]>() {
            public int compare(int[] person1, int[] person2) {
            return person1[0] - person2[0];
            }
        });
new PriorityQueue<>(new Comparator<int[]>() {
            public int compare(int[] person1, int[] person2) {
                return person1[0] - person2[0];
            }
        });
        
//lambda表达式
Arrays.sort(num, (v1 , v2) -> v1[0] - v2[0]);
new PriorityQueue<>((v1 , v2) -> v1[0] - v2[0]);

比较器重写（在一个字段排序的基础上再排序）

例题：【NC97 字符串出现次数的TopK问题】https://blog.nowcoder.net/n/4a41d180b3774cedbddd33d49b3bd756?f=comment

class MyCompare implements Comparator<Map.Entry<String  , Integer>>{
    public int compare(Map.Entry<String  , Integer> a , Map.Entry<String  , Integer> b){
        if(a.getValue().equals(b.getValue())) return b.getKey().compareTo(a.getKey());
        else return a.getValue() - b.getValue();
    }
}

写好的比较器可以直接放在优先队列里PriorityQueue<Map.Entry<String , Integer>> pq = new PriorityQueue<>(myCompare);

数组

数组的初始化

int[] num = new int[]{1,2,3};
or
int[] dp = new int[n];
//所有值初始化为-1
Arrays.fill(dp, -1);

数组复制

深拷贝

int[] arr = new int[nums.length];
arr= nums.clone();

int[] arr = nums;

浅拷贝

while

1、while循环后没有循环体，后面要加分号；
while(i < j );
2、while循环后有循环体（即使是空循环体），后面不加分号；
while(i < j){}

求绝对值

舍掉小数取整:Math.floor(3.5)=3
四舍五入取整:Math.rint(3.5)=4
进位取整:Math.ceil(3.1)=4 
取绝对值：Math.abs(-3.5)=3.5
取余数：A%B = 余数

Random()

参考：https://blog.csdn.net/weixin_41050155/article/details/79814304?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522163305775216780264051582%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=163305775216780264051582&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2_allsobaiduend~default-1-79814304.first_rank_v2_pc_rank_v29&utm_term=java%E4%B8%ADrandom%E5%87%BD%E6%95%B0%E7%94%A8%E6%B3%95&spm=1018.2226.3001.4187

java中存在两个随机函数，它们分别来自java.long.Math.random()和 java.util.Random();其中前者的适用范围比较小，完全可以被后者取代。

在这里插入图片描述

dfs()里的返回类型传导问题

例子：面试题55 - II. 平衡二叉树
参考：https://blog.csdn.net/qq_42647047/article/details/111303308

public class Solution {
    public boolean IsBalanced_Solution(TreeNode root) {
        int depth = dfs(root);
        return depth == -1 ? false : true;
    }
    //当返回的不是void时，需要注意返回类型的传导问题，比如返回的是boolean类型时，
    //一个地方返回true，但在传导的时候可能碰到false，而导致结果变成false；
    //可以像下面一样，在一个dfs(root.left)后，判断一下，如果符合条件，直接返回对应的值，否则，再继续下面的步骤；
    int dfs(TreeNode root){
        if(root == null) return 0;
        int leftDepth = dfs(root.left);
        if(leftDepth == -1) return -1;
        int rigthDepth = dfs(root.right);
        if(rigthDepth == -1) return -1;
        if(Math.abs(leftDepth - rigthDepth) <=1) return Math.max(leftDepth , rigthDepth) + 1;
        else return -1;
    }
}

萌萌滴太阳

关注

2
点赞
踩
18

收藏

觉得还不错? 一键收藏
0
评论
Java编程刷题常用

类型变换数据结构堆Java 中提供了现成的类 PriorityQueue，默认是小根堆，实现大根堆需要重写一下比较器。PriorityQueue<Integer> pq = new PriorityQueue<>((v1 , v2) -> v2 - v1);
复制链接

扫一扫