常见的所有排序算法和搜索算法

时光、相遇

已于 2022-10-19 14:54:45 修改

阅读量221

点赞数

文章标签：算法

于 2022-08-10 22:56:57 首次发布

本文链接：https://blog.csdn.net/fightrookie/article/details/126276124

版权

可以参考一个很全的文章：

(44条消息) 排序算法时间复杂度、空间复杂度、稳定性比较_blackboydec的博客-CSDN博客

排序算法

常见的排序算法的时间复杂度：

(13条消息) 排序算法时间复杂度、空间复杂度、稳定性比较_blackboydec的博客-CSDN博客_排序算法稳定性

1.快速排序（数组和链表都能实现）

基于“二分”的思想，最差的时间复杂度是 O(N^2), 平均时间复杂度是 O(NlogN)

例如： “6 1 2 7 9 3 4 5 10 8”十个数，进行快速排序，首先的流程是：

1先探测

1.1 先选择一个基准点（一个参考数）；

1.2 比6大的数放右边，比6小的数放左边——左右两个哨兵指针，左边找比基准数第一个大的，右边找比基准数第一个小的，如果找到，则互换位置；直到两个哨兵相遇，将基准数和相遇地方的数进行交换位置，则探测结束。

2 对基准数左右两端分别进行处理

2.1 6的左端序列依然继续找基准数

递归 2.1中的序列，左右分开

2.2 6的右端序列依然继续找基准数

递归 2.2中的序列，左右分开

3 最终处理结束，完成快排

参考别人的博客，写的快排的基本原理：

(13条消息) 快速排序（java实现）_大数据指北的博客-CSDN博客_快速排序java

对别人博客中的最原始的快排算法进行优化：

优化的地方在于：最开始的时候，随机选择基准数，这样的话，可以加快速度，减少探测的次数——也就是减少左右哨兵移动的次数。

具体代码如下：

    public static void main(String[] args) {
        int[] nums = {8, 4, -1, 3, 4, 5, -2, -4};
        quickSort(nums, 0, nums.length - 1);
        System.out.println(Arrays.toString(nums));
    }

    //主方法
    public int[] sortArray(int[] nums) {
        quickSort(nums, 0, nums.length - 1);
        return nums;
    }

    //使用random函数，为了后续的随机一个基准数的索引
    public static Random random = new Random();

    public static void quickSort(int[] nums, int start, int end) {
        if (start >= end) {
            return;
        }
        //优化，在[start,end]中随机选取一个作为基准索引
        int idx = start + random.nextInt(end - start + 1);
        //与start交换位置
        swap(nums, start, idx);
        //选定基准值，以起始坐标 start对应的数 作为基准数
        int baseValue = nums[start];
        int left = start, right = end;
        while (left < right) {
            //右指针向左寻找比基准值小的元素
            while (left < right && nums[right] >= baseValue) {
                right--;
            }
            //左指针向右寻找比基准值大的元素
            while (left < right && nums[left] <= baseValue) {
                left++;
            }
            swap(nums, left, right);
        }
        //此时的start = 0, right 其实在 while的时候，已经 -- 减减到了中间第一次探测 基准点的位置
        swap(nums, start, right);
        quickSort(nums, start, right - 1); //递归 第一次探测之后的左边序列
        quickSort(nums, right + 1, end); //递归 第二次探测之后的右边序列
    }

    public static void swap(int[] nums, int i, int j) {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }

2.归并排序（数组和链表都能实现）

原理：

1.先对数组进行折半拆分；

2.分成最小的单元之后，进行排序；

3.然后再对小的单元进行合并。

在对小的单元排序的时候，要先创建一个两倍待合并的单元长度的数组，然后三个指针，p、p1、p2，分别指向两倍长度数组的起始位置，两个小单元的起始位置，然后如果有一个填入的话（p1 和 p2元素较小的一个填入），则对应的小单元的指针向下移动一位，p指针每次都要向下移动一位。

(13条消息) 十大经典排序算法-归并排序算法详解_小小学编程的博客-CSDN博客_归并排序算法

具体代码如下：

public static void main(String[] args) {
    int[] nums = {8, 4, -1, 3, 4, 5, -2, -4};
    mergeSort(nums);
    System.out.println(Arrays.toString(nums));
}

//归并排序,主方法
public static void mergeSort(int[] nums) {
    int[] temp = splitAction(nums);
    System.arraycopy(temp, 0, nums, 0, temp.length);
}

