关于排序的算法

最新推荐文章于 2024-10-30 11:20:30 发布
最新推荐文章于 2024-10-30 11:20:30 发布
阅读量55 收藏
点赞数 1
分类专栏： 计算机相关知识随笔 文章标签： 算法 排序算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_59335499/article/details/131023270
版权
本文详细介绍了几种常见的排序算法，包括冒泡排序、插入排序、选择排序、快速排序、归并排序和堆排序，阐述了它们的基本思想、实现步骤以及时间复杂度和空间复杂度。对于每种排序算法，都提供了C++和Java的代码实现，并附有注释和解释。
摘要由CSDN通过智能技术生成

关于排序算法有如下分类

 常用的几种排序算法有以下几个：

1.冒泡排序（Bubble Sort）：

通过比较相邻元素的大小，依次交换相邻元素的位置，直到所有元素按照从小到大（或从大到小）的顺序排列。

冒泡排序是一种基本的排序算法，它的基本思想是通过不断比较相邻的两个元素，将较大（或较小）的元素向后交换，从而达到排序的目的。具体实现如下：

1.比较相邻的元素。如果第一个比第二个大，就交换它们两个。

2.对每一对相邻的元素进行比较，从第一对到最后一对。这样，最后的元素应该是最大的数。

3.针对所有的元素重复以上的步骤，除了最后一个。

4.持续每次对越来越少的元素重复上述步骤，直到没有任何一对数字需要比较。

下面是C++实现冒泡排序的 Java 代码实现

下面是Java实现冒泡排序的 Java 代码实现

​
public static void bubbleSort(int[] arr) {
    int temp;//临时变量
    boolean flag;//标识变量，表示是否进行过交换
    //外层循环控制排序趟数
    for (int i = 0; i < arr.length - 1; i++) {
        flag = false;//每次开始排序前，都设置flag为未排序过
        //内层循环控制每一趟排序多少次
        for (int j = 0; j < arr.length - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {//如果前面的数比后面的数大，则交换
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                flag = true;//只要有交换，flag就置为true
            }
        }
        if (!flag) {//如果没有交换过元素，则已经有序，退出循环
            break;
        }
    }
}

​

2.插入排序（Insertion Sort）：

将一个元素插入到已排好序的数组中，使得插入后的数组仍然有序。

当我们使用插入排序算法时，我们将一个元素插入到已经排好序的数组中，使得插入后的数组仍然有序。假设我们在排序过程中，待排序的数组L[1...n]在某个时刻的状态如下：

我们需要将元素L(i)插入到已经有序的子序列L[1...i-1]中。为了完成这个操作，我们需要执行以下步骤：

  1. 查找L(i)在L[1...i-1]中的插入位置k。
  2. 将L[k...i-1]中的所有元素依次后移一个位置。
  3. 将L(i)复制到L(k)。

为了实现对数组L[1...n]的排序，我们可以将L(2)~L(n)依次插入到前面已经排好序的子序列中，初始时，我们可以将L[1]视为已经排好序的子序列。上述操作执行n-1次就能得到一个有序的数组。插入排序通常采用就地排序的方式，因此空间复杂度为O(1)。在从后向前的比较过程中，我们需要反复将已经排好序的元素逐步向后移动，为新元素提供插入空间。

 

 

以下是插入排序算法的C语言和Java代码实现，附有注释和讲解：

C语言代码实现：

#include <stdio.h>

void insertion_sort(int arr[], int n) {
    int i, j, key;
    for (i = 1; i < n; i++) {
        key = arr[i];
        j = i - 1;
        // 将比key大的元素向后移动，为key腾出位置
        while (j >= 0 && arr[j] > key) {
            arr[j+1] = arr[j];
            j--;
        }
        arr[j+1] = key;
    }
}

int main() {
    int arr[] = {5, 2, 4, 6, 1, 3};
    int n = sizeof(arr) / sizeof(arr[0]);
    insertion_sort(arr, n);
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    return 0;
}

