Leetcode刷题、常用算法汇总(Java版本)，腾讯T3大牛总结

最新推荐文章于 2024-04-21 02:31:49 发布
最新推荐文章于 2024-04-21 02:31:49 发布
阅读量985 收藏 17
点赞数 20
分类专栏： 2024年程序员学习 文章标签： 算法 leetcode java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84006562/article/details/137318889
版权

String limit = sc.nextLine();

int row = Integer.parseInt(limit.split(" ")[0]);

int column = Integer.parseInt(limit.split(" ")[1]);

int[][] matrix = new int[row][column];

for (int i = 0; i < row; i++) {

String[] lineArr = sc.nextLine().split(" ");

int[] lintIntArr = new int[lineArr.length];

for (int j = 0; j < lineArr.length; j++) {

lintIntArr[j] = Integer.parseInt(lineArr[j]);

}

matrix[i] = lintIntArr;

}

for (int[] i : matrix) {

System.out.println(Arrays.toString(i));

}

int[][] result = new int[column][row];

result = transpose(matrix);

for (int[] i : result) {

System.out.println(Arrays.toString(i));

}

}

public static int[][] transpose1(int[][] matrix) {

int m = matrix.length, n = matrix[0].length;

int[][] transposed = new int[n][m];

for (int i = 0; i < m; i++) {

for (int j = 0; j < n; j++) {

transposed[j][i] = matrix[i][j];

}

}

return transposed;

}

public static int[][] transpose(int[][] matrix) {

int row = matrix.length, column = matrix[0].length;

int[][] res = new int[column][row];

for (int i = 0; i < row * column; i++) {

res[i / row][i % row] = matrix[i % row][i / row];

}

return res;

}

}

✔螺旋矩阵 II

===================================================================

① 题目

在这里插入图片描述

② 思路

  1. 模拟法，设定边界

在这里插入图片描述

③ 代码

package dataStructure.Array;

import java.util.Scanner;

/**

  • leetCode 59. 螺旋矩阵 II

*/

public class generateMatrix {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

int n = scanner.nextInt();

int[][] result = generateMatrixDemo(n);

for (int[] r : result) {

for (int j : r) {

System.out.printf("%d ", j);

}

System.out.println();

}

}

public static int[][] generateMatrixDemo(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++; // left to right.

t++;

for (int i = t; i <= b; i++) mat[i][r] = num++; // top to bottom.

r–;

for (int i = r; i >= l; i–) mat[b][i] = num++; // right to left.

b–;

for (int i = b; i >= t; i–) mat[i][l] = num++; // bottom to top.

l++;

}

return mat;

}

}

✔子数组最大平均数 I

======================================================================

① 题目

在这里插入图片描述

② 思路

  1. 滑动窗口：在数组中不断右滑，寻找第i到i+k个元素之和最大的窗口。滑动窗口参考

  2. preSum方法：preSum方法

③ 代码

package algorithm;

import java.lang.reflect.Array;

import java.util.Arrays;

import java.util.Scanner;

/*

  • leetcode 643. 子数组最大平均数 I

  • 给定 n 个整数，找出平均数最大且长度为 k 的连续子数组，并输出该最大平均数。

  • */

public class findMaxAverage {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

String[] nums = scanner.nextLine().split(" ");

int[] numsArr = new int[nums.length];

for (int i = 0; i < nums.length; i++) {

numsArr[i] = Integer.parseInt(nums[i]);

}

int k = scanner.nextInt();

System.out.println(findMaxAverageDemo2(numsArr, k));

}

public static double findMaxAverageDemo2(int[] nums, int k) {

int[] preSum = new int[nums.length + 1];

int sum = 0;

for (int i = 0; i < k; i++) {

sum += nums[i];

}

for (int i = 1; i < nums.length + 1; i++) {

preSum[i] = preSum[i - 1] + nums[i - 1];

if (i >= k) {

int currentSum = preSum[i] - preSum[i - k];

if (currentSum > sum) sum = currentSum;

}

}

return 1.0 * sum / k;

}

}

✔公平的糖果棒交换

====================================================================

① 题目

在这里插入图片描述

② 思路

  1. 方法一：暴力双层for循环 超时

  2. 方法二：哈希表。时间复杂度：O(n + m)O(n+m)，其中 nn 是序列 AA 的长度，mm 是序列 BB 的长度。空间复杂度：O(n)O(n)，其中 nn 是序列 AA 的长度。我们需要建立一个和序列 AA 等大的哈希表。

在这里插入图片描述

  1. 方法三：双指针。要求数组有序。在这里插入图片描述

③ 代码

package algorithm;

