算法与数据结构全阶班-左程云版(二)基础阶段之1.复杂度、对数器、二分法和异或运算

文章目录

  • 引言
  • 1.概述
  • 2.复杂度
  • 3.对数器
  • 4.二分法
  • 5.异或运算
  • 总结

引言

本文主要介绍了数据结构与算法的基本概念,包括算法评价指标、复杂度、对数器、二分法和异或运算。

1.概述

评价算法优劣的核心指标

  • 时间复杂度(流程决定)
  • 额外空间复杂度(流程决定)
  • 常数项时间(实现细节决定)

常见的常数时间的操作:

  • 常见的算术运算(+、-、*、/、%等)

  • 常见的位运算(>>、>>>、<<、|、&、^等)

  • 赋值、比较、自增、自减操作等

  • 数组寻址操作

总之,执行时间固定的操作都是常数时间的操作。
反之,执行时间不固定的操作,都不是常数时间的操作。

时间复杂度就是计算常数操作了多少次。

如何确定算法流程的总操作数量与样本数量之间的表达式关系:

  1. 想象该算法流程所处理的数据状况,要按照最差情况来。
  2. 把整个流程彻底拆分为一个个基本动作,保证每个动作都是常数时间的操作
  3. 如果数据量为N,看看基本动作的数量和N是什么关系。

2.复杂度

如何确定算法流程的时间复杂度

当完成了表达式的建立,只要把最高阶项留下即可。低阶项都去掉,高阶项的系数也去掉。

记为:O(忽略掉系数的高阶项)

例如下图:

算法与数据结构全阶班-左程云版(二)基础阶段之1.复杂度、对数器、二分法和异或运算_第1张图片

显然后者的时间复杂度更低。

时间复杂度的意义在于:
当我们要处理的样本量很大很大时,我们会发现低阶项是什么不是最重要的;每一项的系数是什么,不是最重要的。真正重要的就是最高阶项是什么。
这就是时间复杂度的意义.它是衡量算法流程的复杂程度的一种指标,该指标只与数据量有关,与过程之外的优化无关。

三种基本排序:

选择排序:

package complexity01;

import java.util.Arrays;

/**
 * @author Corley
 * @date 2021/10/3 19:26
 * @description LeetCodeAlgorithmZuo-complexity01
 */
public class SelectionSort {

    public static void selectionSort(int[] arr) {
        if (null == arr || arr.length < 2) {
            return;
        }
        int minIndex;
        for (int i = 0; i < arr.length - 1; i++) {
            minIndex = i;
            for (int j = i + 1; j < arr.length; j++) {
                minIndex = arr[minIndex] < arr[j] ? minIndex : j;
            }
            swap(arr, i, minIndex);
        }
    }

    private static void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

    public static void main(String[] args) {
        int[] arr = new int[]{3, 2, 5, 1, 4, 9, 0, 7, 12, 5, 7, 3};
        System.out.println(Arrays.toString(arr));
        selectionSort(arr);
        System.out.println(Arrays.toString(arr));
    }
}


冒泡排序:

package complexity01;

import java.util.Arrays;

/**
 * @author Corley
 * @date 2021/10/3 19:41
 * @description LeetCodeAlgorithmZuo-complexity01
 */
public class BubbleSort {

    public static void bubbleSort(int[] arr) {
        if (null == arr || arr.length < 2) {
            return;
        }
        
        for (int i = arr.length - 1; i > 0; i--) {
            for (int j = 0; j < i; j++) {
                if (arr[j] > arr[j + 1]) {
                    swap(arr, j, j + 1);
                }
            }
        }
    }

    private static void swap(int[] arr, int i, int j) {
        arr[i] = arr[i] ^ arr[j];
        arr[j] = arr[i] ^ arr[j];
        arr[i] = arr[i] ^ arr[j];
    }

    public static void main(String[] args) {
        int[] arr = new int[]{3, 2, 5, 1, 4, 9, 0, 7, 12, 5, 7, 3};
        System.out.println(Arrays.toString(arr));
        bubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }
}


这两种排序算法的效果不会受到数据的初始状态的影响。

插入排序:

package complexity01;

import java.util.Arrays;

/**
 * @author Corley
 * @date 2021/10/3 20:10
 * @description LeetCodeAlgorithmZuo-complexity01
 */
public class InsertionSort {

    public static void insertionSort(int[] arr) {
        if (null == arr || arr.length < 2) {
            return;
        }

        for (int i = 1; i < arr.length; i++) {
            for (int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--) {
                swap(arr, j, j + 1);
            }
        }
    }

    private static void swap(int[] arr, int i, int j) {
        arr[i] = arr[i] ^ arr[j];
        arr[j] = arr[i] ^ arr[j];
        arr[i] = arr[i] ^ arr[j];
    }