Java代码实现：

public class InsertionSort {
    public static void insertionSort(int[] arr) {
        int n = arr.length;
        for (int i = 1; i < n; i++) {
            int key = arr[i];
            int j = i - 1;
            // 将比key大的元素向后移动，为key腾出
            while (j >= 0 && arr[j] > key) {
                arr[j+1] = arr[j];
                j--;
            }
            arr[j+1] = key;
        }
    }

    public static void main(String[] args) {
        int[] arr = {5, 2, 4, 6, 1, 3};
        insertionSort(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

注释和讲解：

在这两份代码中，我们都定义了一个名为insertion_sort（C语言）或insertionSort（Java）的函数来实现插入排序算法。在函数内部，我们使用了两个循环来实现排序。外层循环从第二个元素开始，依次将每个元素插入到前面已经排好序的子序列中。内层循环则用来将比当前元素大的元素向后移动，为当前元素腾出位置。

在C语言代码中，我们使用了一个while循环来将比当前元素大的元素向后移动。当找到一个比当前元素小的元素时，我们就将当前元素插入到这个元素的后面。在Java代码中，使用了一个for循环来实现相同的功能。当找到一个比当前元素小的元素时，我们就将当前元素插入到这个元素的后面。

在插入排序算法中，我们需要使用两个循环来完成排序，因此时间复杂度为O(n^2)。但是，由于插入排序算法具有就地排序的特点，因此空间复杂度为O(1)。

3.选择排序（Selection Sort）：

每次选择数组中最小（或最大）的元素，将其放在数组的起始位置，然后再在剩余的元素中选择最小（或最大）的元素，放在已排序元素的末尾，直到所有元素有序。

假设排序元素为L【1,2.....n】   括号中代表元素次序1就是第一个元素，n就是第n各元素。

选择排序的基本思想是从第一个元素开始依次与其余元素对比，比值小则换位，然后取第二个元素依次向后继续比较大小，与之小则换位。选择排序的每一轮都会选择未排序序列中的最小元素，将其与未排序序列的第一个元素进行交换，从而不断缩小未排序序列的范围。在上面的例子中，选择排序的第一轮中，4和序列中的其他元素进行比较，找到最小的元素1，然后将4和1进行交换，因此4与1进行了交换。

#include <stdio.h>

void selection_sort(int arr[], int len) {
    for (int i = 0; i < len - 1; i++) {  // 外层循环控制排序轮数
        int min_index = i;  // 记录最小值的下标
        for (int j = i + 1; j < len; j++) {  // 内层循环查找最小值
            if (arr[j] < arr[min_index]) {
                min_index = j;
            }
        }
        if (min_index != i) {  // 如果最小值不是当前位置，则交换两个位置的元素
            int temp = arr[i];
            arr[i] = arr[min_index];
            arr[min_index] = temp;
        }
    }
}

int main() {
    int arr[] = { 5, 3, 8, 4, 2, 7, 1, 6 };
    int len = sizeof(arr) / sizeof(arr[0]);
    selection_sort(arr, len);
    for (int i = 0; i < len; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    return 0;
}

Java的选择排序实现：

public class SelectionSort {
    public static void selectionSort(int[] arr) {
        int len = arr.length;
        for (int i = 0; i < len - 1; i++) {  // 外层循环控制排序轮数
            int minIndex = i;  // 记录最小值的下标
            for (int j = i + 1; j < len; j++) {  // 内层循环查找最小值
                if (arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            if (minIndex != i) {  // 如果最小值不是当前位置，则交换两个位置的元素
                int temp = arr[i];
                arr[i] = arr[minIndex];
                arr[minIndex] = temp;
            }
        }
    }

    public static void main(String[] args) {
        int[] arr = {5, 3, 8, 4, 2, 7, 1, 6};
        selectionSort(arr);
        for (int i : arr) {
            System.out.print(i + " ");
        }
        System.out.println();
    }
}

4快速排序（Quick Sort）:

是一种高效的排序算法，它采用分治的思想，将一个大问题分解成若干个小问题来解决。快速排序的基本思想是：选择一个基准元素，将数组中小于基准元素的元素放在基准元素的左边，将大于基准元素的元素放在基准元素的右边，然后递归地对左右两个子数组进行排序，最终将整个数组排序。

快速排序的具体实现过程如下：

  1. 选择一个基准元素，一般选择第一个元素或者最后一个元素；
  2. 将数组中小于基准元素的元素放在基准元素的左边，大于基准元素的元素放在基准元素的右边；
  3. 对左右两个子数组分别递归地进行快速排序，直到子数组的长度为1或0。

快速排序的时间复杂度为O(nlogn)，空间复杂度为O(logn)，是一种非常高效的排序算法。

 

以下是快速排序的C语言实现，附有注释和讲解：

#include <stdio.h>

void quick_sort(int arr[], int left, int right) {
    if (left >= right) {  // 如果左右指针相遇，则返回
        return;
    }
    int i = left, j = right, pivot = arr[left];  // 初始化左右指针和基准元素
    while (i < j) {
        while (i < j && arr[j] >= pivot) {  // 从右往左找第一个小于基准元素的数
            j--;
        }
        if (i < j) {
            arr[i++] = arr[j];  // 将该数放到左边
        }
        while (i < j && arr[i] < pivot) {  // 从左往右找第一个大于等于基准元素的数
            i++;
        }
        if (i < j) {
            arr[j--] = arr[i];  // 将该数放到右边
        }
    }
    arr[i] = pivot;  // 将基准元素放到正确的位置
    quick_sort(arr, left, i - 1);  // 对左边的序列进行快速排序
    quick_sort(arr, i + 1, right);  // 对右边的序列进行快速排序
}

int main() {
    int arr[] = { 5, 3, 8, 4, 2, 7, 1, 6 };
    int len = sizeof(arr) / sizeof(arr[0]);
    quick_sort(arr, 0, len - 1);
    for (int i = 0; i < len; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    return 0;
}

c复制代码

注释：

  • void quick_sort(int arr[], int left, int right)：快速排序函数，参数包括待排序数组、左指针和右指针。
  • if (left >= right)：如果左右指针相遇，则返回。
  • int i = left, j = right, pivot = arr[left]：初始化左右指针和基准元素。
  • while (i < j)：当左右指针未相遇时，进行以下操作：
    • while (i < j && arr[j] >= pivot)：从右往左找第一个小于基准元素的数。
    • if (i < j)：如果找到了，则将该数放到左边。
    • while (i < j && arr[i] < pivot)：从左往右找第一个大于等于基准元素的数。
    • if (i < j)：如果找到了，则将该数放到右边。
  • arr[i] = pivot：将基准元素放到正确的位置。
  • quick_sort(arr, left, i - 1)：对左边的序列进行快速排序。
  • quick_sort(arr, i + 1, right)：对右边的序列进行快速排序。

快速排序的时间复杂度为O(nlogn)，是一种高效的排序算法。

以下是基础的快速排序的Java实现代码，同样加上了注释和讲解：

public class QuickSort {
    public static void main(String[] args) {
        int[] arr = {3, 1, 5, 2, 4, 9, 7, 6, 8}; // 定义一个包含9个元素的整型数组

        quickSort(arr, 0, arr.length - 1); // 调用快速排序算法对数组进行排序

        System.out.print("Sorted integers: "); // 输出排序后的整数
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " "); // 依次输出数组中的每个元素
        }
    }

    /**
     * 快速排序算法
     * @param arr 待排序的数组
     * @param left 数组的左边界
     * @param right 数组的右边界
     */
    public static void quickSort(int[] arr, int left, int right) {
        if (left >= right) { // 如果左边界大于等于右边界，直接返回
            return;
        }

        int i = left, j = right; // 定义两个指针i和j，分别指向数组的左右两端
        int pivot = arr[left]; // 选择第一个元素作为基准元素

        while (i < j) { // 循环执行以下操作，直到i >= j
            while (i < j && arr[j] >= pivot) { // 从右向左找到第一个小于基准元素的元素
                j--;
            }
            if (i < j) { // 如果i < j，将该元素移到左边
                arr[i++] = arr[j];
            }

            while (i < j && arr[i] < pivot) { // 从左向右找到第一个大于等于基准元素的元素
                i++;
            }
            if (i < j) { // 如果i < j，将该元素移到右边
                arr[j--] = arr[i];
            }
        }

        arr[i] = pivot; // 将基准元素放到正确的位置上

        quickSort(arr, left, i - 1); // 对左边的子数组进行快速排序
        quickSort(arr, i + 1, right); // 对右边的子数组进行快速排序
    }
}

在上面的代码中，我们使用了递归的方式来实现快速排序。在快速排序算法中，我们首先选择一个基准元素，将数组中小于基准元素的元素放在基准元素的左边，大于基准元素的元素放在基准元素的右边。然后，我们对左右两个子数组分别递归地进行快速排序，直到子数组的长度为1或0。

需要注意的是，在快速排序算法中，我们使用了两个指针i和j来遍历数组，i指向数组的左端，j指向数组的右端。在每一轮循环中，我们先从右向左找到第一个小于基准元素的元素，然后从左向右找到第一个大于等于基准元素的元素，将它们交换位置。最终，基准元素就被放到了正确的位置上。

填坑法是一种基于快速排序的优化算法，它的思路是：在快速排序中，我们需要将小于基准元素的元素放在基准元素的左边，大于基准元素的元素放在基准元素的右边，这样的话，每次交换都需要移动多个元素，效率较低。因此，我们可以将交换操作转化为填坑操作，即先将基准元素保存到一个临时变量中，然后将空出来的位置填上小于基准元素的元素，最后将基准元素填到空出来的位置上。这样，每次交换只需要移动一个元素，效率更高。

以下是快速排序(填坑法)的Java实现代码，同样加上了注释和讲解：

public class QuickSort {
    public static void main(String[] args) {
        int[] arr = {3, 1, 5, 2, 4, 9, 7, 6, 8}; // 定义一个包含9个元素的整型数组

        quickSort(arr, 0, arr.length - 1); // 调用快速排序算法对数组进行排序

        System.out.print("Sorted integers: "); // 输出排序后的整数
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " "); // 依次输出数组中的每个元素
        }
    }

    /**
     * 快速排序算法（填坑法）
     * @param arr 待排序的数组
     * @param left 数组的左边界
     * @param right 数组的右边界
     */
    public static void quickSort(int[] arr, int left, int right) {
        if (left >= right) { // 如果左边界大于等于右边界，直接返回
            return;
        }

        int i = left, j = right; // 定义两个指针i和j，分别指向数组的左右两端
        int pivot = arr[left]; // 选择第一个元素作为基准元素

        while (i < j) { // 循环执行以下操作，直到i >= j
            while (i < j && arr[j] >= pivot) { // 从右向左找到第一个小于基准元素的元素
                j--;
            }
            if (i < j) { // 如果i < j，将该元素填到左边的空位上
                arr[i] = arr[j];
                i++;
            }

            while (i < j && arr[i] < pivot) { // 从左向右找到第一个大于等于基准元素的元素
                i++;
            }
            if (i < j) { // 如果i < j，将该元素填到右边的空位上
                arr[j] = arr[i];
                j--;
            }
        }

        arr[i] = pivot; // 将基准元素填到正确的位置上

        quickSort(arr, left, i - 1); // 对左边的子数组进行快速排序
        quickSort(arr, i + 1, right); // 对右边的子数组进行快速排序
    }
}

在填坑法的实现中，我们使用了两个指针i和j来遍历数组，i指向数组的左端，j指向数组的右端。在每一轮循环中，我们先从右向左找到第一个小于基准元素的元素，然后将它填到左边的空位上；然后从左向右找到第一个大于等于基准元素的元素，将它填到右边的空位上。最终，基准元素就被填到了正确的位置上。

5.归并排序（Merge Sort）：

归并排序是一种基于分治思想的排序算法。它的基本思想是将待排序的序列分成若干个子序列，分别进行排序，然后再将排好序的子序列合并成一个有序的序列。归并排序的主要过程可以分为两个步骤：

  1. 分割：将待排序的序列从中间分成两个子序列，再对子序列进行分割，直到每个子序列只有一个元素为止。

  2. 合并：将两个已经排好序的子序列合并成一个有序的序列，再将多个有序的子序列合并成一个完整的有序序列。

归并排序的时间复杂度为O(nlogn)，空间复杂度为O(n)。它是一种稳定的排序算法，适用于各种数据类型的排序。但是，归并排序需要额外的空间来存储分割后的子序列，因此在排序大规模数据时，可能会出现空间不足的问题。

 

C语言实现：

#include <stdio.h>

void merge(int arr[], int l, int m, int r) {
    int i, j, k;
    int n1 = m - l + 1;
    int n2 = r - m;

    // 创建两个临时数组
    int L[n1], R[n2];

    // 将数据复制到临时数组中
    for (i = 0; i < n1; i++)
        L[i] = arr[l + i];
    for (j = 0; j < n2; j++)
        R[j] = arr[m + 1 + j];

    // 合并临时数组
    i = 0;
    j = 0;
    k = l;
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k] = L[i];
            i++;
        } else {
            arr[k] = R[j];
            j++;
        }
        k++;
    }

