时间复杂度空间复杂度

最新推荐文章于 2024-09-13 16:27:15 发布

坚持学习！

最新推荐文章于 2024-09-13 16:27:15 发布

阅读量642

点赞数 13

分类专栏：刷刷算法文章标签：算法排序算法 java

本文链接：https://blog.csdn.net/2401_84288592/article/details/140892852

版权

刷刷算法专栏收录该内容

1 篇文章 0 订阅

订阅专栏

复杂度

时间复杂度

什么叫做时间复杂度？

看做了多少次常数操作，且只要最高项，不要常数和系数，然后剩下的东西。按照最差情况来估计。

什么叫做常数操作？

一个操作如果和样本的数据量没有关系，每次都是固定时间内完成的操作，叫做常数操作。

谁的时间复杂度低谁的算法就更好。

时间复杂度相同怎么办？

当时间复杂度相等时，然后再分析不同数据样本下的实际运行时间，也就是“常数项时间”，不能看常数或者系数的大小，因为无法评判*和与的计算速度。
如下面的示例 两个都是O(n), 就要实际操作来评判。

public static void p1() {
    int N = 1000;
    int a = 1;
    for (int i = 0; i < N; i++) {
        a = 2 + 3;
        a = 3 * 5;
    }
}


public static void p2() {
    int N = 1000;
    int a = 1;
    for (int i = 0; i < N; i++) {
        a = 2 | 3;
        a = 3 & 5;
    }
}

空间复杂度

什么是空间复杂度？

这个流程需要你额外多少空间才能支持你计算？
如果只有有限集的数量那就是O(1)

public class Test02 {
    public static void main(String[] args) {
        int[] arr = {1,2,4,5,6,1,3,5};
        //i和j都是额外开辟的空间
        for (int i = 0; i < arr.length; i++) {
            int minIndex = i; //临时开辟的空间 重复开辟又销毁
            for (int j = i+1; j < arr.length; j++) {
                minIndex = arr[j]<arr[minIndex]?j:minIndex;
            }
            //两个索引的元素交换
            swap(arr,i,minIndex);
        }
    }
}

异或运算（^）

相同为0，不同为1

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

异或运算也可以理解为无进位相加

什么是无进位相加？

10110^00111 对应为相加满2进十，且不仅为也就是留下0

异或运算的规则

0 ^ N = N N^N=0
满足交换律与结合律

交换两个变量的值，我们可以怎么写？

可以这样做的前提是a和b是独立的区域（指向的内存不同）

public class Test03 {
    public static void main(String[] args) {
        int a = 17;
        int b = 23;
        a = a ^ b;
        b = a ^ b;
        a = a ^ b;
        System.out.println("结果a为"+a+"b为"+b);
    }
}

为什么呢？

假设 a = 甲，b = 乙
a = a ^ b 甲 ^ 乙
b = a ^ b 甲 ^ 乙 ^ 乙 =》甲 ^ 0 => 甲
a = a ^ b 甲 ^ 乙 ^ 甲 =》乙 ^ 0 => 乙

案例1

题目

在一个数组中，一个数出现了奇数次，其他出现了偶数次，怎么找到这个出现奇数次的数？

代码

public class Test04 {
    public static void main(String[] args) {
        int[] arr = {1,2,2,3,3,4,4};
        int eor = 0;
        for (int i = 0; i < arr.length; i++) {
            eor = eor ^ arr[i];
        }
        System.out.println(eor);
    }
}

为什么可以这样写？

因为根据交换律和结合律
在这里插入图片描述

为什么符合交换律和结合律？

用无进位相交就很好解决可以看出偶数次为0 奇数次为1，因为相同为0,不同为1.

案例2

题目

两个数出现了奇数次，其他出现偶数。


public class Test05 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,3,4,4,5,5};
        int eor = 0;
        for (int i = 0; i < arr.length; i++) {
            eor ^= arr[i];
        }
        //eor必然有一个位置上是1
        int rightOne = eor & (~eor +1);// 取出最右的1
        //~eor是取反  & 1&1才是1 其他都是0
        int onlyOne = 0;
        for (int i : arr) {
            if ((i&rightOne)==1){
                onlyOne ^= i;
            }
        }

        System.out.println(onlyOne+"和"+ (eor^onlyOne));

    }
}

异或运算的弊端

在使用异或运算来交换两个变量的值的时候，必须确保两个变量是相互独立的，分别有自己的地址。