    public static void main(String[] args) {
        int[] arr = new int[]{3, 2, 5, 1, 4, 9, 0, 7, 12, 5, 7, 3};
        System.out.println(Arrays.toString(arr));
        insertionSort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

插入排序的效果会受到数据的初始状态的影响,例如数组已经是有序的情况下。

额外空间复杂度
你要实现一个算法流程,在实现算法流程的过程中,你需要开辟一些空间来支持你的算法流程。
作为输入参数的空间,不算额外空间;
作为输出结果的空间,也不算额外空间。
因为这些都是必要的、和现实目标有关的,所以都不算。
但除此之外,你的流程如果还需要开辟空间才能让你的流程继续下去。这部分空间就是额外空间。如果你的流程只需要开辟有限几个变量,额外空间复杂度就是O(1)。

算法流程的常数项的比拼方式
放弃理论分析,生成随机数据直接测。为什么不去理论分析?
不是不能纯分析.而是没必要。因为不同常数时间的操作,虽然都是固定时间,但还是有快慢之分的。
比如,位运算的常数时间原小于算术运算的常数时间,这两个运算的常数时间又远小于数组寻址的时间。
所以如果纯理论分析,往往会需要非常多的分析过程。都已经到了具体细节的程度.莫不如交给实验数据好了。

常见的时间复杂度(我们陆续都会见到的):
排名从好到差:

O(1)
O(logN)
O(N)
O(N*logN)
O(N^2) O(N^3) … O(N^K)
O(2^N) O(3^N)… O(K^N)
O(N!)

算法和数据结构学习的大脉络:
1)知道怎么算的算法
2)知道怎么试的算法

3.对数器

对数器:

1,你想要测的方法a
2,实现复杂度不好但是容易实现的方法b,实现一个随机样本产生器
4,把方法a和方法b跑相同的随机样本,跑多次,看看得到的结果是否一样
5,如果有一个随机样本使得比对结果不一致,打印样本进行人工干预,改对方法a和方法b
6,当样本数量很多时比对测试依然正确,可以确定方法a已经正确。

4.二分法

二分法:

只要构建出能够排除另外一端的逻辑,就可以使用二分,而不一定需要保证数组有序。

应用:

1)在一个有序数组中,找某个数是否存在

package complexity01;

/**
 * @author Corley
 * @date 2021/10/4 9:03
 * @description LeetCodeAlgorithmZuo-complexity01
 */
public class BinarySearchExist {

    public static boolean exist(int[] arr, int num) {
        if (null == arr || 0 == arr.length) {
            return false;
        }
        int L = 0, R = arr.length - 1;
        int mid;
        while (L < R) {
            mid = L + ((R - L) >> 1);
            if (arr[mid] == num) {
                return true;
            } else if (arr[mid] < num) {
                L = mid + 1;
            } else {
                R = mid - 1;
            }
        }
        return arr[L] == num;
    }

    public static void main(String[] args) {
        int[] arr = {0, 2, 5, 5, 6, 7, 7, 7, 9, 12};
        System.out.println(exist(arr, 5));
        System.out.println(exist(arr, 8));
        System.out.println(exist(arr, 9));
    }
}

2)在一个有序数组中,找>=某个数最左侧的位置

package complexity01;

/**
 * @author Corley
 * @date 2021/10/4 9:20
 * @description LeetCodeAlgorithmZuo-complexity01
 */
public class BinarySearchNearLeft {

    public static int nearestIndex(int[] arr, int num) {
        int index = -1;
        if (null == arr || 0 == arr.length) {
            return index;
        }
        int L = 0, R = arr.length - 1;
        int mid;
        while (L <= R) {
            mid = L + ((R - L) >> 1);
            if (arr[mid] >= num) {
                index = mid;
                R = mid - 1;
            } else {
                L = mid + 1;
            }
        }
        return index;
    }

    public static void main(String[] args) {
        int[] arr = {0, 2, 5, 5, 6, 7, 7, 7, 9, 12};
        System.out.println(nearestIndex(arr, 5));
        System.out.println(nearestIndex(arr, 8));
        System.out.println(nearestIndex(arr, 9));
    }
}

3)在一个有序数组中,找<=某个数最右侧的位置

package complexity01;

/**
 * @author Corley
 * @date 2021/10/4 9:30
 * @description LeetCodeAlgorithmZuo-complexity01
 */
public class BinarySearchNearRight {

    public static int nearestIndex(int[] arr, int num) {
        int index = -1;
        if (null == arr || 0 == arr.length) {
            return index;
        }
        int L = 0, R = arr.length - 1;
        int mid;
        while (L <= R) {
            mid = L + ((R - L) >> 1);
            if (arr[mid] <= num) {
                index = mid;
                L = mid + 1;
            } else {
                R = mid - 1;
            }
        }
        return index;
    }

    public static void main(String[] args) {
        int[] arr = {0, 2, 5, 5, 6, 7, 7, 7, 9, 12};
        System.out.println(nearestIndex(arr, 5));
        System.out.println(nearestIndex(arr, 8));
        System.out.println(nearestIndex(arr, 9));
    }
}

4)局部最小值问题