    // 处理剩余元素
    while (i < n1) {
        arr[k] = L[i];
        i++;
        k++;
    }

    while (j < n2) {
        arr[k] = R[j];
        j++;
        k++;
    }
}

void mergeSort(int arr[], int l, int r) {
    if (l < r) {
        int m = l + (r - l) / 2;

        // 递归分解左右两部分
        mergeSort(arr, l, m);
        mergeSort(arr, m + 1, r);

        // 合并左右两部分
        merge(arr, l, m, r);
    }
}

int main() {
    int arr[] = { 38, 27, 43, 3, 9, 82, 10 };
    int n = sizeof(arr) / sizeof(arr[0]);

    mergeSort(arr, 0, n - 1);

    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);
    printf("\n");

    return 0;
}

Java实现：

public class MergeSort {
    public static void merge(int arr[], int l, int m, int r) {
        int i, j, k;
        int n1 = m - l + 1;
        int n2 = r - m;

        // 创建两个临时数组
        int L[] = new int[n1];
        int R[] = new int[n2];

        // 将数据复制到临时数组中
        for (i = 0; i < n1; i++)
            L[i] = arr[l + i];
        for (j = 0; j < n2; j++)
            R[j] = arr[m + 1 + j];

        // 合并临时数组
        i = 0;
        j = 0;
        k = l;
        while (i < n1 && j < n2) {
            if (L[i] <= R[j]) {
                arr[k] = L[i];
                i++;
            } else {
                arr[k] = R[j];
                j++;
            }
            k++;
        }

        // 处理剩余元素
        while (i < n1) {
            arr[k] = L[i];
            i++;
            k++;
        }

        while (j < n2) {
            arr[k] = R[j];
            j++;
            k++;
        }
    }

