数据结构与算法从零开始系列：冒泡排序、选择排序、插入排序、希尔排序、堆排序、快速排序、归并排序、基数排序

最新推荐文章于 2024-07-03 19:13:37 发布

许英俊潇洒

最新推荐文章于 2024-07-03 19:13:37 发布

阅读量2.9k

点赞数 10

文章标签： java 算法数据结构 c语言

本文链接：https://blog.csdn.net/qq_30379689/article/details/58254148

版权

欢迎Star，本文的所有示例源码都在Github:https://github.com/AndroidHensen/Arithmetic

本篇内容包含

排序的介绍
排序的C的实现
排序的Java的实现
排序的时间复杂度的计算

（一）冒泡排序

1、基本思想：

两个数比较大小，较大的数下沉，较小的数冒起来

2、实现步骤：

这张图就是将数字12，35，99，18，76竖起来

第一次：从底部有一个气泡，圈住12并且和35对比，如果比上面小就交换，气泡往上升
第二次：12和99对比，如果比上面小就交换，气泡往上升
第三次：重复上面的操作，最后可以把12排到最上面

3、这张图模拟了冒泡排序的整个过程

第一个红色框表示气泡
两个红色框表示比较大小
黑色框表示已经排好的数字
最后排成有序的数字

冒泡排序的C的实现

1、程序优化：

这里加了一个flag作为优化程序的条件，如果程序未进入内循环，说明数字已经排序好了，后面的比较也就没有意义了，直接程序结束

2、实现口诀：

两数相抱转个圈

3、易犯错误：

忘记添加优化flag

#include<stdio.h>

void bubbleSort(int arr[],int n){
    int i,j,flag;
    for (i = 1; i < n; i++) {
        flag = 0;
        for (j = 0; j < n-i; j++) {
            if(arr[j]<arr[j+1]){
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
                flag =1;
            }
        }
        if(flag == 0)break;
    }
}

void main(){
    int i;
    int arr[10] = {1, 4, 8, 3, 2, 9, 5, 0, 7, 6};
    bubbleSort(arr, 10);

    //9,8,7,6,5,4,3,2,1,0,
    for(i=0; i<10; i++){
        printf("%d,", arr[i]);
    }
}

冒泡排序的Java的实现

public class BubbleSort {

    public void bubbleSort(int[] arr,int n){
        boolean flag;
        for (int i = 1; i < n; i++) {
            flag = false;
            for (int j = 0; j < n-i; j++) {
                if(arr[j]<arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                    flag =true;
                }
            }
            if(!flag)break;
        }
    }

    public static void main(String[] args) {
        int[] arr = {1, 4, 8, 3, 2, 9, 5, 0, 7, 6};
        BubbleSort sort = new BubbleSort();
        sort.bubbleSort(arr, arr.length);

        //9,8,7,6,5,4,3,2,1,0,
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+",");
        }
    }
}

冒泡排序的时间复杂度的计算

1、我们从代码分析，可以知道有两个循环

外循环：执行(n-1)次，当最坏的情况下，会执行n次，虽然最后一次(i < n)不通过，但还是算一次，其中里面有一条赋值语句
内循环：在(i=1,2,3…n-1)，执行(n-i)次，即(n-1,n-2…1)，其中有四条赋值语句

2、那么就可以计算出各自复杂度

外循环：最坏情况下是(1 x n)次
内循环：通过等差数列求和公式，(n-1+n-2+…1)=n^2/2

3、根据推导大O阶规则来进行推导

用常数1来取代运行时间中所有加法常数
修改后的运行次数函数中，只保留最高阶项
如果最高阶项存在且不是1，则去除与这个项相乘的常数

4、得到的冒泡排序的复杂度的大O表示法为

(1xn)+(n^2/2) ≈ n^2 = O(n^2)

（二）选择排序

1、基本思想：

让第一个数与后面的所有数一个个比较，找出最小的数，将最小的数跟第一个数交换
接着从第二个数开始，继续上面的操作

2、实现步骤：

选择排序的C的实现

