认识算法

认识 时间复杂度

常数时间的操作

一个操作和 样本的数据量没有 关系，每次都是固定时间内完成。
时间复杂度为一个算法流程中，常数操作数量的一个指标； 用Big O来表示

对一个算法流程非常熟悉， 发生多少 常数时间 的操作

表达式中，只要高阶项 。 也不要高阶项的系数

评价一个算法的好坏，先看时间复杂度，然后 分析不同数据样本下 实际 运行时间， 也就是常数项 时间。

选择排序

时间复杂度 O(n^2) 额外空间 O(1)

public void userSort(int[] arr) {
        System.out.println("===选择排序===");
        if (arr == null || arr.length < 2) {
            return;
        }
        // 选择排序，每次选一个最小的或者最大的,然后和当前 索引交换
        // i 从 0 遍历到 length-1, 剩下一个肯定是最大的了
        for (int i = 0; i < arr.length - 1; i++) {
            int min = i; // 保存 值最小的索引
            // 依次遍历后续每个位置
            for (int j = i + 1; j < arr.length; j++) {
                // 从 i+ 1 开始选择，前面的已经是选择好的
                if (arr[j] < arr[min]) {
                    min = j;
                }
            }
            // 遍历完成之后。min 和 i 交换
            swap(arr, i, min);
        }
 
    }

python 实现

def user_sort(self, arr):
   print("选择排序")
   # 选择排序
   for i in range(len(arr)):
       min_index = i
       for j in range(i+1, len(arr)):
           if arr[j] < arr[min_index]:
               min_index = j 
       
       arr[i], arr[min_index] = arr[min_index], arr[i]

冒泡排序

时间复杂度O(n^2) 空间复杂度O(1)
从0开始

public void userSort(int[] arr) {
        if(arr == null || arr.length <2){
            return;
        }
        // 冒泡排序，俩俩依次对比
 
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                // 俩俩比较，前面的比后面的大就交换
                if (arr[i] > arr[j]) {
                    swap(arr, i, j);
                }
            }
        }
    }

从最后开始

public void userSort(int[] arr) {
        if (arr == null || 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);
                }
            }
        }
    }

python 实现

def user_sort(self, arr):
    print("冒泡排序")
    for i in range(len(arr))[::-1]:
        for j in range(i):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]

插入排序

就是在前面已经排好序的时候，依次和前面的数据比较，如果小，就和当前元素交换，直到不能插入，就退出。
在大部分是已经排好序的时候，效果最好

 public void userSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        // 插入排序
 
        // 从索引1开始，0位置就是已经排好的。
        for (int i = 1; i < arr.length; i++) {
 
            for (int j = i - 1; j >= 0; j--) {
                if (arr[j] > arr[j + 1]) {
                    swap(arr, j, j + 1);
                } else {
                    break;
                }
            }
        }
    }

python 实现
调试的时候，写了个bug,交换 = 写成 ==了。我去。看了半天。

def user_sort(self, arr):
    print("插入排序")
    for i in range(1, len(arr)):
        for j in range(i)[::-1]:
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
            else:
                break

归并排序

从中间分成左右俩部分，分别排好序，然后合并。
调试的时候，userSort方法忘记调用mergeSort了，看了半天。我了个去。。。

public void userSort(int[] arr) {
    if (arr == null || arr.length < 2) {
        return;
    }
    // 归并排序
    mergeSort(arr, 0, arr.length - 1);
}
 
public void mergeSort(int[] arr, int l, int r) {
 
    if (l == r) {
        // 递归的结束条件。
        return;
    }
 
    int mid = l + ((r - l) >> 1);
    mergeSort(arr, l, mid); // 排左边, 递归
    mergeSort(arr, mid + 1, r); // 排 右边, 递归
 
    merge(arr, l, mid, r); // 合并
 
}
 
public void merge(int[] arr, int l, int m, int r) {
    // 需要辅助数组,大小是当前r-l + 1
    int[] helpArry = new int[r - l + 1];
    int helpArryCurrentIndex = 0; // 辅助数组当前索引
    int lCurrentIndex = l; // 左边当前索引
    int rCurrentIndex = m + 1; // 右边当前索引
 
    // 循环条件，左边当前索引还没有到mid，以及 右边当前索引还没有到r
    while (lCurrentIndex <= m && rCurrentIndex <= r) {
        // 判断当前左 右俩个数谁进入 辅助数组
        if (arr[lCurrentIndex] <= arr[rCurrentIndex]) {
            // 左边 数小，进入辅助数组
            helpArry[helpArryCurrentIndex] = arr[lCurrentIndex];
            // 左边索引加1
            lCurrentIndex += 1;
        } else {
            // 右边 数小， 进入辅助数组
            helpArry[helpArryCurrentIndex] = arr[rCurrentIndex];
            // 右边索引加1
            rCurrentIndex += 1;
        }
        // 辅助数组索引 必加1
        helpArryCurrentIndex += 1;
    }
 
    // 上面while循环条件结束，有可能左边还有数，也有可能右边还有数
 
    while (lCurrentIndex <= m) {
        // 左边还有数
        helpArry[helpArryCurrentIndex++] = arr[lCurrentIndex++];
    }
 
    while (rCurrentIndex <= r) {
        // 右边还有数
        helpArry[helpArryCurrentIndex++] = arr[rCurrentIndex++];
    }
 
    // 把辅助数组的数，拷贝到arr数组中
    for (int i = 0; i < helpArry.length; i++) {
        arr[l + i] = helpArry[i];
    }
 
}

