排序算法总结

爱晒太阳的小老鼠

已于 2024-07-26 11:27:53 修改

阅读量494

点赞数 6

分类专栏：算法文章标签：数据结构排序算法算法

于 2024-07-26 11:16:23 首次发布

本文链接：https://blog.csdn.net/s07aser123/article/details/140709842

版权

算法专栏收录该内容

5 篇文章 0 订阅

订阅专栏

1、排序总结

介绍集中常见的基础排序,包括冒泡排序、插入排序、希尔排序、选择排序、快速排序

排序算法	描述	代码思路总结
1、冒泡排序	相邻元素比大小，每一次遍历就把最大的元素换到了最后	1、2层循环 2、第一个循环i,从第位置0开始遍历 3、第一个循环i,从第位置0开始遍历，结束条件是arr.length-i-1,把相邻的元素两两比较，前面比后面大就交换位置，每次循环把最大的元素放到最后面
2、插入排序	遍历数组，把当前位置数，插入前面已经遍历的数组合适位置	1、2层for循环 2、第一个循环i,从第位置1开始遍历 3、第二个循环j,从第一个循环位置倒着循环比较大小，直到没有插入点
希尔排序（特殊插入）	特殊的插入排序，增加了一层循环，增加了gap	步骤：（2,3步是跟普通插入排序一样） 1、第一层循环 gap循环，下标从size/2开始 2、第二层循环i,下标i从gap开始 3、第三层循环j,下标从i-gap开始
3、选择排序	每次找到最小值放到当前遍历的位置	1、2层for 2、第一层for,下标i从0开始直到结束 3、第二层for，小标从i+1开始，找到最小的值的小标minIndex 4、i和minIndex数据互换
4、快速排序	把数组数据最后一个数作为基准，数组左边的数小于基准，右边的数大于基础，找出基准数据index，然后递归	1、把数组数据最后一个数作为基准，数组左边的数小于基准，右边的数大于基础，找出基准数据index 2、扩容左侧区域
5、归并排序
6、基数排序
7、堆排序

2、代码

2.1、冒泡排序

/***
 * 冒泡排序
 * 思路：把相邻的元素两两比较，根据大小来交换元素的位置，每次循环把最大的元素放到最后面
 * 1、2层for
 * 2、第一层for,下标i从0开始直到结束
 * 3、第二层for，下标j从0开始直到length-i-1
 **/
public static void bubbleSort(int arr[]) {
    if (arr == null || arr.length < 2) {
        return;
    }
    for (int i = 0; i <arr.length; i++) {
        for (int j = 0; j <arr.length-i-1; j++) {
            if (arr[j] > arr[j+1]) {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}

2.2、插入排序

2.2.1普通插入

/***
 * 插入排序思路:
 * 1、2层for循环
 * 2、第一个循环从第二个元素开始遍历
 * 3、第二个循环从第一个循环位置倒着循环比较大小，直到没有插入点
**/
public static void InsertSortx1(int arr[]){
    if(arr==null || arr.length==1){
        return;
    }
    for(int i=1;i<arr.length;i++){
        for(int j=i-1;j>=0 && arr[j]>arr[j+1];j--){
            arr[j] = arr[j] ^ arr[j+1];
            arr[j+1] = arr[j] ^ arr[j+1];
            arr[j] = arr[j] ^ arr[j+1];
        }
    }
}

2.2.2希尔排序

/**
 * 特殊的插入排序，增加了一层循环，增加了gap
 * 步骤：（2,3步是跟普通插入排序一样）
 * 1、第一层循环  gap循环，下标从size/2开始
 * 2、第二层循环  下标i从gap开始
 * 3、第三层循环   下标从i-gap开始
**/
public static void sortx(int arr[]) {
    int size = arr.length;
    for (int gap = size / 2; gap > 0; gap = gap / 2) {
        for (int i = gap; i < size; i++) {
            for (int j = i-gap;j >= 0 && arr[j] > arr[j + gap];j -= gap) {
                //插入排序采用交换法
                int temp = arr[j];
                arr[j] = arr[j+gap];
                arr[j+gap] = temp;
            }
        }
    }
}

2.3、选择排序

/***
 * 选择排序
 * 思路：每次找到最小值放到当前遍历的位置
 * 1、2层for
 * 2、第一层for,下标i从0开始直到结束
 * 3、第二层for，小标从i+1开始，找到最小的值的小标minIndex
 * 4、i和minIndex数据互换
 **/
public static void selSort1(int arr[]) {
     if(arr==null || arr.length<2) {
         return ;
     }
     for(int i=0;i<arr.length;i++){
         int minIndex = i;
         for(int j=i+1;j<arr.length;j++){
             if(arr[j]<arr[minIndex]){
                 minIndex = j;
             }
         }
         if(minIndex!=i){
             //互换
             arr[i] = arr[i]^arr[minIndex];
             arr[minIndex] = arr[i]^arr[minIndex];
             arr[i] = arr[i]^arr[minIndex];
         }
     }
}

2.4、快速排序

//快速排序,排序思路，把数组数据最后一个数作为基准，数组左边的数小于基准，右边的数大于基础，找出基准数据index，然后递归
private static void quickSort(int arr[],int left,int right){
    if(left>=right){
        return ;
    }
    //把数组数据最后一个数作为基准，数组左边的数小于基准，右边的数大于基础，找出基准数据index
    int index = partionIndex(arr,left,right);
    quickSort(arr,left,index-1);
    quickSort(arr,index,right);
}


/***
 * 1、把数组数据最后一个数作为基准，数组左边的数小于基准，右边的数大于基础，找出基准数据index
 * 2、扩容左侧区域
 * arr[i]<num,i和左侧区域下一个数据交换，i++
 * arr[i]>num,i++
**/
private static int partionIndex(int arr[],int left,int right){
    //基准数据   2,11,8,9,1,10,4,3,0,7 ，如果basic是7
    int basicData = arr[right];
    int pl = left;
    for(int i=left;i<right;i++){
        if(arr[i]<basicData){
            //数据交换
            swap(arr,i,pl++);
        }
    }
    swap(arr,right,pl);
    return pl;
}

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