七大排序算法:插入排序、希尔排序、选择排序、冒泡排序、堆排序、归并排序、快速排序

以下内容转载自文章

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循环结束后到此)
    }
}

    时间复杂度:最坏情况下为O(N*N),此时待排序列为逆序,或者说接近逆序
    最好情况下为O(N),此时待排序列为升序,或者说接近升序。
    空间复杂度:O(1)

2.希尔排序

步骤:
1.先选定一个小于N的整数gap作为第一增量,然后将所有距离为gap的元素分在同一组,并对每一组的元素进行直接插入排序。然后再取一个比第一增量小的整数作为第二增量,重复上述操作…
2.当增量的大小减到1时,就相当于整个序列被分到一组,进行一次直接插入排序,排序完成。
动图如下:

思路:
希尔排序,先将待排序列进行预排序,使待排序列接近有序,然后再对该序列进行一次插入排序,此时插入排序的时间复杂度为O(N),

代码如下:

//希尔排序
void ShellSort(int* arr, int n)
{
    int gap = n;
    while (gap>1)
    {
        //每次对gap折半操作
        gap = gap / 2;
        //单趟排序
        for (int i = 0; i < n - gap; ++i)
        {
            int end = i;
            int tem = arr[end + gap];
            while (end >= 0)
            {
                if (tem < arr[end])
                {
                    arr[end + gap] = arr[end];
                    end -= gap;
                }
                else
                {
                    break;
                }
            }
            arr[end + gap] = tem;
        }
    }
}

    时间复杂度平均:O(N^1.3)
    空间复杂度:O(1)

3.选择排序

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

动图如下:
代码如下:

//选择排序
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)

4.冒泡排序

思路:
左边大于右边交换一趟排下来最大的在右边

动图如下:

代码如下:

//冒泡排序
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)

5.堆排序

堆排可看这篇b站讲解

//下标为i的节点的父节点的下标:(i - 1)/ 2
//下标为i的节点的左孩子的下标: i * 2 + 1
//下标为i的节点的右孩子的下标: i * 2 + 1
堆排序:建堆:O(N),维护性质:O(logN) -> O(NlogN)
//数组存放排序结果,同时也是输入,利用堆做中间件,i表示维护性质的起始节点,这是以维护大顶堆的性质为例 -> 数组从小到大排序
	void heapify(int arr[], int len, int i)
	{
		int largest = i;
		int left = i * 2 + 1;
		int right = i * 2 + 2;
		if (left < len && arr[largest] < arr[left])
        largest = left;
		if (right < len &&arr[largest] < arr[right])
		largest = right;
		if (largest != i) //即当前i节点不满足大顶堆
		swap(&arr[i], &arr[largest]); //开始维护大顶堆的性质
        heapify(arr, len, largest);//递归维护孩子节点,看是否满足
	}
	void heapSort(int arr[], int len)
	{
		for(int i = (len - 1) / 2; i >= 0; i--)//建堆
		{
			heapify(arr, len, i); //倒序从数组建立(维护)大顶堆
		}
		for(int i = len - 1, i > 0; i--)
		{
			swap[&arr[i], &arr[0]];//排序交换,因为堆顶肯定是最大的,所以交换到最后面 -> 从小到大的顺序
			heapify(arr, i, 0); // 交换之后开始维护堆的性质,因为i已经排好序了,所以维护的长度是i,而不是len,并且肯定从堆顶开始维护
		}
	}

6.归并排序

归并排序看这篇b站

//归并排序:分治和递归的思想:	O(NlogN)
	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++;
        }
	}
	void  mSort(int arr[], int tempArr[], int left, int right)
	{
		if (left < right)
		{ 	// 开始分治
			int mid = (left + right) / 2;
			// 递归划分左半区
			mSort(arr, temaArr, left, mid);
			// 递归划分右半区
			mSort(arr, tempArr, mid + 1, right);
			// 排序并合并
			merge(arr, tempArr, left, mid, right);
		}
	}
	void mergeSort(int arr[], int len) //排序入口,分治合并需要一个临时数组
	{
		int tempArr[len];
		mSort(arr, tempArr, 0, len - 1);
	}

7.快速排序

7.2 挖坑法
7.2.1 递归