1、注意点：

用语言实现排序的时候，只是记录着最小值的下标，接着用最小值的下标继续和后面的数进行比较，这是和思路不同的地方

2、实现口诀：

角标互换

3、易犯错误：

忘记添加角标判断

#include<stdio.h>

void selectSort(int arr[],int n){
    int i,j,minIndex;
    for (i = 0; i < n-1; i++) {
        minIndex = i;
        for (j = i+1; j < n; j++) {
            if(arr[j]<arr[minIndex]){
                minIndex = j;
            }
        }
        if(minIndex!=i){
            int temp = arr[minIndex];
            arr[minIndex] = arr[i];
            arr[i] = temp;
        }
    }
}
void main(){
    int i;
    int arr[8] = {3, 1, 5, 7, 2, 4, 9, 6};
    selectSort(arr, 8);

    //1,2,3,4,5,6,7,9,
    for(i=0; i<8; i++){
        printf("%d,", arr[i]);
    }
}

选择排序的Java的实现

public class SelectSort {

    public void selectSort(int arr[], int n) {
        for (int i = 0; i < n - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < n; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            if (minIndex != i) {
                int temp = arr[minIndex];
                arr[minIndex] = arr[i];
                arr[i] = temp;
            }
        }
    }

    public static void main(String[] args) {
        int[] arr = {3, 1, 5, 7, 2, 4, 9, 6};
        SelectSort sort = new SelectSort();
        sort.selectSort(arr, arr.length);

        //1,2,3,4,5,6,7,9,
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + ",");
        }
    }
}

选择排序的时间复杂度的计算

1、我们从代码分析，可以知道有两个循环

外循环：执行(n-1)次，当最坏的情况下，会执行n次，虽然最后一次(i < n)不通过，但还是算一次，其中里面有四条赋值语句
内循环：在(j=1,2,3…n-1)，执行(n-i)次，即(n-1,n-2…1)，其中有一条赋值语句

2、那么就可以计算出各自复杂度

外循环：最坏情况下是(4 x n)次
内循环：通过等差数列求和公式，(n-1+n-2+…1)=n^2/2

3、复杂度的大O表示法为

(4xn)+(1x(n^2/2)) ≈ n^2 = O(n^2)

（三）插入排序

1、基本思想：

其实就是你玩扑克牌的时候，排序你自己的牌的思路
从后面抽出牌，插入到前面的牌中

2、实现步骤：

初始值：1, 4, 8, 3, 2, 9, 5, 0, 7, 6
第一次：抽出牌4，与1对比，发现比它大，不交换
第二次：抽出牌8，与4对比，发现比它大，不交换
第三次：抽出牌3，与8对比，发现比它小，交换，继续与前面一个数比，与4对比，发现比它小，交换，继续与前面一个数比，与1对比，发现比它大，不交换
第四次：重复上面步骤，完成扑克牌排序

插入排序的C的实现

1、实现口诀：

扑克牌往回插

2、易犯错误：

忘记退出的break

#include<stdio.h>

void insertSort(int arr[],int n){
    int i,j;
    for (i = 0; i < n - 1; i++) {
        for (j = i + 1; j > 0; j--) {
            if (arr[j] < arr[j - 1]) {
                int temp = arr[j];
                arr[j] = arr[j - 1];
                arr[j - 1] = temp;
            } else {
                break;
            }
        }
    }
}

void main(){
    int i;
    int arr[10] = {1, 4, 8, 3, 2, 9, 5, 0, 7, 6};
    insertSort(arr, 10);

    //0,1,2,3,4,5,6,7,8,9,
    for(i=0; i<10; i++){
        printf("%d,", arr[i]);
    }
}

插入排序的Java的实现

public class InsertSort {

    public void insertSort(int[] arr, int n) {
        for (int i = 0; i < n - 1; i++) {
            for (int j = i + 1; j > 0; j--) {
                if (arr[j] < arr[j - 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j - 1];
                    arr[j - 1] = temp;
                } else {
                    break;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] arr = {1, 4, 8, 3, 2, 9, 5, 0, 7, 6};
        InsertSort sort = new InsertSort();
        sort.insertSort(arr, arr.length);

        //0,1,2,3,4,5,6,7,8,9,
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + ",");
        }
    }
}

