算法 on withdong02

十种排序算法整理

Thu, 16 Apr 2026 14:04:24 +0000

十种排序算法

冒泡排序

一共进行 n - 1 轮，在每一轮排序中对相邻两元素进行比较，大的排在后面。

/**  
 * 冒泡排序  
 * 时间复杂度：最优 O(n)，最坏 O(n²)，平均 O(n²)  
 * 空间复杂度：O(1)，原地排序  
 * 稳定性：稳定  
 */  
private static void bubbleSort(int[] arr) {  
    int n = arr.length;  
    boolean flag = true;  
    for (int i = 0; i < n - 1; i++) {  
        flag = true;  
        for (int j = 0; j < n - 1 - i; j++) {  
            if (arr[j] > arr[j + 1]) {  
                swap(arr, j, j + 1);  
                flag = false;  
            }  
        }  
        if (flag) break;  
    }  
}

选择排序

同样进行 n - 1 轮，每一轮从待排序序列中挑出最小的元素，将其放至已排序序列的末尾。

LeetCode155.最小栈

Thu, 26 Feb 2026 14:17:10 +0000

第二次碰到这道题了，又学了两种解题方法，记录一下。

题目介绍

设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。

实现 MinStack 类:

MinStack() 初始化堆栈对象。
void push(int val) 将元素val推入堆栈。
void pop() 删除堆栈顶部的元素。
int top() 获取堆栈顶部的元素。
int getMin() 获取堆栈中的最小元素。

解法一：使用辅助栈

这个也是最简单的，题目没有空间限制，考虑使用两个栈，主栈正常记录元素进出，辅助栈记录每个元素对应最小值的进出，辅助栈的栈顶保持为主栈所有元素的最小值。

当元素入栈时，比较该元素和辅助栈的栈顶，如果该元素更小，那么将其推入主栈的同时也将其推入辅助栈。

当元素出栈时，如果主栈栈顶元素值和辅助栈的栈顶元素值相等。那么将该元素从两个栈里同时弹出，否则正常弹出主栈栈顶元素。

class MinStack {
    Deque<Integer> stack1;
    Deque<Integer> stack2;
    public MinStack() {
        stack1 = new ArrayDeque<>();
        stack2 = new ArrayDeque<>();
    }
    
    public void push(int val) {
        stack1.push(val);
        if (stack2.isEmpty() || val <= stack2.peek()) {
            stack2.push(val);
        }
    }
    
    public void pop() {
        int num = stack1.pop();
        if (num == stack2.peek()) stack2.pop();
    }
    
    public int top() {
        return stack1.peek();
    }
    
    public int getMin() {
        return stack2.peek();
    }
}

解法二：使用自定义链表

评论区有评论说面试官要求使用栈以外的数据结构来设计，所以找到这种方法。

LeetCode8.字符串转换整数

Sun, 15 Feb 2026 14:04:24 +0000

一切源于一道题目：8. 字符串转换整数 (atoi) - 力扣（LeetCode）

考虑这样一个问题：给你一个数字字符串，如何在32位环境下安全的处理可能超过[-2^31, 2^31 - 1]范围的数字，不能使用64位变量临时存储。

因为我熟悉Java，所以下面提到的数据类型都为 Java 中的数据类型。

Integer.MAX_VALUE = 2^31 - 1 = 2147483647;
Integer.MIN_VALUE = -2^31 = -2147483648;

首先题目说不能使用64位变量，所以 Long 类型不能使用，那就一步一步累加，具体思路就是设置两个变量 digit, res，从头到尾遍历字符串每一位，同时计算 res = res * 10 + digit。但这样的话，累加过程中 res 可能会无征兆直接溢出，程序直接抛异常。那怎么办，介绍一下从 K神题解里学来的方法。

整体思路也是一步一步累加，但提前预判溢出。

这里有个核心变量 bndry = 2^31 / 10 = 214748364，，它是32位有符号整数最大值去掉最后一位的结果。

在执行 res = res * 10 + digit 之前，先检查 res 与 bndry 的关系，有下面两种溢出的可能。

情况一：res > bndry ，意味着 res 乘10后，即使加上最小的数字0，结果也会超过 2147483647，溢出。
情况二：res == bndry，此时是否溢出取决于要累加的数字 digit。
- 如果 digit <= 7，此时正数负数都不会溢出，但等于七对正数来说已经达到最大值。
- 如果 digit = 8，拼接后值为 2147483648，比 Integer.MAX_VALUE 大 1，而负数即 -2147483648 还未溢出。
- 如果 digit > 8，正数负数都溢出。

思路还是很清晰的，在下一位拼接前进行判断可以很好的避开溢出问题。下面看一下题解代码