思路:
挖坑法思路与hoare版本(左右指针法)思路类似
1.选出一个数据(一般是最左边或是最右边的)存放在key变量中,在该数据位置形成一个坑
2、还是定义一个L和一个R,L从左向右走,R从右向左走。(若在最左边挖坑,则需要R先走;若在最右边挖坑,则需要L先走)

后面的思路与hoare版本(左右指针法)思路类似在此处就不说了

单趟动图如下:

代码如下:

//快速排序法  挖坑法
void QuickSort1(int* arr, int begin, int end)
{
    if (begin >= end)
        return;
    int left = begin,right = end;
    int key = arr[begin];
    while (begin < end)
    {
        //找小
        while (arr[end] >= key && begin < end)
        {
            --end;
        }
        //小的放到左边的坑里
        arr[begin] = arr[end];
        //找大
        while (arr[begin] <= key && begin < end)
        {
            ++begin;
        }
        //大的放到右边的坑里
        arr[end] = arr[begin];
    }
    arr[begin] = key;
    int keyi = begin;
    //[left,keyi-1]keyi[keyi+1,right]
    QuickSort1(arr, left, keyi - 1);
    QuickSort1(arr, keyi + 1, right);
}

  • 53
    点赞
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
[入门数据分析的第一堂课]这是一门为数据分析小白量身打造的课程,你从网络或者公众号收集到很多关于数据分析的知识,但是它们零散不成体系,所以第一堂课首要目标是为你介绍:Ø  什么是数据分析-知其然才知其所以然Ø  为什么要学数据分析-有目标才有动力Ø  数据分析的学习路线-有方向走得更快Ø  数据分析的模型-分析之道,快速形成分析思路Ø  应用案例及场景-分析之术,掌握分析方法[哪些同学适合学习这门课程]想要转行做数据分析师的,零基础亦可工作中需要数据分析技能的,例如运营、产品等对数据分析感兴趣,想要更多了解的[你的收获]n  会为你介绍数据分析的基本情况,为你展现数据分析的全貌。让你清楚知道自己该如何在数据分析地图上行走n  会为你介绍数据分析的分析方法和模型。这部分是讲数据分析的道,只有学会底层逻辑,能够在面对问题时有自己的想法,才能够下一步采取行动n  会为你介绍数据分析的数据处理和常用分析方法。这篇是讲数据分析的术,先有道,后而用术来实现你的想法,得出最终的结论。n  会为你介绍数据分析的应用。学到这里,你对数据分析已经有了初步的认识,并通过一些案例为你展现真实的应用。[专享增值服务]1:一对一答疑         关于课程问题可以通过微信直接询问老师,获得老师的一对一答疑2:转行问题解答         在转行的过程中的相关问题都可以询问老师,可获得一对一咨询机会3:打包资料分享         15本数据分析相关的电子书,一次获得终身学习
1. 直接插入排序:将待排序的数列分为有序区和无序区,从无序区中取出一个元素,插入到有序区中的正确位置,直到无序区为空。时间复杂度为O(n^2)。 2. 希尔排序:将待排序的数列分成若干个子序列,对每个子序列进行插入排序,缩小增量,直到增量为1,最后对整个数列进行一次插入排序。时间复杂度为O(nlogn)。 3. 冒泡排序:比较相邻的两个元素,如果前者大于后者,则交换它们的位置,一次冒泡可以把一个元素排到正确的位置,重复进行n-1次,直到排序完成。时间复杂度为O(n^2)。 4. 快速排序:选定一个基准值,将数列分为左右两个部分,左边的元素都小于基准值,右边的元素都大于基准值,递归地对左右两个部分进行快速排序。时间复杂度为O(nlogn)。 5. 简单选择排序:从待排序的数列中选择最小的元素,放置到已排序数列的末尾,重复该过程,直到待排序数列为空。时间复杂度为O(n^2)。 6. 堆排序:先将待排序的数列构建成一个最大堆,然后将堆顶的元素与末尾元素交换位置,并重新构建最大堆,重复该过程,直到排序完成。时间复杂度为O(nlogn)。 7. 归并排序:将待排序的数列分成两个部分,对每个部分进行归并排序,然后将两个有序的部分合并成一个有序的数列,递归地进行该过程,直到排序完成。时间复杂度为O(nlogn)。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值