import java.util.Arrays;

import java.util.HashSet;

import java.util.Scanner;

import java.util.Set;

public class fairCandySwap {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

String[] aNums = scanner.nextLine().split(" ");

String[] bNums = scanner.nextLine().split(" ");

int[] aArray = new int[aNums.length];

int[] bArray = new int[bNums.length];

for (int i = 0; i < aNums.length; i++) aArray[i] = Integer.parseInt(aNums[i]);

for (int i = 0; i < bNums.length; i++) bArray[i] = Integer.parseInt(bNums[i]);

int[] result = fairCandySwapDemo3(aArray, bArray);

System.out.println(Arrays.toString(result));

}

public static int[] fairCandySwapDemo1(int[] A, int[] B) {

for (int i = 0; i < A.length; i++) {

for (int j = 0; j < B.length; j++) {

int tempA = A[i];

int tempB = B[j];

A[i] = tempB;

B[j] = tempA;

if (arraySum(A) == arraySum(B)) {

return new int[]{tempA, tempB};

}

A[i] = tempA;

B[j] = tempB;

}

}

return new int[]{0, 0};

}

public static int[] fairCandySwapDemo2(int[] A, int[] B) {

int sumA = Arrays.stream(A).sum();

int sumB = Arrays.stream(B).sum();

int delta = (sumA - sumB) / 2;

Set rec = new HashSet<>();

for (int a : A) rec.add(a);

for (int y : B) {

int x = y + delta;

if (rec.contains(x)) {

return new int[]{x, y};

}

}

return new int[]{0, 0};

}

public static int[] fairCandySwapDemo3(int[] A, int[] B) {

Arrays.sort(A);

Arrays.sort(B);

int sum = (Arrays.stream(A).sum() - Arrays.stream(B).sum()) / 2;

int x = 0, y = 0;

while (x < A.length && y < B.length) {

if (A[x] - B[y] == sum) {

return new int[]{A[x], B[y]};

} else if (A[x] - B[y] > sum) {

++y;

} else {

++x;

}

}

return new int[]{0, 0};

}

public static int arraySum(int[] array) {

int sum = 0;

for (int i : array) {

sum += i;

}

return sum;

}

}

✔两数之和、三数之和

=====================================================================

参考：漫画算法题：两数之和与三数之和

这里考虑的两数之和、三数之和答案结果都是唯一的，因此返回的为int数组，如果结果不唯一，则需要返回List。

两数之和

① 题目

在这里插入图片描述

② 思路

  1. 方法一：暴力法双层for循环 O(n2)

  2. 方法二：哈希表 两次循环 第一次循环添加哈希表数据 第二次循环查询结果 O(n)

  3. 方法三：哈希表 一次循环 在第一次插入数据之前先判断有没有满足结果的，有的话返回，没有的话再插入数据 O(n)

③ 代码

package dataStructure.Array;

import java.util.*;

public class twoSum {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

String[] nums = scanner.nextLine().split(" ");

int[] numArr = new int[nums.length];

for (int i = 0; i < nums.length; i++) {

numArr[i] = Integer.parseInt(nums[i]);

}

int target = scanner.nextInt();

int[] resultArr = twoSumDemo1(numArr, target);

System.out.println(Arrays.toString(resultArr));

}

public static int[] twoSumDemo1(int[] nums, int target) {

for (int i = 0; i < nums.length; i++) {

for (int j = i + 1; j < nums.length; j++) {

if (nums[i] + nums[j] == target) {

return new int[]{i, j};

}

}

}

return new int[]{0, 0};

}

public static int[] twoSumDemo2(int[] nums, int target) {

Map<Integer, Integer> map = new HashMap<>();

for (int i = 1; i < nums.length; i++) {

map.put(nums[i], i);

}

for (int i = 0; i < nums.length; i++) {

int other = target - nums[i];

if (map.containsKey(other) && map.get(other) != i) {

return new int[]{i, map.get(other)};

}

}

return new int[]{0, 0};

}

public static int[] twoSumDemo3(int[] nums, int target) {

Map<Integer, Integer> map = new HashMap<>();

for (int i = 0; i < nums.length; i++) {

int other = target - nums[i];

if (map.containsKey(other)) {

return new int[]{i, map.get(other)};

}

map.put(nums[i], i);

}

return new int[]{0, 0};

}

}

三数之和

① 题目

求数组中三个数之和等于某数

② 思路

  1. 方法一：外层一层for循环，内层使用两数之和的方法进行求解。时间复杂度：O(n2)。空间复杂度：O(n)。

  2. 方法二：首先数组排序，外层仍然为一层for循环，for循环内容，采用"夹逼法"，左右两侧双指针，判断外层循环当前数组值与两个指针值的和与target的关系，从而进行指针的移动，最终求的结果。