插入排序的时间复杂度的计算

1、我们从代码分析，可以知道有两个循环

外循环：执行(n-1)次，当最坏的情况下，会执行n次，虽然最后一次(i < n)不通过，但还是算一次
内循环：在(i=0,1,2,3…n-2)，执行(n-i-1)次，即(n-1,n-2…1)，其中有三条赋值语句

2、那么就可以计算出各自复杂度

外循环：最坏情况下是(n)次
内循环：通过等差数列求和公式，3x(n-1+n-2+…1)=(3x(n^2/2))

3、复杂度的大O表示法为

(n)+(3x(n^2/2)) ≈ n^2 = O(n^2)

（四）希尔排序

1、基本思想：

先对所有的数进行分组
对分组的数进行插入排序

这里写图片描述

2、实现步骤：

这张图就是将数字9，1，2，5，7，4，8，6，3，5，按分量（数的个数/2）进行分组，然后在各分组中进行插入排序

第一次：按分量5分成5组，在组中分别进行插入排序
第二次：按分量2分成5组，在组中分别进行插入排序
第三次：按分量1分成5组，在组中分别进行插入排序

希尔排序的C的实现

1、实现口诀：

分组，插入

2、易犯错误：

忘记添加结束break

#include<stdio.h>

void shellSort(int arr[],int length){
    int i,j,k;
    int temp = 0;
    int incre = length;

    while(1){
        incre = incre /2;
        for (i=0;i<incre;i++){
            for (j=i+incre;j<length;j+=incre){
                for (k=j;k>i;k-=incre){
                    if(arr[k]<arr[k-incre]){
                        temp = arr[k];
                        arr[k] = arr[k-incre];
                        arr[k-incre] = temp;
                    }else{
                        break;
                    }
                }
            }
        }

        if(incre == 1){
            break;
        }
    }
}

int main(){
    int i;
    int arr[10] = {3, 1, 5, 7, 2, 4, 9, 6, 8, 10};

    shellSort(arr,10);

    for (i = 0; i < 10; i++) {
        printf("%d,",arr[i]);
    }
}

希尔排序的Java的实现

public class ShellSort {

    public void shellSort(int arr[],int length){
        int temp = 0;
        int incre = length;

        while(true){
            incre = incre /2;
            //对分组进行遍历
            for (int i=0;i<incre;i++){
                //插入排序
                for (int j=i+incre;j<length;j+=incre){
                    for (int k=j;k>i;k-=incre){
                        if(arr[k]<arr[k-incre]){
                            temp = arr[k];
                            arr[k] = arr[k-incre];
                            arr[k-incre] = temp;
                        }else{
                            break;
                        }
                    }
                }
            }
            //无法分组，表示排序结束
            if(incre == 1){
                break;
            }
        }
    }

    public static void main(String[] args) {
        int[] arr = {3, 1, 5, 7, 2, 4, 9, 6, 8, 10};
        ShellSort sort = new ShellSort();
        sort.shellSort(arr, arr.length);

        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + ",");
        }
    }
}

（五）堆排序

1、基本思想：

整理小顶堆
将小顶堆a[0]和a[i]和互换
将换下来后的a[i]取出，即最大数
继续整理小顶堆

这里写图片描述

堆排序的C的实现

#include<stdio.h>

/**
 * 整理小顶堆，从i节点开始调整，从0开始计算，i节点的子节点为 2*i+1, 2*i+2
 *
 * @param a 所有节点
 * @param i 第i个节点
 * @param n 节点总数
 */