    public static void mergeSort(int arr[], int l, int r) {
        if (l < r) {
            int m = l + (r - l) / 2;

            // 递归分解左右两部分
            mergeSort(arr, l, m);
            mergeSort(arr, m + 1, r);

            // 合并左右两部分
            merge(arr, l, m, r);
        }
    }

    public static void main(String args[]) {
        int arr[] = { 38, 27, 43, 3, 9, 82, 10 };
        int n = arr.length;

        mergeSort(arr, 0, n - 1);

        for (int i = 0; i < n; i++)
            System.out.print(arr[i] + " ");
        System.out.println();
    }
}

6.堆排序（Heap Sort）：

将数组看成一颗完全二叉树，将其转换为一个大根堆或小根堆，然后依次取出堆顶元素，将其放在已排序元素的末尾，直到所有元素有序。

堆排序（Heap Sort）是一种基于完全二叉树的排序算法，其基本思想是将待排序的数组看成一颗完全二叉树，然后将其转换为一个大根堆或小根堆。在大根堆中，每个父节点的值都大于等于其子节点的值；在小根堆中，每个父节点的值都小于等于其子节点的值。堆排序的基本步骤如下：

  1. 将待排序的数组转换为一个大根堆或小根堆。

  2. 取出堆顶元素，将其放在已排序元素的末尾。

  3. 调整剩余元素，使其仍然成为一个大根堆或小根堆。

  4. 重复步骤2和步骤3，直到所有元素有序。