当两个变量指向同一片存储区域时，即a = b，使用异或交换会导致两个变量的值都变为0。这是因为连续的异或操作会导致变量值被重置为0。‌
在数组操作中，如果尝试交换位于相同索引位置的元素，由于异或运算的特性，这些元素的值也会变为0。这是因为对一个数进行三次自异或操作的结果是0。‌
在某些编程语言中，连续赋值语句的执行顺序可能导致意外的结果。例如，在C#中，连续的异或赋值操作需要特别注意，以避免出现意外的结果。‌
在进行选择排序等算法时，如果错误地使用了异或交换，可能会导致排序结果错误，因为错误的交换操作会改变数据的顺序。‌

插入排序

往前看如果比前面小就交换，一直到不用交换或者前面没有数
选择排序和冒泡排的时间复杂度不受数据的影响。
插入排序会被数据所影响
虽然插入，冒泡和选择都是O(n2),但是最优情况下插入是O(n) （数据已经排好的情况下）

选择排序代码

public class Test08 {
    public static void main(String[] args) {
        int[] arr = {1,1,1,2,3,2,5,7,2,1};
        for (int i = 0; i < arr.length; i++) {
            int min = i;
            for (int j = i+1; j < arr.length; j++) {
                //每次找最小的
                if (arr[min]>arr[j]){
                   min = j;
                }
            }
            int temp = arr[i];
            arr[i] = arr[min];
            arr[min] = temp;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

冒泡排序

冒泡排序是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。重复进行直到没有再需要交换的元素，这意味着数列已经排序完成

public class Test09 {
    public static void main(String[] args) {
        int[] arr = {1, 1, 1, 2, 3, 2, 5, 7, 2, 1};
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0 ; j < arr.length - i - 1; j++) {
                if (arr[j] > arr[j+1]) {
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

    }
}

插入排序

public class Test06 {
    public static void main(String[] args) {
       int[] arr = {1,2,3,4,5,1,2,3};
        for (int i = 1; i < arr.length; i++) {
            for (int j = i-1; j>=0&&arr[j]>arr[j+1]; j--) {				
             //交换两个的值
                    swap();
               
            }
        }
    }
}

二分查找

在一个有序数组中找到指定的数，每次都找中间值O(log2N)

二分查找代码

public class Test10 {
    public static void main(String[] args) {
        int[] arr = {1, 1, 1, 2, 2, 3, 4, 5, 6};
        int start = 0;
        int end = arr.length - 1;
        int findNum = 3;
        while (start <= end) {
            int mid = (start + end) / 2;
            if (arr[mid] > findNum) {
                end = mid - 1;
            } else if (arr[mid] == findNum) {
                System.out.println("找到了" + arr[mid]);
                return;
            } else {
                start = mid + 1;
            }
        }
        System.out.println("没找到");
    }
}

找这个值的最左边的值

public class Test11 {
    public static void main(String[] args) {
        int[] arr = {1, 1, 1, 2, 2, 3, 4, 5, 6,6};
        int start = 0;
        int end = arr.length - 1;
        int findNum = 3;
        int temp = -1;
        while (start <= end) {
            int mid = (start + end) / 2;
            if (arr[mid] > findNum) {
                end = mid - 1;
            } else if (arr[mid] == findNum) {
                temp = mid;
                end = mid-1;
            } else {
                start = mid + 1;
            }
        }
        System.out.println(temp);
    }
}

局部最小

在一个arr中，里面的元素无序，相邻的数一定不相等。
1.先判断0位置是不是局限最小
2.再判断n-1位置是不是一个局部最小
3.取中间判断是否是局部最小，然后继续二分，为啥一定有最小
因为：
当0和n-1都不是局部最小，则中间一定有局部最小，同理
在这里插入图片描述

public class Test12 {
    public static void main(String[] args) {
        int[] arr = {2, 1, 0, 5, 7, 8};
        int start = 0;
        int end = arr.length - 1;
        int result = -1;
        if (arr.length == 1) {
            return;
        }

        if (arr[start] < arr[start + 1] || arr[end] < arr[end - 1]) {
            result = arr[start];
            System.out.println("开头或结尾" + result);
            return;
        }

        while (start <= end) {
            int mid = start + (end - start) / 2;
            if (arr[mid] > arr[mid - 1]) {
                //往左下坡
                end = mid - 1;
            } else if (arr[mid] < arr[mid + 1] && arr[mid] < arr[mid - 1]) {
                result = arr[mid];
                break;
            } else{
                //往右下坡
                start = mid + 1;
            }
        }
        System.out.println(result);
    }
}