void MinHeapFixdown(int a[], int i, int n) {

    int j = 2 * i + 1; //左节点
    int temp = 0;

    //j<n：如果左节点小于节点总数，表示该节点有节点，否则该节点是叶子节点是不需要调整的
    while (j < n) {
        //j+1<n：存在右节点，a[j+1]<a[j]：左右子节点中寻找最小的
        if (j + 1 < n && a[j + 1] < a[j]) {
            //将节点移到右节点
            j++;
        }

        //较大节点在下面
        if (a[i] <= a[j])
            break;

        //较大节点在上面，则将大节点下移
        temp = a[i];
        a[i] = a[j];
        a[j] = temp;

        //复位
        i = j;
        j = 2 * i + 1;
    }
}

//构建最小堆
void MakeMinHeap(int a[], int n) {
    int i;
    //从倒数第二层开始排序，取自己的孩子进行排序，这样所有的节点都排序到了
    for (i = (n - 1) / 2; i >= 0; i--) {
        MinHeapFixdown(a, i, n);
    }
}

void MinHeap_Sort(int a[], int n) {
    int i;
    int temp = 0;
    MakeMinHeap(a, n);

    for (i = n - 1; i > 0; i--) {
        temp = a[0];
        a[0] = a[i];
        a[i] = temp;
        MinHeapFixdown(a, 0, i);
    }
}

int main(){
    int i;
    int arr[10] = {1, 4, 8, 3, 2, 9, 5, 0, 7, 6};

    MinHeap_Sort(arr,10);

    for (i = 0; i < 10; i++) {
        printf("%d,",arr[i]);
    }
}

堆排序的Java的实现

public class HeapSort {

    public static void MinHeap_Sort(int a[], int n) {
        int temp = 0;
        MakeMinHeap(a, n);

        for (int i = n - 1; i > 0; i--) {
            temp = a[0];
            a[0] = a[i];
            a[i] = temp;
            MinHeapFixdown(a, 0, i);
        }
    }

    //构建最小堆
    public static void MakeMinHeap(int a[], int n) {
        //从倒数第二层开始排序，取自己的孩子进行排序，这样所有的节点都排序到了
        for (int i = (n - 1) / 2; i >= 0; i--) {
            MinHeapFixdown(a, i, n);
        }
    }

    /**
     * 整理小顶堆，从i节点开始调整，从0开始计算，i节点的子节点为 2*i+1, 2*i+2
     *
     * @param a 所有节点
     * @param i 第i个节点
     * @param n 节点总数
     */
    public static void MinHeapFixdown(int a[], int i, int n) {

        int j = 2 * i + 1; //左节点
        int temp = 0;

        //j<n：如果左节点小于节点总数，表示该节点有节点，否则该节点是叶子节点是不需要调整的
        while (j < n) {
            //j+1<n：存在右节点，a[j+1]<a[j]：左右子节点中寻找最小的
            if (j + 1 < n && a[j + 1] < a[j]) {
                //将节点移到右节点
                j++;
            }

            //较大节点在下面
            if (a[i] <= a[j])
                break;

            //较大节点在上面，则将大节点下移
            temp = a[i];
            a[i] = a[j];
            a[j] = temp;

            //复位
            i = j;
            j = 2 * i + 1;
        }
    }

    public static void main(String[] args) {
        int[] arr = {1, 4, 8, 3, 2, 9, 5, 0, 7, 6};
        MinHeap_Sort(arr, arr.length);

        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + ",");
        }
    }
}

（六）快速排序

1、基本思想：

以第一个数（a）为基准
分别在头部和尾部添加指针
右边指针先开始，遇到比a小的数则停止
左边指针后开始，遇到比a大的数则停止
交换右边和左边的指针数
重复上述步骤，直到两指针相等
交换a与两指针指向的数

这里写图片描述

快速排序的C的实现

#include <stdio.h> 

void quicksort(int a[],int left,int right) 
{ 
    int i,j,t,temp; 

    if(left>right) 
       return; 

    temp=a[left]; //存基准数 
    i=left; 
    j=right; 

    while(i!=j) 
    { 
                   //先从右边开始找 
                   while(a[j]>=temp && i<j) 
                            j--; 
                   //再从左边开始找  
                   while(a[i]<=temp && i<j) 
                            i++; 
                   //交换两个数在数组中的位置 
                   if(i<j) 
                   { 
                            t=a[i]; 
                            a[i]=a[j]; 
                            a[j]=t; 
                   } 
    } 
    //基准数归位 
    a[left]=a[i]; 
    a[i]=temp; 

    quicksort(a,left,i-1);//继续处理左边的
    quicksort(a,i+1,right);//继续处理右边的
} 