具体实现过程如下：

  1. 将待排序的数组转换为一个大根堆或小根堆。

  2. 取出堆顶元素，将其放在已排序元素的末尾。

  3. 调整剩余元素，使其仍然成为一个大根堆或小根堆。

  4. 重复步骤2和步骤3，直到所有元素有序。

堆排序的时间复杂度为O(nlogn)，空间复杂度为O(1)。由于堆排序需要进行大量的数据移动，因此其常数项比较大，不适合处理小规模的数据。

C语言实现：

#include <stdio.h>

void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

void heapify(int arr[], int n, int i) {
    int largest = i;
    int l = 2 * i + 1;
    int r = 2 * i + 2;

    if (l < n && arr[l] > arr[largest])
        largest = l;

    if (r < n && arr[r] > arr[largest])
        largest = r;

    if (largest != i) {
        swap(&arr[i], &arr[largest]);
        heapify(arr, n, largest);
    }
}

void heapSort(int arr[], int n) {
    for (int i = n / 2 - 1; i >= 0; i--)
        heapify(arr, n, i);

    for (int i = n - 1; i >= 0; i--) {
        swap(&arr[0], &arr[i]);
        heapify(arr, i, 0);
    }
}

int main() {
    int arr[] = { 38, 27, 43, 3, 9, 82, 10 };
    int n = sizeof(arr) / sizeof(arr[0]);

    heapSort(arr, n);

    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);
    printf("\n");

    return 0;
}

