【leetcode学习笔记】时间复杂度、异或、简单的排序算法

原创已于 2023-03-10 14:59:53 修改 · 210 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #排序算法 #散列表

于 2022-02-13 18:20:07 首次发布

本文介绍了时间复杂度的概念，讲解了异或运算的定义、性质及其在LeetCode第136题中的应用。此外，还探讨了三种简单的排序算法——选择排序、插入排序和冒泡排序的原理及Java实现，它们的时间复杂度均为O(n^2)。

一、时间复杂度

1.1 常数时间的操作

运算时间和数据大小无关的操作，例：数组按照索引取数A[i]，四则运算（+-*/等

1.2 时间复杂度

算法所需要的常数操作的次数，一般取最高次项，并忽略常数，记做O(f(n))

二、异或运算

异或运算，逻辑表达式为xor，在python、java中符号均为^，属于位运算的一种。a^b是指将a和b转化为二进制，然后每一位对应的做逻辑运算。

2.1 定义

0^0=0，0^1=1，1^0=1，1^1=0

例：

a=6 --> 110

b=11 --> 1011

a^b --> 1101 = 13

2.2 运算律

异或运算满足以下规律：

归零律：x^x=0
恒等律：x^0=x
交换律：x^y=y^x
结合律：(x^y)^z=x^(y^z)

2.3 leetcode第136题

https://leetcode-cn.com/problems/single-number/

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

说明：你的算法应该具有线性时间复杂度。你可以不使用额外空间来实现吗？

分析：本体采用异或运算求解。由异或运算的交换律和结合律，我们可以任意交换数组中的顺序。假设输入为[x1, x2, ..., xm]，经过顺序调整，我们将出现一次的数放在最前面，其余的相同数均放在一起，即[a, b, b, c, c, ...]

那么，由结合律、归零律、恒等率可得：

0^x1^x2^...^xn

=x1^x2^...^xn

= a^b^b^c^c^...

= a^(b^b)^(c^c)^...

= a^0^0^...

= a

因此，我们只需要设置初始值为0，然后轮流和数组中所有元素做以后运算即可得到答案。

java解法：

class Solution {
    public int singleNumber(int[] nums){
        int res = 0;
        for(int num: nums){
            res ^= num;
        }
        return res;
    }
}

python解法：使用reduce函数即可。

三、简单的排序算法

3.1 选择排序

算法核心：在第i步，找到第i小的数，放到第i位，使得第i位的数是正确的，后续无需遍历

java实现：

public static void selectSort(int[]a)
{
    int minIndex = 0;
    int temp = 0;
    if((a == null)||(a.length == 0))
        return;
    for(int i = 0; i < a.length - 1; i++)
    {
        minIndex = i;
        for(int j = i+1; j < a.length; j++)
        {
            if(a[j] < a[minIndex])
            {
                minIndex = j;
            }
        }
        if(minIndex != i)
        {
            temp = a[i];
            a[i] = a[minIndex];
            a[minIndex] = temp;
        }
    }
}

时间复杂度：O(n^2)

3.2 插入排序

算法核心：在第i步，将第i位的数插入到前i-1位中的合适位置，使得前i位是有序的

java实现：

private static int[] insertSort(int[] arr){
    if(arr == null || arr.length < 2){
        return arr;
    }
    for(int i = 1; i < arr.length; i++){
        for(int j = i; j > 0; j--){
            if(arr[j] < arr[j-1]){
                int temp = arr[j];
                arr[j] = arr[j-1];
                arr[j-1] = temp;
            }else{
                break;
            }
        }
    }
    return arr;
}

时间复杂度：O(n^2)

3.3 冒泡排序

算法核心：在第i步，从左往右将所有的数和下一个数做比较，如果顺序不对，则交换，使得倒数第i个数成为第i大的数

java实现：

private static int[] bubbleSort(int[] arr){
    if(arr == null || arr.length < 2){
        return arr;
    }
    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;
            }
        }
    }
    return arr;
}

时间复杂度： O(n^2)