int main() 
{ 
    int arr[10]= {1, 4, 8, 3, 2, 9, 5, 0, 7, 6};
    int i;

    quicksort(arr,1,10);    

    for (i = 0; i < 10; i++) {
        printf("%d,",arr[i]);
    }

    return 0; 
}

快速排序的Java的实现

public class QuickSort {

    public static void quicksort(int a[], int left, int right) {
        int i, j, t, temp;

        if (left > right)
            return;

        temp = a[left]; //存基准数
        i = left;
        j = right;

        while (i != j) {
            //先从右边开始找
            while (a[j] >= temp && i < j)
                j--;
            //再从左边开始找
            while (a[i] <= temp && i < j)
                i++;
            //交换两个数在数组中的位置
            if (i < j) {
                t = a[i];
                a[i] = a[j];
                a[j] = t;
            }
        }
        //基准数归位
        a[left] = a[i];
        a[i] = temp;

        quicksort(a, left, i - 1);//继续处理左边的
        quicksort(a, i + 1, right);//继续处理右边的
    }

    public static void main(String[] args) {
        int arr[] = {1, 4, 8, 3, 2, 9, 5, 0, 7, 6};
        quicksort(arr, 0, arr.length-1);

        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + ",");
        }
    }
}

（七）归并排序

1、基本思想：

先将需要排序的数，按中点进行分组
重复分组，直到分到的组不能再分
比较最后分开的两个组
哪个组的数小，就取谁，取了后就在对应数列中删除这个数
重复取数，直到两组的数被完全取出，合并取出来的所有数
重复上述比较、取数、合并的步骤，最后合并成有序数组

这里写图片描述

归并排序的Java的实现

public class MergeSort {

    /**
     * 归并排序
     *
     * @param a
     * @param first
     * @param last
     * @param temp
     */
    public void merge_sort(int a[], int first, int last, int temp[]) {
        if (first < last) {
            int middle = (first + last) / 2;
            merge_sort(a, first, middle, temp);//左半部分排好序
            merge_sort(a, middle + 1, last, temp);//右半部分排好序
            mergeArray(a, first, middle, last, temp); //合并左右部分
        }
    }

    /**
     * 合并数组
     *
     * @param a
     * @param first
     * @param middle
     * @param end
     * @param temp
     */
    public void mergeArray(int a[], int first, int middle, int end, int temp[]) {
        int i = first;
        int m = middle;
        int j = middle + 1;
        int n = end;
        int k = 0;
        while (i <= m && j <= n) {
            //比较两个组的数
            if (a[i] <= a[j]) {
                temp[k] = a[i];
                k++;
                i++;
            } else {
                temp[k] = a[j];
                k++;
                j++;
            }
        }
        //左边一组中，当左边分组被取完时，该把右边分组全部取出来
        while (i <= m) {
            temp[k] = a[i];
            k++;
            i++;
        }

        //右边一组中，当左边分组被取完时，该把右边分组全部取出来
        while (j <= n) {
            temp[k] = a[j];
            k++;
            j++;
        }

        //在temp中取出所有排序好的数
        for (int ii = 0; ii < k; ii++) {
            a[first + ii] = temp[ii];
        }
    }

    public static void main(String[] args) {
        int[] arr = {1, 4, 8, 3, 2, 9, 5, 0, 7, 6};
        MergeSort sort = new MergeSort();
        sort.merge_sort(arr, 0, arr.length - 1, new int[10]);

        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + ",");
        }
    }
}

（八）基数排序

在学习基数排序之前，必须要知道桶排序，所以先简单的学习一下桶排序

1、基本思想：

