排序大全（干货）

FENG.Lxj

于 2024-10-04 14:00:48 发布

阅读量228

点赞数 8

文章标签：排序算法数据结构算法

本文链接：https://blog.csdn.net/2301_80419036/article/details/142702573

版权

1. 插入排序步骤：

2.选择排序思路：每次从待排序列中选出一个最小值，然后放在序列的起始位置，直到全部待排数据排完即可。实际上，我们可以一趟选出两个值，一个最大值一个最小值，然后将其放在序列开头和末尾，这样可以使选择排序的效率快一倍。

3.冒泡排序思路：左边大于右边交换一趟排下来最大的在右边

4.并归排序

5.快速排序

1. 插入排序
步骤：

1.从第一个元素开始，该元素可以认为已经被排序
2.取下一个元素tem，从已排序的元素序列从后往前扫描
3.如果该元素大于tem，则将该元素移到下一位
4.重复步骤3，直到找到已排序元素中小于等于tem的元素
5.tem插入到该元素的后面，如果已排序所有元素都大于tem，则将tem插入到下标为0的位置
6.重复步骤2~5

动图演示如下：

思路：
在待排序的元素中，假设前n-1个元素已有序，现将第n个元素插入到前面已经排好的序列中，使得前n个元素有序。按照此法对所有元素进行插入，直到整个序列有序。
但我们并不能确定待排元素中究竟哪一部分是有序的，所以我们一开始只能认为第一个元素是有序的，依次将其后面的元素插入到这个有序序列中来，直到整个序列有序为止。

代码如下：

void InsertSort(int* arr, int n)
{
    for (int i = 0; i < n - 1; ++i)
    {
        //记录有序序列最后一个元素的下标
        int end = i;
        //待插入的元素
        int tem = arr[end + 1];
        //单趟排
        while (end >= 0)
        {
            //比插入的数大就向后移
            if (tem < arr[end])
            {
                arr[end + 1] = arr[end];
                end--;
            }
            //比插入的数小，跳出循环
            else
            {
                break;
            }
        }
        //tem放到比插入的数小的数的后面
        arr[end  + 1] = tem;
        //代码执行到此位置有两种情况:
        //1.待插入元素找到应插入位置（break跳出循环到此）
        //2.待插入元素比当前有序序列中的所有元素都小（while循环结束后到此）
    }
}

2.选择排序
思路：
每次从待排序列中选出一个最小值，然后放在序列的起始位置，直到全部待排数据排完即可。
实际上，我们可以一趟选出两个值，一个最大值一个最小值，然后将其放在序列开头和末尾，这样可以使选择排序的效率快一倍。

动图如下：

代码如下：

//选择排序
void swap(int* a, int* b)
{
    int tem = *a;
    *a = *b;
    *b = tem;
}
void SelectSort(int* arr, int n)
{
    //保存参与单趟排序的第一个数和最后一个数的下标
    int begin = 0, end = n - 1;
    while (begin < end)
    {
        //保存最大值的下标
        int maxi = begin;
        //保存最小值的下标
        int mini = begin;
        //找出最大值和最小值的下标
        for (int i = begin; i <= end; ++i)
        {
            if (arr[i] < arr[mini])
            {
                mini = i;
            }
            if (arr[i] > arr[maxi])
            {
                maxi = i;
            }
        }
        //最小值放在序列开头
        swap(&arr[mini], &arr[begin]);
        //防止最大的数在begin位置被换走
        if (begin == maxi)
        {
            maxi = mini;
        }
        //最大值放在序列结尾
        swap(&arr[maxi], &arr[end]);
        ++begin;
        --end;
    }
}

时间复杂度：最坏情况：O(N^2)
最好情况：O(N^2)
空间复杂度：O(1)

3.冒泡排序
思路：
左边大于右边交换一趟排下来最大的在右边

动图如下：

代码如下：

//冒泡排序
void BubbleSort(int* arr, int n)
{
    int end = n;
    while (end)
    {
        int flag = 0;
        for (int i = 1; i < end; ++i)
        {
            if (arr[i - 1] > arr[i])
            {
                int tem = arr[i];
                arr[i] = arr[i - 1];
                arr[i - 1] = tem;
                flag = 1;
            }
        }
        if (flag == 0)
        {
            break;
        }
        --end;
    }
}

时间复杂度：最坏情况：O(N^2)
最好情况：O(N)
空间复杂度：O(1)

4.并归排序

思路：采用分治和递归的思路

代码

public class 归并排序 {
    public static void main(String[] args) {
        int arr[] = {9,5,2,7,12,4,3,1,11};
        int n= 9;
        System.out.println(Arrays.toString(arr));
        merge_sort(arr,n);
        System.out.print("归并后：");
        System.out.println(Arrays.toString(arr));
    }

    //归并排序入口
    private  static  void merge_sort(int arr[],int n){
        int[] tempArr = new int[n];
        msort(arr,tempArr,0,n-1);
    }

    //归并
    private static  void msort(int arr[], int tempArr[], int left , int right){
        //如果只有一个元素，那么就不需要划分
        //只有一个元素的区域，本来就是有序的，只需要被归并即可
        if(left < right){
            //找中心点
            int mid  = (left+right)/2;
            //递归划分左半区
            msort(arr, tempArr , left , mid);
            //递归划分右半区
            msort(arr, tempArr , mid+1 , right);
            //合并已经排序的部分
            merge(arr , tempArr ,left , mid ,right);
        }
    }

     //合并
    private static  void merge(int[] arr, int[] tempArr, int left, int mid, int right) {
        //标记左半区第一个未排序的元素
        int l_pos = left;
        //标记左半区第一个未排序的元素
        int r_pos = mid+1;
        //临时数组元素的下标
        int pos = left;
        //合并
        while (l_pos <= mid && r_pos <= right){
            if(arr[l_pos] < arr[r_pos]) //左半区第一个剩余元素更小
                tempArr[pos++] = arr[l_pos++];
            else  tempArr[pos++] = arr[r_pos++];  右半区第一个剩余元素更小
        }

        //合并左半区剩余的元素
        while (l_pos <= mid){
            tempArr[pos++] = arr[l_pos++];
        }

        //合并右半区剩余的元素
        while (r_pos <= right){
            tempArr[pos++] = arr[r_pos++];
        }

        //把临时数组中合并的元素复制到原来的数组
        while (left <= right) {
            arr[left] = tempArr[left];
            left++;
        }
    }
}

5.快速排序

基本思想：

选定Pivot中心轴（任意一个）
将大于Pivot的数字放在Pivot右边
将小于Pivot的数字放在Pivot左边
分别对左右子序列重复前三步操作

此时左下标的数符合小于pivot中心轴，该数不做处理继续移动

以此类推，完成排序

代码

public class 快速排序0 {
    static int arry[] = {19, 97, 9, 17, 1, 8};
    public static void main(String[] args) {
        Quicksort(arry, 0, arry.length-1);
        for (int i : arry) {
            System.out.print(i+" ");
        }
    }
    static void Quicksort(int arry[], int l, int r) {
        if (l > r) return;
        int left = l;
        int right = r;
        int pivot = arry[left];
        while (left < right) {
            //右
            while (left < right && arry[right] >= pivot) right--;
            if (left < right) arry[left] = arry[right];
            //左
            while (left < right && arry[left] <= pivot) left++;
            if (left < right) arry[right] = arry[left];
            if (left == right) arry[left] = pivot;
        }
        //左边
        Quicksort(arry,l,right-1);
        Quicksort(arry,left+1,r);
    }
    }