蓝桥杯Java大学C组知识点复习资料
1. 枚举 [1-3]
例题：找出1~n中的所有质数
题目描述：输入整数n，输出所有小于等于n的质数。
输入输出示例：
代码实现：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| public class PrimeNumbers {
public static void main(String[] args) {
int n = 10;
for (int i = 2; i <= n; i++) {
boolean isPrime = true;
for (int j = 2; j * j <= i; j++) {
if (i % j == 0) {
isPrime = false;
break;
}
}
if (isPrime) System.out.print(i + " ");
}
}
}
|
解析：通过双重循环枚举每个数，判断是否为质数。外层循环遍历所有候选数，内层循环检查是否有因数。
2. 排序
(1) 冒泡排序 [2]
例题：对数组 [5,3,8,4,2] 进行升序排序
输入输出示例：
1
2
| 输入：5 3 8 4 2
输出：2 3 4 5 8
|
代码实现：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| public class BubbleSort {
public static void main(String[] args) {
int[] arr = {5, 3, 8, 4, 2};
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
System.out.println(Arrays.toString(arr));
}
}
|
解析：相邻元素比较，将大的元素逐步”冒泡”到末尾。
(2) 选择排序 [3]
例题：对数组 [64,25,12,22,11] 进行升序排序
代码实现：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| public class SelectionSort {
public static void main(String[] args) {
int[] arr = {64, 25, 12, 22, 11};
for (int i = 0; i < arr.length - 1; i++) {
int minIndex = i;
for (int j = i + 1; j < arr.length; j++) {
if (arr[j] < arr[minIndex]) minIndex = j;
}
int temp = arr[minIndex];
arr[minIndex] = arr[i];
arr[i] = temp;
}
System.out.println(Arrays.toString(arr));
}
}
|
解析：每次选择未排序部分的最小值，与当前位置交换。
3. 搜索
BFS [1-5]
例题：迷宫寻路（0为通路，1为障碍）
1
2
3
4
| 输入迷宫：
0 1 0 0
0 0 0 1
1 0 0 0
|
输出：最短路径长度
代码实现：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
| public class BFSMaze {
static class Node {
int x, y, step;
Node(int x, int y, int step) {
this.x = x; this.y = y; this.step = step;
}
}
public static void main(String[] args) {
int[][] maze = {
{0,1,0,0},
{0,0,0,1},
{1,0,0,0}
};
int[] dx = {0,0,1,-1}, dy = {1,-1,0,0};
Queue<Node> queue = new LinkedList<>();
queue.add(new Node(0,0,0));
maze[0][0] = 1;
while (!queue.isEmpty()) {
Node node = queue.poll();
if (node.x == 2 && node.y == 3) {
System.out.println(node.step);
return;
}
for (int i = 0; i < 4; i++) {
int nx = node.x + dx[i], ny = node.y + dy[i];
if (nx >=0 && nx <3 && ny >=0 && ny <4 && maze[nx][ny]==0) {
queue.add(new Node(nx, ny, node.step+1));
maze[nx][ny] = 1;
}
}
}
}
}
|
解析：使用队列实现广度优先搜索，逐层扩展找到最短路径。
4. 贪心 [1-5]
例题：活动选择问题（最多安排多少不重叠活动）
输入：活动列表 [[1,4],[3,5],[0,6],[5,7]]
输出：最大数量
代码实现：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| public class ActivitySelection {
public static void main(String[] args) {
int[][] activities = {{1,4},{3,5},{0,6},{5,7}};
Arrays.sort(activities, (a,b) -> a[1]-b[1]);
int count = 1, lastEnd = activities[0][1];
for (int i=1; i<activities.length; i++) {
if (activities[i][0] >= lastEnd) {
count++;
lastEnd = activities[i][1];
}
}
System.out.println(count);
}
}
|
解析：每次选择结束时间最早且不冲突的活动。
5. 模拟 [1-3]
例题：时钟角度计算（时:分）
输入：3:15
输出：时针与分针夹角（7.5度）
代码实现：
1
2
3
4
5
6
7
8
9
| public class ClockAngle {
public static void main(String[] args) {
int hour = 3, minute = 15;
double hourAngle = (hour % 12 + minute/60.0) * 30;
double minuteAngle = minute * 6;
double diff = Math.abs(hourAngle - minuteAngle);
System.out.println(Math.min(diff, 360 - diff));
}
}
|
解析：计算时针和分针的角度差，取最小值。
6. 二分 [2-5]
例题：在有序数组中查找目标值的插入位置
输入：[1,3,5,6], 目标值4
输出：2
代码实现：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| public class BinarySearch {
public static int searchInsert(int[] nums, int target) {
int left = 0, right = nums.length-1;
while (left <= right) {
int mid = left + (right - left)/2;
if (nums[mid] == target) return mid;
else if (nums[mid] < target) left = mid +1;
else right = mid -1;
}
return left;
}
public static void main(String[] args) {
int[] arr = {1,3,5,6};
System.out.println(searchInsert(arr,4));
}
}
|
解析：通过不断缩小查找范围确定插入位置。
7. DP（普通一维问题）[3-5]
例题：斐波那契数列第n项（n<=30）
输入：6
输出：8
代码实现：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| public class Fibonacci {
public static int fib(int n) {
if (n <=1) return n;
int[] dp = new int[n+1];
dp[0]=0; dp[1]=1;
for (int i=2; i<=n; i++) {
dp[i] = dp[i-1] + dp[i-2];
}
return dp[n];
}
public static void main(String[] args) {
System.out.println(fib(6));
}
}
|
解析：使用动态规划数组存储中间结果，避免重复计算。
8. 高精度 [1-5]
例题：两个大整数相加（位数不超过1000）
输入：
1
2
| 12345678901234567890
98765432109876543210
|
输出：111111111011111111100
代码实现：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| public class BigNumberAdd {
public static void main(String[] args) {
String a = "12345678901234567890";
String b = "98765432109876543210";
StringBuilder res = new StringBuilder();
int carry = 0;
for (int i=a.length()-1, j=b.length()-1; i>=0 || j>=0 || carry>0; i--,j--) {
int sum = carry;
if (i>=0) sum += a.charAt(i)-'0';
if (j>=0) sum += b.charAt(j)-'0';
carry = sum/10;
res.append(sum%10);
}
System.out.println(res.reverse());
}
}
|
解析：从低位到高位逐位相加，处理进位。
9. 数据结构
(1) 栈 [2-4]
例题：括号匹配验证
输入："()[]{}"
输出：true
代码实现：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| public class BracketMatch {
public static boolean isValid(String s) {
Stack<Character> stack = new Stack<>();
for (char c : s.toCharArray()) {
if (c == '(' || c == '[' || c == '{') {
stack.push(c);
} else {
if (stack.isEmpty()) return false;
char top = stack.pop();
if ((c==')' && top!='(') ||
(c==']' && top!='[') ||
(c=='}' && top!='{')) return false;
}
}
return stack.isEmpty();
}
public static void main(String[] args) {
System.out.println(isValid("()[]{}"));
}
}
|
解析：左括号入栈，右括号时检查栈顶是否匹配。
(2) 队列 [2-5]
例题：层次遍历二叉树
输入：树结构 1(2(4)(5))(3)
输出：[1,2,3,4,5]
代码实现：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
| import java.util.*;
class TreeNode {
int val; TreeNode left, right;
TreeNode(int val) { this.val = val; }
}
public class LevelOrder {
public static List<Integer> levelOrder(TreeNode root) {
List<Integer> res = new ArrayList<>();
Queue<TreeNode> queue = new LinkedList<>();
if (root != null) queue.add(root);
while (!queue.isEmpty()) {
TreeNode node = queue.poll();
res.add(node.val);
if (node.left != null) queue.add(node.left);
if (node.right != null) queue.add(node.right);
}
return res;
}
public static void main(String[] args) {
TreeNode root = new TreeNode(1);
root.left = new TreeNode(2); root.right = new TreeNode(3);
root.left.left = new TreeNode(4); root.left.right = new TreeNode(5);
System.out.println(levelOrder(root));
}
}
|
解析：使用队列按层处理节点。
(3) 链表 [2-5]
例题：反转链表
输入：1->2->3->4
输出：4->3->2->1
代码实现：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
| class ListNode {
int val; ListNode next;
ListNode(int val) { this.val = val; }
}
public class ReverseLinkedList {
public static ListNode reverseList(ListNode head) {
ListNode prev = null;
while (head != null) {
ListNode nextTemp = head.next;
head.next = prev;
prev = head;
head = nextTemp;
}
return prev;
}
public static void main(String[] args) {
ListNode head = new ListNode(1);
head.next = new ListNode(2); head.next.next = new ListNode(3);
head.next.next.next = new ListNode(4);
ListNode reversed = reverseList(head);
while (reversed != null) {
System.out.print(reversed.val + " ");
reversed = reversed.next;
}
}
}
|
解析：通过三个指针逐步反转节点指向。
10. 数学 [1-5]
例题：求n的质因数之和
输入：2024
输出：29
代码实现：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| public class PrimeFactorSum {
public static void main(String[] args) {
int n = 2024;
int sum = 0;
for (int i=2; i*i <=n; i++) {
while (n % i == 0) {
sum += i;
n /= i;
}
}
if (n >1) sum += n;
System.out.println(sum);
}
}
|
解析：分解质因数并累加，注意重复因数多次累加。
以上为蓝桥杯Java C组核心知识点示例，建议结合真题练习巩固。