③ 代码

package dataStructure.Array;

import java.util.Arrays;

import java.util.HashMap;

import java.util.Map;

import java.util.Scanner;

public class threeSum {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

String[] nums = scanner.nextLine().split(" ");

int[] numsArr = new int[nums.length];

for (int i = 0; i < nums.length; i++) {

numsArr[i] = Integer.parseInt(nums[i]);

}

int target = scanner.nextInt();

int[] result = threeSumDemo2(numsArr, target);

System.out.println(Arrays.toString(result));

}

public static int[] threeSumDemo1(int[] nums, int target) {

for (int i = 0; i < nums.length; i++) {

Map<Integer, Integer> map = new HashMap<>();

int d1 = target - nums[i];

// 寻找两数之和等于d1的组合

for (int j = i + 1; j < nums.length; j++) {

int d2 = d1 - nums[j];

if (map.containsKey(d2)) {

return new int[]{i, j, map.get(d2)};

}

map.put(nums[j], j);

}

}

return new int[]{0, 0, 0};

}

public static int[] threeSumDemo2(int[] nums, int target) {

Arrays.sort(nums);

for (int i = 0; i < nums.length; i++) {

int d = target - nums[i];

// j和k双指针循环定位,j在左端,k在右端

for (int j = i + 1, k = nums.length - 1; j < nums.length; j++) {

// k指针向左移动

while (j < k && (nums[j] + nums[k]) > d) {

k–;

}

// 如果指针重合，跳出本次循环

if (j == k) break;

if (nums[j] + nums[k] == d) {

return new int[]{i, j, k};

}

}

}

return new int[]{0, 0, 0};

}

}

✔ln(N!)

==================================================================

① 题目

编写一个递归的静态方法计算ln(N!)的值

② 思路

ln(N!) = ln(N) + ln(N-1) + ln(N-2) + ······ + ln(3) + ln(2) + ln(1)

③ 代码

package algorithm;

public class lgN {

public static void main(String[] args) {

System.out.println(lgNDemo(10));

}

public static double lgNDemo(int n) {

if (n == 1 || n == 0) return 0.0;

return Math.log(n) + lgNDemo(n - 1);

}

}

✔返回数组中每个元素出现的次数

==========================================================================

① 题目

编写一个静态方法histogram(),接受一个整型数组a[]和一个整数M为参数并返回一个大小为M的数组，其中第i个元素的值为整数i在参数数组中出现的次数。如果a[]中的值均在0-M-1之间，返回数组中所有元素之和应该等于a.length

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
img
img
img
img
img
img

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024b （备注Java）
img

结局：总结+分享

看完美团、字节、腾讯这三家的一二三面试问题，是不是感觉问的特别多，可能咱们真的又得开启面试造火箭、工作拧螺丝的模式去准备下一次的面试了。

开篇有提及我可是足足背下了Java互联网工程师面试1000题，多少还是有点用的呢，换汤不换药，不管面试官怎么问你，抓住本质即可！能读到此处的都是真爱

  • Java互联网工程师面试1000题

image.png

而且从上面三家来看，算法与数据结构是必备不可少的呀，因此我建议大家可以去刷刷这本左程云大佬著作的 《程序员代码面试指南 IT名企算法与数据结构题目最优解》，里面近200道真实出现过的经典代码面试题。

  • 程序员代码面试指南–IT名企算法与数据结构题目最优解

image.png

  • 其余像设计模式，建议可以看看下面这4份PDF（已经整理）

image.png

  • 更多的Java面试学习笔记如下，关于面试这一块，我额外细分出Java基础-中级-高级开发的面试+解析，以及调优笔记等等等。。。

image.png

以上所提及的全部Java面试学习的PDF及笔记，如若皆是你所需要的，那么都可发送给你！

img-Sdkt7imq-1712095870993)]
[外链图片转存中…(img-Tsk8hq6P-1712095870994)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-VW6Ocgba-1712095870994)]

结局：总结+分享

看完美团、字节、腾讯这三家的一二三面试问题，是不是感觉问的特别多，可能咱们真的又得开启面试造火箭、工作拧螺丝的模式去准备下一次的面试了。

开篇有提及我可是足足背下了Java互联网工程师面试1000题，多少还是有点用的呢，换汤不换药，不管面试官怎么问你，抓住本质即可！能读到此处的都是真爱

  • Java互联网工程师面试1000题

[外链图片转存中…(img-pGKc1nWm-1712095870995)]