//拆分
public static int[] splitAction(int[] nums) {
    if (nums.length <= 1) {
        return nums;
    }
    int mid = nums.length / 2;
    //找中间位置，分别copy 左右两边数组的元素
    int[] left = splitAction(Arrays.copyOfRange(nums, 0, mid));
    int[] right = splitAction(Arrays.copyOfRange(nums, mid, nums.length));
    return mergeAction(left, right);
}

//合并
public static int[] mergeAction(int[] left, int[] right) {
    int[] temp = new int[left.length + right.length];
    int l = 0, r = 0, idx = 0;
    while (l < left.length && r < right.length) {
        //取 l 和  r 中对应较小的元素，存放在 temp数组中
        if (left[l] < right[r]) {
            temp[idx++] = left[l++];
        } else {
            temp[idx++] = right[r++];
        }
    }
    //比较之后，会出现 左右小数组中还存有元素的情况，因此将 左右小数组中某一个数组中还存有的元素加入到temp数组
    while (l < left.length) {
        temp[idx++] = left[l++];
    }
    while (r < right.length) {
        temp[idx++] = right[r++];
    }
    return temp;
}

链表排序（快排和堆排的链表形式实现）

是leetcode 原题： 148. 排序链表 - 力扣（LeetCode）

思路借鉴：(13条消息) 链表排序——归并排序、快速排序_HerofH_的博客-CSDN博客

3.堆排序*****

堆排序的基本思想

1.先将所给的待排序的数组 构造成一个大顶堆；（元素上升的过程）

2.再交换堆顶位置元素和大顶堆末尾元素，每交换一次结束后，调整剩余的 n -1 个元素——使其仍然是大顶堆；（元素下降的过程）

3.直到交换完最后的元素，结束，输出结果就是一个从小到大的有序序列。

代码主要包含：

1 构造大顶堆；

2 交换位置再继续构造大顶堆；

3交换索引位置的值。

public static void main(String[] args) {
    int[] nums = {3, 1, 4, 2, 8, 5, 9, 7, 6};
    heapSort(nums);
    System.out.println(Arrays.toString(nums));
}

//堆排序思路：
public static void heapSort(int[] nums) {
    //1、构造大顶堆
    createHeap(nums);
    //2、调整大顶堆，让最大值放到最后(不参与下次堆调整)
    for (int j = nums.length - 1; j > 0; j--) {
        // //大顶堆构造完成后，nums[0]的位置就是最大值。将最大值交换到末尾
        swap(nums, 0, j);
        //将[0,j-1]范围内的元素调整为新的大顶堆
        adjustHeap(nums, 0, j - 1);
    }
}

//1、根据给定数组创建大顶堆，通过新插入的上升
public static void createHeap(int[] nums) {
    for (int i = 0; i < nums.length; i++) {
        //当前插入的索引
        int curIdx = i;
        //当前索引的父索引
        int fatherIdx = (i - 1) / 2;
        //如果当前索引的值 > 父节点的值，那么就交换，并且父节点成为当前节点继续向上比较，直到当前节点比父节点下
        while (nums[curIdx] > nums[fatherIdx]) {
            //交换位置
            swap(nums, curIdx, fatherIdx);
            //当前索引指向交换后的新索引位置
            curIdx = fatherIdx;
            //重新计算当前节点的父节点
            fatherIdx = (curIdx - 1) / 2;
        }
    }
}

//2、在范围[i,len]的范围内调整堆，堆顶下降
public static void adjustHeap(int[] nums, int idx, int len) {
    //当前节点的左右孩子节点的索引
    int leftIdx = 2 * idx + 1;
    int rightIdx = 2 * idx + 2;
    //只要还存在左右子节点，就继续走下边的逻辑
    while (leftIdx <= len || rightIdx <= len) { //边界条件，遍历左右子节点不能大于所有节点的个数范围
        //左右孩子中值最大的所在的索引
        int bigIdx = (rightIdx <= len && nums[rightIdx] > nums[leftIdx]) ? rightIdx : leftIdx;
        if (nums[idx] >= nums[bigIdx]) {
            break;
        }
        //如果当前节点小于左右节点中的最大值，那么应该交换位置，然后继续向下比较新的左右孩子节点
        //交换位置
        swap(nums, idx, bigIdx);
        
        //因为当前节点的子节点比当前节点大，因此交换完位置之后，将当前节点的索引更新成 其子节点的索引
        idx = bigIdx;
        //因为还要判断交换完之后，当前节点(小的) 和 下一次的左右子节点的位置
        //重新计算新的左右孩子节点所在的位置
        leftIdx = 2 * idx + 1;
        rightIdx = 2 * idx + 2;
    }
}

//交换元素
public static void swap(int[] nums, int i, int j) {
    int temp = nums[i];
    nums[i] = nums[j];
    nums[j] = temp;
}