python 实现
注意，一点要检查 传递进来的数组的大小，负责容易死循环，
或者 递归结束条件改为 l>=r

class InsertSort(ArrayUtil):
    def user_sort(self, arr):
        print("插入排序")
        for i in range(1, len(arr)):
            for j in range(i)[::-1]:
                if arr[j] > arr[j+1]:
                    arr[j], arr[j+1] = arr[j+1], arr[j]
                else:
                    break
 
class MergeSort(ArrayUtil):
 
    def user_sort(self, arr):
        if len(arr) == 0:
            return
        self.merge_sort(arr, 0, len(arr) - 1)
    
    def merge_sort(self, arr, l, r):
        # print(f"l == r {l}, {r}")
        if l == r:
            return
        
        m = l + ((r-l) >> 1)
        # print(f"{l} + {r}  ==> {m}")
 
        self.merge_sort(arr, l, m)
        self.merge_sort(arr, m + 1, r)
 
        self.merge(arr, l, m, r)
 
    def merge(self, arr, l, m, r):
        help_arry = []
        l_cur_index = l
        r_cur_index = m + 1
 
        while l_cur_index <= m and r_cur_index <= r:
            if arr[l_cur_index] <= arr[r_cur_index]:
                help_arry.append(arr[l_cur_index])
                l_cur_index += 1
            else:
                help_arry.append(arr[r_cur_index])
                r_cur_index += 1
        
        while l_cur_index <= m:
            help_arry.append(arr[l_cur_index])
            l_cur_index += 1
 
        while r_cur_index <= r:
            help_arry.append(arr[r_cur_index])
            r_cur_index += 1
        
        for index, item in enumerate(help_arry):
            arr[l + index] = item 

快速排序1.0

[ <5 5 >5 ]

1：选最后一个元素作为划分值
2：小于这个元素的放在左边，大于这个元素的放在右边
依次对左右俩个子序列操作步骤 1,2
时间复杂度O(N^2)(最坏情况）
123456789

@Override
public void userSort(int[] arr) {
    quickSort(arr, 0, arr.length - 1);
}
 
public static void quickSort(int[] arr, int l, int r) {
    // 递归退出条件
    if (l >= r) {
        return;
    }
 
    // 分割
    int[] p = pararion(arr, l, r);
 
    quickSort(arr, l, p[0]);
    quickSort(arr, p[1], r);
 
}
 
public static int[] pararion(int[] arr, int l, int r) {
    int less = l - 1; // 小于区域
    int more = r; // 大于区域
    // 当 l 和大于区域 相撞，停止
    // 划分值为最后一个元素 arr[r]
    while (l < more) {
 
        if (arr[l] < arr[r]) {
            // 当前元素小于 划分值 ，小于区域 和 l 交换
            // 小于区域 右扩(less++), 看下一个元素(l++)
            less++;
            swap(arr, less, l); // 因为 小于区域下一个 元素 可能是划分值，
            l++;
        } else if (arr[l] > arr[r]) {
            // 当前元素 大于 划分值，大于区域左扩(more 减一 )
 
            // 当前元素和 大于区域的下一个元素交换
            swap(arr, --more, l);
 
        } else {
            // 当前元素等于 划分值， 看下一个元素
            l++;
 
        }
 
    }
    // 划分完之后，大于区域的左边元素和划分值（最后一个元素）交换
    swap(arr, more, r);
 
    // 把小于区域 的 索引 和 大于区域 的 索引返回去
    return new int[] { less, more };
 
}

python 实现

def user_sort(self, arr):
    if len(arr) <= 1:
        return
    self.quick_sort(arr, 0, len(arr) - 1)
 
def quick_sort(self, arr, l, r):
    if l >= r:
        return 
    
    less, more = self.partition(arr, l, r)
 
    self.quick_sort(arr, l, less)
    self.quick_sort(arr, more, r)
 
def partition(self, arr, l, r):
    less = l - 1
    more = r
 
    while l < more:
        if arr[l] < arr[r]:
            less += 1
            arr[less], arr[l] = arr[l], arr[less]
            l += 1
        elif arr[l] > arr[r]:
            more -= 1
            arr[l], arr[more] = arr[more], arr[l]
        else:
            l += 1
    
    arr[more], arr[r] = arr[r], arr[more]
 
    return less, more

快速排序2.0

【<5 =5 > 5】

快速排序3.0

划分值 很偏，所以最坏。划分值如果在中间，就很好。
划分值随机选择一个。和最后一个位置交换。
O(NlogN)
空间复杂度O(logN)

 swap(arr, l + (int) (Math.random() * (r - l + 1)), r); //随机选择一个位置后最后一个位置交换