而且从上面三家来看，算法与数据结构是必备不可少的呀，因此我建议大家可以去刷刷这本左程云大佬著作的 《程序员代码面试指南 IT名企算法与数据结构题目最优解》，里面近200道真实出现过的经典代码面试题。

  • 程序员代码面试指南–IT名企算法与数据结构题目最优解

[外链图片转存中…(img-sun57jUA-1712095870995)]

  • 其余像设计模式，建议可以看看下面这4份PDF（已经整理）

[外链图片转存中…(img-lKcgpAmp-1712095870995)]

  • 更多的Java面试学习笔记如下，关于面试这一块，我额外细分出Java基础-中级-高级开发的面试+解析，以及调优笔记等等等。。。

[外链图片转存中…(img-yEmMDk9Y-1712095870996)]

以上所提及的全部Java面试学习的PDF及笔记，如若皆是你所需要的，那么都可发送给你！

2401_84006562
关注
  • 20
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java算法刷题带注释Leetcode
06-19
Java算法刷题带注释Leetcode，基础算法
algorithm-learning:leetcode刷题（Java，Python）和算法书籍
03-18
《algorithm-learning: leetcode刷题（Java，Python）和算法书籍》这个压缩包文件主要包含的是关于算法学习的资源，特别是针对LeetCode平台上的题目进行的编程实践，涉及的编程语言主要是Java和Python。LeetCode是一...
LeetCode算法：0~99道
qq_43265673的博客
02-24 377
冒泡排序 定义一个布尔变量 hasChange，用来标记每轮是否进行了交换。在每轮遍历开始时，将 hasChange 设置为 false。 若当轮没有发生交换，说明此时数组已经按照升序排列，hashChange 依然是为 false。此时外层循环直接退出，排序结束。 代码示例 Java import java.util.Arrays; public class BubbleSort { private static void bubbleSort(int[] nums) { b
leetcode1082(1)，2024年最新java商城项目面试问题及答案
最新发布
2401_84434420的博客
04-21 751
Java面试核心知识点一共有30个专题，足够读者朋友们应付面试啦，也节省朋友们去到处搜刮资料自己整理的时间！Java面试核心知识点网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）一个人可以走的很快，但一群人才能走的更远！
LeetCode刷题（JAVA语言）
LK-330的博客
03-29 250
LeetCode刷题Day1 Java语言编写 public class number_sum_1 { /* * 给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 的那 两个 整数，并返回它们的数组下标。 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。 你可以按任意顺序返回答案。 * */ public static void main(String[] args) { int[] number_1={1,
LeetCode 刷题【Java常用API与数据结构总结】（持续更新……）
qq_51395785的博客
02-04 998
在使用Java刷题中对相关基础知识及用法的回顾和补充。
LeetCode刷题笔记-JAVA
weianluo的博客
11-02 537
非科班艰难的刷题之路，目前刷到200题，本文记录技巧性较高的题目。 Round 1 713. 乘积小于K的子数组 给定一个正整数数组nums。 找出该数组内乘积小于k的连续的子数组的个数。 示例 1: 输入: nums = [10,5,2,6], k = 100 输出: 8 解释: 8个乘积小于100的子数组分别为: [10], [5], [2], [6], [10,5], [...
LeetCode刷题笔记（Java）---第1-18题
gongsenlin341的博客
03-03 1520
文章目录两数之和两数相加无重复字符串的最长子串寻找两个有序数组的中位数 两数之和 给定一个整数数组nums和一个目标值target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。 你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。 示例: 解答： private static int[] twoSum(int[] nums, int target...
基于java的leetcode刷题与复习指南算法模板代码
03-20
总之，这个基于Java的LeetCode刷题与复习指南算法模板代码集合，不仅包含了各种算法的实践案例，还强调了Java在解决实际问题中的优势，是Java开发者提升技能、备战面试的宝贵资源。通过系统地学习和练习，你可以不断...
LeetCode刷题题解-Java版本
05-18
在编程领域，LeetCode 是一个非常受欢迎的在线平台，它提供了大量的算法题目供程序员练习和提升技能。本文将详细解析三个使用 Java 实现的 LeetCode 题目的解法，主要涉及双指针技巧的应用。 1. **有序数组的 Two ...
LeetCode 刷题笔记 with Java.zip
11-23
《LeetCode刷题笔记withJava》是一份专为Java开发者准备的算法实战指南，涵盖了LeetCode网站上前一百道编程挑战题目。这份资料旨在帮助程序员提升算法能力，掌握数据结构和问题解决技巧，对于准备面试或者想要提升...
leetcode刷题列表
01-17
leetcode， fb刷题列表，包含难易程度 适用于2018，2019
Java算法集题大全.zip
05-29
Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全
Leetcode刷题手册 labuladong的算法小抄官方完整版（共 560 页）
06-19
算法 Leetcode刷题手册 labuladong的算法小抄官方完整版
leetcode 刷题记录(java)-持续更新
diemi9167的博客
09-25 916
感觉说的挺好的，值得学习 1 版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。 2 本文链接：https://blog.csdn.net/liujiaqi12345/article/details/88357041 3 Leetcode JAVA 题解： https://github.com/mJack...
LeetCode 刷题记录（5,6,7）—Java语言
Traveler
05-07 409
5. 最长回文子串 给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为1000。 示例 1： 输入: “babad” 输出: “bab” 注意: “aba”也是一个有效答案。 示例 2： 输入: “cbbd” 输出: “bb” 思路 这道题最直接的解法就是中心扩散法，即从每个字符或者每个两个字符间开始判断左右两边是否相等，不过时间复杂度太高，最适合的还...
LeetCode 刷题记录（8,9,10）—Java语言
Traveler
05-08 1127
8. 字符串转整数 (atoi) 题目 实现 atoi，将字符串转为整数。 在找到第一个非空字符之前，需要移除掉字符串中的空格字符。如果第一个非空字符是正号或负号，选取该符号，并将其与后面尽可能多的连续的数字组合起来，这部分字符即为整数的值。如果第一个非空字符是数字，则直接将其与之后连续的数字字符组合起来，形成整数。 字符串可以在形成整数的字符后面包括多余的字符，这些字符可以被忽略，它...
LeetCode 刷题记录（15）—Java语言
Traveler
05-11 663
15. 三数之和 题目 给定一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？找出所有满足条件且不重复的三元组。 注意：答案中不可以包含重复的三元组。 例如, 给定数组 nums = [-1, 0, 1, 2, -1, -4]， 满足要求的三元组集合为： [ [-1, 0, 1], [-1, -1, ...
LeetCode Java面试刷题笔记汇总
终生学习践行者
01-19 2348
LeetCode Java刷题笔记汇总，按照类型刷题效率更高。
leetcode刷题java 常用函数
01-11
以下是一些常用的函数和数据结构在LeetCode刷题中的应用示例： 1. 栈（Stack）：栈是一种后进先出（LIFO）的数据结构，常用于解决与括号匹配、逆波兰表达式等问题。 ```java import java.util.Stack; Stack<Integer> stack = new Stack<>(); stack.push(1); // 入栈 stack.push(2); stack.push(3); int top = stack.peek(); // 获取栈顶元素，但不删除 int pop = stack.pop(); // 弹出栈顶元素 boolean isEmpty = stack.isEmpty(); // 判断栈是否为空 ``` 2. 队列（Queue）：队列是一种先进先出（FIFO）的数据结构，常用于解决与广度优先搜索（BFS）相关的问题。 ```java import java.util.Queue; import java.util.LinkedList; Queue<Integer> queue = new LinkedList<>(); queue.offer(1); // 入队 queue.offer(2); queue.offer(3); int front = queue.peek(); // 获取队首元素，但不删除 int poll = queue.poll(); // 弹出队首元素 boolean isEmpty = queue.isEmpty(); // 判断队列是否为空 ``` 3. 堆（Heap）：堆是一种特殊的树形数据结构，常用于解决与优先队列相关的问题。 ```java import java.util.PriorityQueue; PriorityQueue<Integer> minHeap = new PriorityQueue<>(); // 小顶堆 minHeap.offer(3); // 入堆 minHeap.offer(1); minHeap.offer(2); int min = minHeap.peek(); // 获取堆顶元素，但不删除 int pollMin = minHeap.poll(); // 弹出堆顶元素 boolean isEmpty = minHeap.isEmpty(); // 判断堆是否为空 ``` 4. 位运算（Bit Manipulation）：位运算是对二进制数进行操作的技术，常用于解决与位操作相关的问题，如位与、位或、位异或等。 ```java int a = 5; // 二进制表示为 101 int b = 3; // 二进制表示为 011 int andResult = a & b; // 位与运算，结果为 001，即 1 int orResult = a | b; // 位或运算，结果为 111，即 7 int xorResult = a ^ b; // 位异或运算，结果为 110，即 6 int complement = ~a; // 取反运算，结果为 11111111111111111111111111111010，即 -6 int leftShift = a << 1; // 左移运算，结果为 1010，即 10 int rightShift = a >> 1; // 右移运算，结果为 10，即 2 ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值