精华内容
下载资源
问答
  • 根号n段归并排序算法时间复杂度分析过程: 1.合并 根号n向下取整 段子数组使用的是自底向上两两归并的策略 2.根号n段归并排序算法时间复杂度的数学推导
  • 自然归并排序算法时间复杂度分析

    千次阅读 2016-11-24 22:21:13
    最近在看一部美剧《breaking bad》,从中领会了不少东西。回头再看过去写的博客,感觉真是很糟糕。...这篇对自然归并排序算法时间复杂度的分析便是第一篇。   对于普通归并排序算法,我就不

    最近在看一部美剧《breaking bad》,从中领会了不少东西。回头再看过去写的博客,感觉真是很糟糕。真正自己的东西极少,大多数内容都是网上一搜一大堆的玩意,那么,这样的博客写着有什么意思呢?

    从今往后,我的博客一定要写进自己的思想,就算没有创新,也一定要有独立思考求解的过程。

     

    这篇对自然归并排序算法时间复杂度的分析便是第一篇。

     

    对于普通归并排序算法,我就不赘述了。任何一本算法书籍都有介绍,随便用python写了一笔:

    class Merge():
        def __init__(self):
            self.tmp_arr = [0,0,0,0,0,0,0,0,0,0,0,0]
    
        def merge(self, arr, start, mid, end):
            for i in range(start, end+1):
                self.tmp_arr[i] = arr[i]
            j = mid + 1
            k = start
            for i in range(start, end+1):
                if k > mid:
                    arr[i] = self.tmp_arr[j]
                    j += 1
                elif j > end:
                    arr[i] = self.tmp_arr[k]
                    k += 1
                elif self.tmp_arr[j] < self.tmp_arr[k]:
                    arr[i] = self.tmp_arr[j]
                    j += 1
                else:
                    arr[i] = self.tmp_arr[k]
                    k += 1
        def sort(self, arr, start, end):
            if end <= start:
                return 
            mid = start + (end - start) / 2
            self.sort(arr, start, mid)
            self.sort(arr, mid + 1, end)
            self.merge(arr, start, mid ,end)
            
    mobj = Merge()
    arr = [5,3,4,7,1,9,0,4,2,6,8]
    mobj.sort(arr, 0, len(arr)-1)
    for i in range(len(arr)):
        print arr[i]

    其时间复杂度为O(nlogn),归并排序的比较是分层次来归并的(第一次是两两归并,之后再在第一次归并的基础上两两归并,每一层归并的次数为上一层除二,最终形成一二叉树,该二叉树的高即为归并次数logn。而每一层的比较次数恒等于n,所以时间复杂度求得nlogn)。

    自然归并排序算法是在归并排序算法基础上的改进,首先将数列中,已经有序的数分为小组,再在这些小组的基础上归并。

    例如 5,3,4,7,1,9,0,4,2,6,8

    则可首先得到{5},{3},{4,7},{1,9},{0,4},{2,6,8}

    第一次归并得到{3,5},{1,4,7,9},{0,2,4,6,8}

    第二次归并得到{1,3,4,5,7,9},{0,2,4,6,8}

    可以看出,原理同样是二路归并,只不过最开始现将有序的部分划分了下。所以那一次‘划分了’多少个组,将决定以后的归并是否更顺利(树的层数更少)

     

    普通归并排序的情况,第一次归并得到的组数为g = N/2

    自然归并排序的情况,设第一次归并得到的组数为g,因为,一个数为一组的概率为1/2,两个数为一组的概率为1/4,n个数为一组的概率为2的n次方分之一。则可求得等式:

     

    继续推导:

    可知,在随机情况下,自然归并排序分的组数是与普通归并排序 无限趋近相等的。

     

    结论:在分组数相等的基础上,继续进行二路归并,之后的‘二叉树’的高度便是一样的。所以时间复杂度同样为O(nlogn)。

             然而,若已知待排序数列相对有序的情况,则自然归并排序算法是优于普通归并排序算法的。

    展开全文
  •  刚看了网易公开课里的《 麻省理工学院公开课:算法导论》,受益颇深!国外学校的讲课方式确实更有趣味和深度(或许因为在学校压根没听进去过几节课),在评判一个软件的时候,有很多因素是比程序的性能让人更看重...

        第一次写博客,心情难免有点忐忑,不过为了达到心中的小目标,尽可能的用有效率的方法去提升自己。废话不多说,下面进入正题。

        刚看了网易公开课里的《 麻省理工学院公开课:算法导论》,受益颇深!国外学校的讲课方式确实更有趣味和深度(或许因为在学校压根没听进去过几节课),在评判一个软件的时候,有很多因素是比程序的性能让人更看重的,比如安全性,可扩展性,稳定性,以及近期越来越重要的用户友好性( user friendiness)等等。但是性能依旧被看重的原因是以上的那些稳定性等因素的实现,都是建立在良好的性能之上的。而在纷繁复杂的计算机语言中,算法的思想是不变的。而一个程序员无论在哪一个计算机专业领域上,算法依旧是傍身的法宝。(以上全是拾人牙慧)

        插入排序:

            原理:

             

             每次处理就是将无序数列的第一个元素与有序数列的元素从后往前逐个进行比较,找出插入位置,将该元素插入到有序数列的合适位置  中。

            时间复杂度:

                对于每一个元素比较的次数是 θ(j)(j表示当前数组位置)总时间T(n)=从第二项开始到最后一项对其进行求和(称为算数级数)=θ(n^2)。


        归并排序:

            原理:






    展开全文
  • 几篇排位很高的和原地归并算法的博客都将原地归并算法的复杂度...但实际上经过一番计算发现,利用线性数组+手摇算法实现的原地归并算法复杂度在O(n2)O(n^2)O(n2)。 通过链表实现才是O(nlog⁡n)O(n\log n)O(nlogn)的。

    几篇排位很高的和原地归并算法的博客比如:
    https://blog.csdn.net/acdreamers/article/details/24244643
    都将原地归并算法的复杂度归为 O ( n log ⁡ n ) O(n\log n) O(nlogn)的。

    但实际上经过一番计算发现,利用线性数组+手摇算法实现的原地归并,算法复杂度在 O ( n 2 ) O(n^2) O(n2)
    通过链表实现才是 O ( n log ⁡ n ) O(n\log n) O(nlogn)的。

    链表实现nlogn

    借用原文章中利用线性数组实现的图,简单说明这一点。
    在这里插入图片描述

    假设利用单向链表进行实现,我们将图中ijindex之前的元素用三个指针p1,p2,p3指向。利用如下过程实现常数时间的手摇。

    tmp = p1->next;
    p1->next = p2->next;
    p2->next = p3->next;
    p3->next = tmp;
    delete tmp;
    

    那么即便最坏的情况也只是进行n/2次链表手摇。
    T ( n ) = c ⋅ n 2 + 2 T ( n 2 ) T(n)=c\cdot\frac{n}{2}+2T(\frac{n}{2}) T(n)=c2n+2T(2n)
    复杂度为 O ( n log ⁡ n ) O(n\log n) O(nlogn)

    手摇数组实现n方

    相比之前提到的利用线性数组+手摇实现的,我们可以构造这样一个序列:

    1,3,5,7,   2,4,6,8
    

    这样每推进一位就需要进行一次手摇。而每次手摇算法的开销为 n 2 ⋅ 1 2 \displaystyle\frac{n}{2}\cdot\frac{1}{2} 2n21,随序列剪短,需要进行手摇的序列长度从 n 2 \frac{n}{2} 2n逐一缩短为1。等差求和为 c n 2 cn^2 cn2
    但注意,这个算法复杂度并非 n 2 log ⁡ n n^2\log n n2logn 其实就算n方也本来就不如用冒泡
    T ( n ) = c n 2 + 2 T ( n 2 ) T(n)=cn^2+2T(\frac{n}{2}) T(n)=cn2+2T(2n)

    求和为 ∑ k = 0 ∞ c ( n 2 k ) 2 ⋅ 2 k = c n 2 ∑ k = 0 ∞ 1 2 k \sum\limits_{k=0}^\infty c\left(\frac{n}{2^k}\right)^2\cdot 2^{k}=cn^2\sum\limits_{k=0}^\infty \frac{1}{2^k} k=0c(2kn)22k=cn2k=02k1
    等号右边级数显然收敛到一个常数,故为 O ( n 2 ) O(n^2) O(n2)

    展开全文
  • 排序算法之 冒泡排序及性能优化(时间复杂度+空间复杂度分析) 排序算法之 简单选择排序及时间复杂度分析 排序算法之 直接插入排序及时间复杂度分析 排序算法之 希尔排序及时间复杂度分析 排序算法之 快速排序及时间...
     
    

    归并排序

    归并排序是建立在归并操作上的一种有效排序算法,该算法是采用分治法的一个典型应用。
    这里的分治如何理解?
    比如我们要统计本县城的高考状元,而一个县城中有很多中学,每个中学又有若干个班级,每个班级有若干名学生,每个学生是一个单独个体,看成数组中的一个元素。接下来,班级内学生两两组合并排好序组成一组,然后两组两组再进行合并并排好序…各班级分别排好序…各学校分别排好序…县中所有学生排序…

    归并排序基本思想:

    1. 将序列中待排序数分为若干组,每个数字为一组
    2. 将若干个组进行两两合并,保证合并后的组是有序的
    3. 一直重复第二步操作直到剩下一组,排序完成

    效果图:
    在这里插入图片描述
    在这里插入图片描述

    算法实现

    #include <stdio.h>
    
    int arr1[10] = {9,8,7,6,5,4,3,2,1,0}, arr2[10];//原数组arr1,临时空间数组arr2
    void merge(int low, int mid, int high) {
    	int i = low, j = mid + 1, k = low;
    	while (i <= mid && j <= high)
    		if (arr1[i]<arr1[j])
    			arr2[k++] = arr1[i++];
    		else
    			arr2[k++] = arr1[j++];
    	while (i <= mid)
    		arr2[k++] = arr1[i++];
    	while (j <= high)
    		arr2[k++] = arr1[j++];
    	for (i = low; i <= high; i++) {
    		arr1[i] = arr2[i];
    	}
    }
    
    void mergeSort(int a, int b) {
    	//直到a=b时,停止递归。
    	if (a<b) {
    		int mid = (a + b) / 2;
    		mergeSort(a, mid);
    		mergeSort(mid + 1, b);
    		merge(a, mid, b);
    	}
    }
    
    int main() {
    	int i;
        mergeSort(0, 9);
    	return 0;
    }
    
    
    

    时间复杂度

    归并排序的效率是比较高的,设数列长为N,将数列分开成小数列一共要logN步,每步都是一个合并有序数列的过程,时间复杂度可以记为O(N),故一共为O(NlogN)。因为归并排序每次都是在相邻的数据中进行操作,所以归并排序在O(NlogN)的几种排序方法(快速排序,归并排序,希尔排序,堆排序)也是效率比较高的。

    展开全文
  • 排序算法归并排序 及其时间复杂度和空间复杂度排序算法中快速排序的效率是非常高的,但是还有种排序算法的效率可以与之媲美,那就是归并排序归并排序和快速排序有那么点异曲同工之妙,快速排序:是先...
  • 归并排序,其实就是递归+合并。
  • 归并排序算法你还记得吧?它的递归实现代码非常简洁。现在我们就借助归并排序来看看,如何用递归树,来分析递归代码的时间复杂度。 归并排序每次会将数据规模一分为二。我们把归并排序画成递归树,就是下面这个样子...
  • 排序算法-归并排序时间复杂度

    千次阅读 2019-02-17 18:21:10
    归并排序就是将要排序的序列不断的进行划分,直到不能划分为止这样就只是对两个有序的序列进行合并排序。 如图: 在合并的过程中需要创建一个临时空间来存储排好的顺序,之后将这个临时空间再赋值到序列的相应位置...
  • 这里我直接从网上找了一份对归并排序算法的比较好的介绍排序算法 。 计算时间复杂度 关键是怎么计算时间复杂度? 我们在假设数组的长度为n的基础上进行归并排序,假设排序的总共用时为T[n]T[n]T[n],则: 第一次,将...
  • 4.利用Master Theorem求归并排序时间复杂度 我们上一篇博客重点回顾了复杂度的概念,以及基本的复杂度计算方法。这篇博客我们利用归并排序Merge Sort算法带着大家深入计算复杂度。 1.归并排序概念 假设我们有一...
  • 归并排序算法时间复杂度

    千次阅读 2019-07-10 17:37:12
    我们对n个元素进行归并排序,需要时间T(n), 那分解成两个子数组排序的时间都是T(n/2)。...归并排序时间复杂度计算公式是: T(1) = C; n=1 时,只需要常量级的执行时间,所以表示为 C。 T(n) = 2*T(n/2...
  • 排序算法时间复杂度、空间复杂度、稳定性比较

    万次阅读 多人点赞 2017-07-30 21:33:22
    排序算法分类排序算法比较表格填空 排序算法 平均时间复杂度 最坏时间复杂度 空间复杂度 是否稳定 冒泡排序 :————-: :—–: :—–: :—–: 选择排序 :————-: :—–: :—–: :—–: 直接插入...
  • 排序(Sorting) 是计算机程序设计中的一种重要操作,它的功能是将一个数据元素(或记录)的...本文主要介绍快速排序算法和归并排序算法的基本概念、原理以及具体的实现方法,并对这两种排序算法的时间复杂度进行分析。
  • 归并排序的空间复杂度

    千次阅读 2021-05-29 09:32:03
    归并排序时间复杂度任何情况下都是 O(nlogn),看起来非常优秀。(待会儿你会发现,即便是快速排序,最坏情况下,时间复杂度也是 O(n^2)。)但是,归并排序并没有像快排那样,应用广泛,这是为什么呢?因为它有一个...
  • 例1:利用递归树计算归并排序的平均时间复杂度归并排序伪代码: MergeSort(A,p,r) { if(p&amp;amp;lt;r) { q = (p+r)/2; MergeSort(A,p,q); MergeSort(A,q+1,r); Merge(A,p,q,r); //合并两个子数组...
  • 图解:归并排序时间复杂度

    千次阅读 2018-11-28 16:28:16
    随着分解的进行,每层复杂度求和的结果都是 cn,这是求得时间复杂度 nlgn 的关键,看到这豁然开朗的感觉!
  • 1.归并排序的步骤如下:  Divide: 把长度为n的输入序列分成两个长度为n/2的子序列。  Conquer: 对这两个子序列分别采用...2.时间复杂度:  这是一个递推公式(Recurrence),我们需要消去等号右侧的
  • 归并排序(MERGE-SORT)是建立在归并操作上的一种有效的排序算法,该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段...
  • 排序算法_复杂度总结

    2013-06-25 13:06:00
    冒泡排序算法时间复杂度是O(n^2) 选择排序算法时间复杂度是O(n^2) 插入排序算法时间复杂度是O(n^2) ...归并排序算法时间复杂度是O(nlogn) 相关概念 1、稳定排序(stable sort)和非稳定排序 稳
  • 归并排序(MERGE-SORT)是建立在归并操作上的一种有效的排序算法,该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。 算法分析 排序的思想就是将元素无限拆分,直到无可拆分为止,再将拆分的元素...
  • 归并排序时间复杂度 -------------------------- 讲归并排序之前,先讲讲什么事递归?递归就是自己调用自己。 比如 f(x)= x^2+ f(x - 1)且f(0)=0; 这个就是递归,比如你要求f(5)就必须先求出f(4)又得求...
  • 归并排序(MERGE-SORT)是建立在归并操作上的一种有效的排序算法,该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段...
  • 最近在准备秋招的期间遇到了很多排序算法时间复杂度、空间复杂度、稳定性相关的题目,那就做个大致的总结吧。 排序算法 时间复杂度(平均) 时间复杂度(最坏) 时间复杂度(最好) 空间复杂度 稳定...
  • 八大排序算法时间复杂度和空间复杂度对比 排序有内部排序和外部排序,内部排序是数据记录在内存中进行排序,而外部排序是因排序的数据很大,一次不能容纳全部的排序记录,在排序过程中需要访问外存。 八大排序就是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 57,791
精华内容 23,116
关键字:

归并排序算法的时间复杂度