Java实现：

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

    public static void heapify(int arr[], int n, int i) {
        int largest = i;
        int l = 2 * i + 1;
        int r = 2 * i + 2;

        if (l < n && arr[l] > arr[largest])
            largest = l;

        if (r < n && arr[r] > arr[largest])
            largest = r;

        if (largest != i) {
            swap(arr, i, largest);
            heapify(arr, n, largest);
        }
    }

    public static void heapSort(int arr[], int n) {
        for (int i = n / 2 - 1; i >= 0; i--)
            heapify(arr, n, i);

        for (int i = n - 1; i >= 0; i--) {
            swap(arr, 0, i);
            heapify(arr, i, 0);
        }
    }

    public static void main(String args[]) {
        int arr[] = { 38, 27, 43, 3, 9, 82, 10 };
        int n = arr.length;

        heapSort(arr, n);

        for (int i = 0; i < n; i++)
            System.out.print(arr[i] + " ");
        System.out.println();
    }
}
ヾ草木萤火(≧▽≦*)o
关注
专栏目录
自己关于排序算法的总结.pdf
07-01
几乎把网上的排序算法小结找遍了，简单地小结一下算法的思路（不含代码，只是用易懂的话说清楚算法是怎么做的），算法时间复杂度和空间复杂的求法（用理解的方式而不是分析代码），各种排序算法的优缺点，稳定与否...
python常用排序算法汇总
02-19
该程序包含7大排序算法: # sort.bubbleSort() #冒泡排序 # sort.shellSort() #希尔排序 # sort.insertionSort() #插入排序 # sort.Selectionsort1() #选择排序 # sort.heapSort() #堆排序 # sort.countSort() ...
常用排序算法
zzh123353的博客
08-25 387
文章目录前言冒泡排序介绍优化选择排序介绍优化插入排序希尔排序堆排序快速排序基数排序归并排序总结 前言 介绍几种常用的排序算法,自己写了部分代码 冒泡排序 介绍 冒泡排序是比较基础的排序算法之一，其思想是相邻的元素两两比较，较大的数下沉，较小的数冒起来，这样一趟比较下来，最大(小)值就会排列在一端。整个过程如同气泡冒起，因此被称作冒泡排序。 冒泡排序的步骤：、 1>比较相邻的元素。如果第一个比第二个大，就交换他们两个。 2>每趟从第一对相邻元素开始，对每一对相邻元素作同样的工作，直到最后一对。
十大排序之(冒泡排序、选择排序、插入排序）
qq_44272681的博客
09-02 155
一、冒泡排序 冒泡排序的基本思想是两两比较相邻元素，如果反序则交换。因为越小的元素会经由交换以升序或降序的方式慢慢浮到数列的顶端，就如同碳酸饮料中二氧化碳的气泡上浮到顶端一样，故名冒泡排序。 算法实现 从第一个元素开始一个一个的比较相邻的元素，如果第一个比第二个大即a[1]>a[2]，就彼此交换。 从第一对到最后一对，对每一对相邻元素做一样的操作。此时在最后的元素应该会是最大的数，这样的操作为一趟冒泡排序。 针对所有的元素重复以上的步骤，每一趟得到的最大值已放在最后，下
排序算法——冒泡排序
程序员之道
08-06 1197
排序算法——冒泡排序 冒泡排序：比较相邻的元素。如果第一个比第二个大，就交换他们两个。对每一对相邻元素做同样的比较，从开始的第一对到结尾的最后一对。通过每一趟的比较，最后的元素是最大的数。针对所有的元素重复以上的步骤，除了最后一个。每趟的比较次数会越来越少，直到没有任何一对数字需要比较。 冒泡排序就是通过每趟排序过程中的两两比较，找到最大的元素，将其往后排。 例如一组数组{9,8,7,6,5,...
七大排序算法
yahid的博客
06-28 1万+
排序：排序就是对某项数据按照特定的要求，比如大小或字符长短等按照升序或降序排序。排序过程中设计稳定性，稳定性指的是若有两个相同的数字，比如1和1。如果排序前1在1的前面，排完序后1还在1的前面。那么就说这个排序算法是稳定的，相反则说明不稳定。注意：如果本身就是一个稳定的排序，可以将其变成不稳定排序；如果本身就是不稳定排序，不能变成稳定的排序。常见的排序方法 上面是基于比较的排序。下面一个一个的分析一：直接插入排序 直接插入排序指的是将新的数据插入在已经排好序的序列中。比如我们生活中的玩的斗地主，我们需要将新
关于排序算法中关键字初始排列顺序问题
fu_jian_ping的博客
04-13 3709
与数组初始状态无关的内排序算法 首先，与初始状态无关分为几种情况 1、算法复杂度与初始状态无关； 2、元素总比较次数与初始状态无关； 3、元素总移动次数与初始状态无关。 【其实还有一种就是总排序趟数与初始状态无关，由于分析简单，除了快速排序的排序次数（递归深度）与关键字选择（初始状态）有关，还有一个优化后的冒泡排序和后序是否有序有关，其他均只与总长度n有关，与初始状态无关，故不做分...
算法学习总结（2）——温故十大经典排序算法
热门推荐
科技D人生
08-29 5万+
一、什么是排序算法 1.1、排序定义 对一序列对象根据某个关键字进行排序。 1.2、排序术语 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面；不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面；内排序：所有排序操作都在内存中完成；外排序：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行；时间复杂度：一个算法执行所耗费的时间。空间...
排序算法动画网站
baiqi123456的博客
08-16 2279
排序算法动画网站
图解快速排序算法
chenchenchencl的博客
08-23 6981
3分钟学会快速排序算法
快速排序算法
鹏鹏2077
05-08 5145
快速排序（Quicksort），计算机科学词汇，适用领域Pascal，c++等语言，是对冒泡排序算法的一种改进。本次实现使用的Java代码。快速排序是一种高效的排序算法，其核心思想是分治法。快速排序的基本思路是先选取一个枢轴元素，通过一趟排序将待排序序列分成两部分，其中左边部分的所有元素都小于等于枢轴元素，右边部分的所有元素都大于等于枢轴元素，然后分别递归地对左右两部分进行排序，直到整个序列有序。
猴子排序算法
qq_41757528的博客
10-05 3760
该定理内容大致为：给一只猴子一台打印机，虽然这只猴子根本不识字，但会乱按，经过一段时间后，在它乱按出来的单词里总能找到一些至少看起来是有意义的部分，比如一两个简短的单词，由此可以推出：只要给它足够长的时间，猴子甚至能完整地写出一本莎士比亚全集。千百年来，衔尾蛇被赋予了数不清的意义，其中就包括较易理解的“循环”，“无限”，以及偏向神学概念的“生死循环”与“轮回”，还有现代科学意义上的“熵增”，甚至惊天动地的“宇宙真理”。猴子算法的意义更多的是理论上的而非应用上，它打破了排序算法时间复杂度的极限，在。
最快的排序算法 计算机最快的算法-史上14个最快速算法：孩子的计算能力爆表！大脑堪比计算机！...，排序算法数据结构
04-07
在计算机科学领域中，排序算法是一种基本的算法，它可以将数据按照一定的顺序排列，以便更好地存储、检索和处理数据。排序算法的速度和效率对程序的性能有着至关重要的影响。 1.冒泡排序算法 冒泡排序算法是一种...
排序算法介绍.zip基础算法
03-27
在“排序算法介绍.zip基础算法”这个压缩包中，我们很可能会找到关于各种排序算法的详细讲解，包括它们的基本原理、实现方式以及性能分析。下面我们将深入探讨排序算法的一些主要知识点。 1. **冒泡排序**：是最...
十大排序算法
10-16
常见10大算法，从原理，动图解析到代码实现，逐步分析，让你轻松入门算法
代码随想录训练营Day12 | 110.平衡二叉树 - 257二叉树的所有路径 - 404.左叶子之和 - 222.完全二叉树的节点个数
Zuoriqiufeng的博客
10-30 392
【代码】代码随想录训练营Day12 | 110.平衡二叉树 - 257二叉树的所有路径 - 404.左叶子之和 - 222.完全二叉树的节点个数。
xtu oj 连接字符串
最新发布
Go offline for a while
10-30 960
最后总结一下：这题思路比较直观，找公共的元素，代码细节比较多，一个是要求输出字典序小的，第二是前面字符串要枚举完最后一个元素才算满足条件，第三是两个字符串可能完全没有公共部分，需要特判。
【力扣打卡系列】二分查找(搜索旋转排序数组)
qq_45734745的博客
10-29 291
坚持按题型打卡&刷&梳理力扣算法题系列，语言为go，Day11。
【算法】Kruskal最小生成树算法
Eristic0618的博客
10-29 723
算法学习笔记之Kruskal最小生成树算法
排序算法详解与性能测试
"这篇文档是关于排序算法的总结，涵盖了多种排序方法的优缺点，并提供了通用的测试程序来衡量不同排序算法的效率。" 在计算机科学中，排序算法是用于组织数据的重要工具，它们能够按照特定顺序（如升序或降序）重新...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ヾ草木萤火(≧▽≦*)o

希望大家多多支持，我会继续分享

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值