首先创建数组A[MaxValue]
将每个数放到相应的位置上，即数的值和索引相等的位置
最后遍历数组，即为排序后的结果

这里写图片描述

桶排序的Java的实现

public class BucketSort {

    public void sort(int[] keys, int bucketNum) {
        int len = keys.length;
        int[] bucket = new int[bucketNum];
        //初始化每个桶
        for (int i = 0; i < bucketNum; i++) {
            bucket[i] = 0;
        }
        //为每个数添加到对应桶
        for (int i = 0; i < len; i++) {
            bucket[keys[i]]++;
        }
        //遍历数组，即为结果
        for (int i = 0; i < bucketNum; i++) {
            for (int j = 1; j <= bucket[i]; j++) {
                System.out.print(i + ",");
            }
        }
    }

    public static void main(String[] args) {
        int[] a = {1, 4, 8, 3, 2, 9, 5, 0, 7, 6, 9, 10, 9, 13, 14, 15, 11, 12, 17, 16, 19};
        BucketSort sorter = new BucketSort();
        sorter.sort(a, 20);
    }
}

基数排序

1、基本思想：

将每个数的个位开始进行桶排序
排序完成后，桶按顺序输出
将排序好个位的数，进行十位开始桶排序
排序完成后，桶按顺序输出
重复上述步骤，直到最高位进行桶排序，按顺序输出即为结果

这里写图片描述

基数排序的Java的实现

public class RadixSort {

    /**
     * @param arr  原数组
     * @param temp 临时数组
     * @param n    序列的数字个数
     * @param k    最大的位数3
     * @param r    基数10
     * @param bin  桶中i位置存储的个数
     */
    public void radixSort(int arr[], int temp[], int n, int k, int r, int bin[]) {
        //digit:位数，个位、十位、百位等
        for (int i = 0, digit = 1; i < k; i++, digit = digit * r) {
            //初始化
            for (int j = 0; j < r; j++) {
                bin[j] = 0;
            }
            //计算每个箱子的数字个数
            for (int j = 0; j < n; j++) {
                bin[(arr[j] / digit) % r]++;
            }
            //bin[j]的个数修改为前j个箱子一共有几个数字
            for (int j = 1; j < r; j++) {
                bin[j] = bin[j - 1] + bin[j];
            }
            //取出每个
            for (int j = n - 1; j >= 0; j--) {      //重点理解
                bin[(arr[j] / digit) % r]--;
                temp[bin[(arr[j] / digit) % r]] = arr[j];
            }
            //将临时数组赋值给我们的数组
            for (int j = 0; j < n; j++) {
                arr[j] = temp[j];
            }
        }
    }

    public static void main(String[] args) {
        int[] arr = {143, 454, 812, 343, 245, 913, 565, 12, 743, 632};
        RadixSort sort = new RadixSort();
        sort.radixSort(arr, new int[10], arr.length, 3, 10, new int[10]);

        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + ",");
        }
    }
}

总结

排序类型	时间复杂度
冒泡排序	O(n^2)
选择排序	O(n^2)
插入排序	O(n^2)
希尔排序	O(n^1.5)
堆排序	O(N*logN)
快速排序	O(N*logN)
归并排序	O(N*logN)
基数排序	O(d(n+r))

许英俊潇洒

关注

10
点赞
踩
120

收藏

觉得还不错? 一键收藏
打赏
3
评论
数据结构与算法从零开始系列：冒泡排序、选择排序、插入排序、希尔排序、堆排序、快速排序、归并排序、基数排序

本篇内容包含排序的介绍排序的C的实现排序的Java的实现排序的时间复杂度的计算（一）冒泡排序1、基本思想：两个数比较大小，较大的数下沉，较小的数冒起来2、实现步骤：这张图就是将数字12，35，99，18，76竖起来第一次：从底部有一个气泡，圈住12并且和35对比，如果比上面小就交换，气泡往上升第二次：12和99对比，如果比上面小就交换，气泡往上升第三次：重复上面的操作，最后可以把12
复制链接

扫一扫