一个无序数组,任意两个相邻元素都不相等,找到一个局部最小值。

package complexity01;

/**
 * @author Corley
 * @date 2021/10/4 9:45
 * @description LeetCodeAlgorithmZuo-complexity01
 */
public class BinarySearchLocalMin {

    public static int getLessIndex(int[] arr) {
        if (null == arr || 0 == arr.length) {
            return -1;
        }
        if (1 == arr.length || arr[0] < arr[1]) {
            return 0;
        }
        if (arr[arr.length - 1] < arr[arr.length - 2]) {
            return arr.length - 1;
        }
        int left = 1, right = arr.length - 2;
        int mid;
        while (left < right) {
            mid = left + ((right - left) >> 1);
            if (arr[mid - 1] < arr[mid]) {
                right = mid - 1;
            } else if (arr[mid + 1] < arr[mid]) {
                left = mid + 1;
            } else {
                return mid;
            }
        }
        return left;
    }

    public static void main(String[] args) {
        System.out.println(getLessIndex(new int[]{0, 2, 5, 5, 6, 7, 7, 7, 9, 12}));
        System.out.println(getLessIndex(new int[]{8, 2, 5, 7, 6, 4, 7, 2, 3, 4}));
        System.out.println(getLessIndex(new int[]{7, 2, 8, 5, 6, 9, 7, 3, 9, 0}));
    }
}

5.异或运算

认识异或运算

异或运算:相同为0,不同为1
同或运算:相同以1,不同为0
能长时间记住的概率接近0%
所以,异或运算就记成无进位相加!

算法与数据结构全阶班-左程云版(二)基础阶段之1.复杂度、对数器、二分法和异或运算_第2张图片

异或运算的性质
1)0^N==N
N^N == 0
2)异或运算满足交换律和结合率

算法与数据结构全阶班-左程云版(二)基础阶段之1.复杂度、对数器、二分法和异或运算_第3张图片

上面的两个性质用无进位相加来理解就非常的容易

如何不用额外变量交换两个数

算法与数据结构全阶班-左程云版(二)基础阶段之1.复杂度、对数器、二分法和异或运算_第4张图片

可以进行这种操作的前提是变量属于不同的对象,即指向不同的内存,否则对象的数值会被置为0,但是允许两个对象的值相等。

一个数组中有一个数出现了奇数次,其他数都出现了偶数次,怎么找到并打印这一个数。

算法与数据结构全阶班-左程云版(二)基础阶段之1.复杂度、对数器、二分法和异或运算_第5张图片

代码:

public static void getOneOddTimes(int[] arr) {
    int eor = 0;
    for (int i = 0; i < arr.length; i++) {
        eor ^= arr[i];
    }
    System.out.println(eor);
}

怎么把一个int类型的数,提取出最右侧的1

方法:N & ((~N) + 1)

算法与数据结构全阶班-左程云版(二)基础阶段之1.复杂度、对数器、二分法和异或运算_第6张图片

一个数组中有两个数出现了奇数次,其他数都出现了偶数次,怎么找到并打印这两个数。

算法与数据结构全阶班-左程云版(二)基础阶段之1.复杂度、对数器、二分法和异或运算_第7张图片

如下:

/*
一个数组中有两个数出现了奇数次,其他数都出现了偶数次,怎么找到并打印这两个数。
 */
public static void getTwoOddTimes(int[] arr) {
    int eor1 = 0;
    for (int j : arr) {
        eor1 ^= j;
    }
    // 提取最右边的1
    int rightOne = eor1 & (~eor1 + 1);

    int eor2 = 0;
    for (int j : arr) {
        if ((j & rightOne) != 0) {
            eor2 ^= j;
        }
    }
    int num1 = eor2, num2 = eor1 ^ eor2;
    System.out.println(num1 + " " + num2);
}

public static void main(String[] args) {
    int[] arr = {1, 2, 2, 4, 6, 6, 6, 6, 6, 4, 4, 4, 7, 7, 6, 7, 8, 8};
    getTwoOddTimes(arr);
}

给定一个数,计算这个数的二进制形式中1的个数。

public static int bit1Count(int num) {
    int count = 0;
    int rightOne;
    while (num != 0) {
        rightOne = num & (~num + 1);
        count++;
        num ^= rightOne;
    }
    return count;
}

public static void main(String[] args) {
    // int[] arr = {1, 2, 2, 4, 6, 6, 6, 6, 6, 4, 4, 4, 7, 7, 6, 7, 8, 8};
    // getTwoOddTimes(arr);
    System.out.println(Integer.toBinaryString(12345));
    System.out.println(bit1Count(12345));
}

总结

左神极力推荐的对数器是检验算法实现正确性的有力工具,可以覆盖几乎所有情况的测试用例,无死角实现对算法的验证。同时异或也是可以在算法实现中加快运算效率的技巧。

你可能感兴趣的:(算法与数据结构全阶班-左程云版,算法与数据结构全阶班-左程云版,基础班,复杂度,对数器,二分法和异或)