精华内容
下载资源
问答
  • 列表元素的几种排序方法

    千次阅读 2019-06-30 11:54:27
    一般的排序方法sort(),属于python的内置方法 names = ['alice','Bob','coco','Harry'] print(names.sort()) 将列表打乱 li = list(range(10)) import random random.shuffle(li) print(li) ...

    一般的排序方法sort(),属于python的内置方法

    names = ['alice','Bob','coco','Harry']
    print(names.sort())
    

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    将列表打乱

    li = list(range(10))
    import random
    random.shuffle(li)
    print(li)
    

    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 常见的几种排序方法

    千次阅读 2018-12-05 08:46:52
    这里是修真院前端小课堂,每篇分享文从 【背景介绍】【知识剖析】...【常见的几种排序方法】 1.背景介绍在计算机科学与数学,一个排序算法(英语:Sorting algorithm)是一种能将一串资料依照特定排序方式进行排列...

    这里是修真院前端小课堂,每篇分享文从

    【背景介绍】【知识剖析】【常见问题】【解决方案】【编码实战】【扩展思考】【更多讨论】【参考文献】

    八个方面深度解析前端知识/技能,本篇分享的是:

    【常见的几种排序方法】

    1.背景介绍
    在计算机科学与数学中,一个排序算法(英语:Sorting algorithm)是一种能将一串资料依照特定排序方式进行排列的一种算法。 最常用到的排序方式是数值顺序以及字典顺序。有效的排序算法在一些算法(例如搜寻算法与合并算法)中是重要的, 如此这些算法才能得到正确解答。 排序算法也用在处理文字资料以及产生人类可读的输出结果。 基本上,排序算法的输出必须遵守下列两个原则:
    输出结果为递增序列(递增是针对所需的排序顺序而言)
    输出结果是原输入的一种排列、或是重组
    虽然排序算法是一个简单的问题,但是从计算机科学发展以来,在此问题上已经有大量的研究。 更多的新算法仍在不断的被发明。
    2.知识剖析
    查找和排序算法是算法的入门知识,其经典思想可以用于很多算法当中。因为其实现代码较短,应用较常见。 所以在面试中经常会问到排序算法及其相关的问题。但万变不离其宗,只要熟悉了思想,灵活运用也不是难事。 一般在面试中最常考的是快速排序和归并排序,并且经常有面试官要求现场写出这两种排序的代码。 对这两种排序的代码一定要信手拈来才行。还有插入排序、冒泡排序、堆排序、基数排序、桶排序等。
    常见的几种算法:
    ①冒泡算法
    ②选择排序
    ③插入排序
    ④快速排序
    3.常见问题
    问题一:各种排序算法用JavaScript 如何实现?
    问题二:各种排序算法的优劣及其应用?
    4.解决方案
    问题一:各种排序算法用JavaScript 如何实现?
    问题二:各种排序算法的优劣及其应用?
    4.解决方案
    冒泡排序
    冒泡排序(英语:Bubble Sort)是一种简单的排序算法。它重复地走访过要排序的数列,一次比较两个元素, 如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有元素再需要交换, 也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。
    冒泡排序演算法的运作如下:
    比较相邻的元素。如果第一个比第二个大,就交换他们两个。
    对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。这步做完后,最后的元素会是最大的数。
    针对所有的元素重复以上的步骤,除了最后一个。
    持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。
    代码实现:

    Array.prototype.bubbleSort = function () {
       var i, j, temp;
       for (i = 0; i < this.length - 1; i++)
           for (j = 0; j < this.length - 1 - i; j++)
               if (this[j] > this[j + 1]) {
                   temp = this[j];
                   this[j] = this[j + 1];
                   this[j + 1] = temp;
               }
       return this;
    };
     
    var num = [22, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70];//定义一个数组
    num.bubbleSort();//数组调用冒泡排序算法
    

    选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理如下。 首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素, 然后放到已排序序列的末尾。以此类推,直到所有元素均排序完毕。 选择排序的思想其实和冒泡排序有点类似,都是在一次排序后把最小的元素放到最前面。但是过程不同, 冒泡排序是通过相邻的比较和交换。而选择排序是通过对整体的选择。

    Array.prototype.selectionSort = function() {
       var i, j, min;
       var temp;
       for (i = 0; i < this.length - 1; i++) {
           min = i;
           for (j = i + 1; j < this.length; j++)
               if (this[min] > this[j])
                   min = j;
           temp = this[min];
           this[min] = this[i];
           this[i] = temp;
       }
       return this;
    };
    var num = [22, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70]; //定义一个数组
    num.selectionSort(); //数组定义选择排序算法
    

    插入排序(英语:Insertion Sort)是一种简单直观的排序算法。它的 工作原理是通过构建有序序列,对于未排序数据, 在已排序序列中从后向前扫描,找到相应位置并插入。插入排序在实现上,通常采用in-place排序 (即只需用到O(1)的额外空间的排序),因而在从后向前扫描过程中,需要反复把已排序元素逐步向后挪位, 为最新元素提供插入空间。
    1.从第一个元素开始,该元素可以认为已经被排序
    2.取出下一个元素,在已经排序的元素序列中从后向前扫描
    3.如果该元素(已排序)大于新元素,将该元素移到下一位置
    4.将新元素插入到该位置后

    Array.prototype.insertionSort = function () {
       for (var i = 1; i < this.length; i++) {
           var temp = this[i];
           var j = i - 1;
           //如果将赋值放到下一行的for循环内, 会导致在第13行出现j未声明的错误
           for (; j >= 0 && this[j] > temp; j--) {
               this[j + 1] = this[j];
           }
           this[j + 1] = temp;
       }
       return this;
    }
    var num = [22, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70]; //定义一个数组
     
    num.insertionSort(); //数组调用插入排序算法
    

    快速排序
    快速排序(英语:Quicksort),又称划分交换排序(partition-exchange sort), 一种排序算法, 最早由东尼·霍尔提出。在平均状况下,排序n个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较, 但这种状况并不常见。事实上,快速排序通常明显比其他Ο(n log n)演算法更快, 因为它的内部循环(inner loop)可以在大部分的架构上很有效率地被实现出来。 快速排序使用分治法(Divide and conquer)策略来把一个序列(list)分为两个子序列(sub-lists)。
    步骤为:
    从数列中挑出一个元素,称为"基准"(pivot),
    重新排序数列,所有比基准值小的元素摆放在基准前面,所有比基准值大的元素摆在基准后面(相同的数可以到任一边)。在这个分割结束之后,该基准就处于数列的中间位置。这个称为分割(partition)操作。
    递归地(recursively)把小于基准值元素的子数列和大于基准值元素的子数列排序。
    递归到最底部时,数列的大小是零或一,也就是已经排序好了。这个演算法一定会结束,因为在每次的迭代(iteration)中,它至少会把一个元素摆到它最后的位置去。

    Array.prototype.quickSort = function () {
       var len = this.length;
       if (len <= 1)
           return this.slice(0);
       var left = [];
       var right = [];
       var mid = [this[0]];
       for (var i = 1; i < len; i++)
           if (this[i] < mid[0])
               left.push(this[i]);
           else
               right.push(this[i]);
       return left.quickSort().concat(mid.concat(right.quickSort()));
    };
     
    var arr = [5, 3, 7, 4, 1, 9, 8, 6, 2];
    arr = arr.quickSort();
    
    

    5.编码实战
    6.扩展思考
    各种排序算法的时间复杂度和空间复杂度
    算法优劣评价术语
    稳定性:
    稳定:如果 a 原本在 b 前面,而 a = b,排序之后 a 仍然在 b 的前面;
    不稳定:如果 a 原本在 b 的前面,而 a = b,排序之后 a 可能会出现在 b 的后面;
    排序方式:
    内排序:所有排序操作都在内存中完成,占用常数内存,不占用额外内存。
    外排序:由于数据太大,因此把数据放在磁盘中,而排序通过磁盘和内存的数据传输才能进行,占用额外内存。
    复杂度:
    时间复杂度: 一个算法执行所耗费的时间。
    空间复杂度: 运行完一个程序所需内存的大小。

     

    7.参考文献
    参考一:JavaScript 排序算法汇总
    8.更多讨论
    还有那些经典排序算法?
    常用的排序算法?_腾讯视频
    PPT链接:常用的排序算法

    展开全文
  • 几种排序算法比较

    千次阅读 多人点赞 2018-12-27 11:52:50
    排序记录的关键字都部相同时,则任何一个记录的无序序列经过排序后得到的结果都唯一,反之,若存在两个或多个关键字相同时,则得到的结果可能不唯一。 假设Ki=Kj且排序前Ki在Kj之前,排序后Ki仍然在kj之前,...
    • 前言

    排序是按照关键字的非递减或非递增顺序对一组记录重新进行排列的操作,是对无规律的一组序列转化为递增或递减的操作。

    排序的稳定性:

           当排序记录中的关键字都部相同时,则任何一个记录的无序序列经过排序后得到的结果都唯一,反之,若存在两个或多个关键字相同时,则得到的结果可能不唯一。

           假设Ki=Kj且排序前Ki在Kj之前,排序后Ki仍然在kj之前,则称排序时稳定的,反之,若可能使排序后Ki在Kj之后,则称排序是不稳定的。注意,只要有一组关键字的实例不满足稳定的要求,则该排序算法就是不稳定的。各有各的适用场合。

    内部排序和外部排序:

           由于待排序记录的数量不同,使得排序过程中数据所占用的存储设备会有所不同。根据在排序过程中记录所占用的存储设备,可将排序分为两大类:内部排序和外部排序。

           内部排序是的是待排序记录全部存放在内存中进行排序的过程,外部排序指的是由于待排序记录的数量很大,以至内存不能一次全部容纳,在排序过程中仍需对外存进行访问的过程。


    • 冒泡排序

    基本思想:

           两两相邻记录的关键字,如果反序则交换,直到没有反序的记录为止。之所以叫做冒泡排序,是因为每次将一个最大或最小的数往后沉淀,沉淀到后面的数比它大或比它小为止,类似于泡泡向上浮起来的过程。

     冒泡排序是排序方法中最直观也是最简单的,我们接触的第一种排序方法也是冒泡排序,基本步骤:

      有一个数组a[10],用变量i表示它的下标(i从0开始)
    (1) 比较两个相邻元素a[i]和a[i+1],如果a[i]>a[i+1],就交换这两个数的位置;
    (2)重复执行第一步,直到比较到最后一对的时候(例:首次是a[8]和a[9],此时,a[9]的值为该数组的最大值,这个值属于有序数列);
    (3)对所有元素(除了有序数列里的元素),重复执行第一步和第二步,每执行完一次,都会找到当前比较的数里最大的那个(有序数列就会增加一个);
    (4)随着参与比较的元素越来越少,最终没有任何一对元素需要比较的时候,排序完成。

    void BubbleSort(int a[],int n)
    {
    	for(int i=0;i<n;i++)
    	for(int j=0;j<n-i-1;j++)
    	if(a[j]>a[j+1]) //两两比较 
    	swap(a[j],a[j+1]);
    }

    时间复杂度:O(n^2)
    空间复杂度:O(1)
    稳定性:由于交换的if条件是a[j]>a[j+1],所以如果等于的话并没有交换,所以冒泡排序是一种稳定排序算法。

    冒泡排序较稳定,可用于链式存储结构,时间复杂度较高,当n较大,初始记录无序时,不宜采用此方法


    • 选择排序

    通过n-1次关键字比较,从n-i+1个记录中选择关键字最小的记录,并和第i个记录交换。

    选择排序是经过一次一次在无序区间中找到最值,放到无序区间的前一个位置,基本步骤:

    (1)设待排序的记录存放在数组r[n]中,第一趟从r[1]开始,通过n-1次比较,从n个记录中选取最小的记录,记为r[k],交换r[1]和r[k]

    (2)第二趟从r[2]开始,通过n-2次比较,从n-1个记录中选出关键字最小的记录,记为r[k],交换r[2]和r[k]

    (3)以此类推,第i趟从r[i]开始,通过n-i次比较,从n-i+1个记录中选取最小关键字记录,记为r[k],交换 r[i]和r[k]

    (4)经过n-1趟,排序完成

    void SelectSort(int a[],int n)
    {
    	for(int i=0;i<n;i++)
    	{
    		int k=i;
    		for(int j=i+1;j<n;j++) //寻找最小元素的下标 
    		if(a[j]<a[k])
    		k=j;
    		
    		if(k!=i)  //放在已排序好的区间后面 
    		swap(a[i],a[k]);
    	}
    }

    时间复杂度:O(n^2)

    空间复杂度:O(1)

    稳定性:就算法本身来说,是一种稳定排序

    选择排序可用于链式存储结构,移动记录次序较少,当每一记录占用空间较多时,此方法比插入排序快


    • 插入排序

    插入排序(直接插入排序)是一种最简单的排序方法,其基本操作是将一条记录插入到已排号的序列当中,从而得到一个有序的记录。

    算法步骤:

    (1)设待排序数组a[n],默认a[0]是一个有序序列

    (2)循环n-1次,每次将为排序序列插入到前面的已排序序列当中,将已排序序列区间长度加1,未排序区间长度减一

    (3)重复(2)直到未排序区间长度为0

    void InsertSort(int a[],int n)
    {
    	for(int i=1;i<n;i++)
    	{
    		int end=a[i]; //记录未排序序列的第一个元素 
    		int j=i-1;
    		while(j>=0&&a[j]>end) //寻找位置 
    		{
    			a[j+1]=a[j];
    			j--;
    		}
    		a[j+1]=end; //插入 
    	}
    }

    时间复杂度:O(n^2)

    空间复杂度:O(1)

    稳定性:稳定排序

    算法简单稳定,容易实现,也适用于链式存储结构,在单链表中只需修改指针,更适用于初始记录基本有序的情况。对与查找插入位置,我们可以用二分查找获取位置。


    • 希尔排序

           希尔排序实质上是采用分组插入的方法,先将整个待排序记录序列分成几组,从而减少参与直接插入排序的数据量,对每组分别进行直接插入排序,然后增加每组的数据量,重新分组,这样经过几次分组后,整个序列基本有序,在对全体进行插入排序,希尔排序记录的分组,不是简单的逐段分组,而是将相隔某个记录增量的记录分成一组。

    希尔排序的基本步骤:

    (1)第一趟取增量gap(gap<n)把全部几记录分成gap个组,对每组进行直接插入排序

    (2)第二趟取gap=gap/2,重复第一步

    (3)以此类推,直到gap=1,再对整个序列排序一次

    ​
    void ShellSort(int a[],int n)
    {
        for(int gap=n/2;gap>0;gap/=2)
        for(int i=gap;i<n;i+=gap)
        {
        	int end=a[i];
        	int j=i-gap;
        	while(j>=0&&a[j]>end)
        	{
        		a[j+gap]=a[j];
        		j-=gap;
            }
    	a[j+gap]=end;
       }
    }
    
    ​

    注意这里的gap不是区间长度,而是区间的跨度,例如数组a[10],此时gap=n/2=5;每个区间的跨度为5,每次gap取上一次的一半,第一次就分为了5组分别为[0,4]、[1,5] 、[2,6]、 [3,7] 、[4,8]、 [5,9];注意是左闭右闭区间。希尔排序做到了跳跃式移动,从而使最后一次gap=1时,序列已基本有序,因此较直接插入排序时间复杂度低。

    时间复杂度:时间复杂度比较复杂,通常认为O(n*log 2  n),当n趋近于无穷大时,可以为O(n(log2 n)^2)

    空间复杂度:O(1)

    稳定性:不稳定

            希尔排序只能用于顺序存储结构,不能用于链式存储结构,增量gap可以有各种取法,但最后一次gap必须等于1, 总比较次数和移动次数较直接插入排序少,当n越大,序列越无序时,效果越明显。


    • 堆排序

            堆排序是一种树性选择排序,再排序过程中,将排序序列a[n]看成一个完全二叉树,利用二叉树双亲节点与孩子节点的内在联系,在当前无序的序列中,选择的关键字最大(或最小)的记录。

            堆的定义为 a[i]>=a[2*i]&&a[i]>=a[2*i+1]  或  a[i]<=a[2*i]&&a[i]<=a[2*i+1],通俗的理解就是在完全二叉树中,一个节点必须同时大于它的左节点和右节点。前者为大根堆后者为小根堆。

    堆排序利用了大根堆(或小根堆)堆顶记录的关键字最大(或最小)这一特征,使得当前无序的序列中选择关键字最大(或最小)的记录变得简单,步骤为:

    (1)按照堆的定义将待排序序列a[n] 调整为大根堆,这个过程称为初建堆,交换a[1]和a[n] ,则a[n]为关键字的最大记录

    (2)将a[n-1]重新调整为堆,交换ra[1]和a[n-1],此时a[n-1]为关键字最大记录

    (3)循环n-1次,直到交换a[1]和a[2]为止

    所以实现堆排序需要熟悉两个问题:建初堆、调整堆

    调整堆就是比较此节点与它的左右孩子节点,选孩子节点中取最大或者最小的一个,与此节点比较,如果不满足条件就交换,直到进行到叶子节点为止。而要将一个无序序列调整为堆,就必须将其所在的二叉树中以一个节点为根的子树都调整为堆。

    int a[10] = {1,3,2,4,8,9,7,5,6,0};
    
    void adjust(int root, int n)
    {
    	int node = root * 2 + 1; //左子节点
    
    	while(node < n)
    	{
    		//如果右节点比左节点大,node指向右节点
    		if(node + 1 < n && a[node] < a[node+1])
    			node++;
    
    		if(a[node] < a[root])
    			break;
    
    		swap(a[node], a[root]);
    
    		root = node;
    		//向下
    		node = node * 2 + 1;
    	}
    }
    
    void heapSort(int n)
    {
    	//从最后一个非叶子节点往上调整
    	for(int i = n/2; i >= 0; i--)
    		adjust(i, n);
    
    	for(int i = n-1; i > 0; i--)
    	{
    		//把根节点放到后面
    		swap(a[0], a[i]);
    		adjust(0, i);
    	}
    }

    时间复杂度:O(nlog2 n)

    空间复杂度:O(1)

    稳定性:不稳定

           堆排序只能用于顺序存储结构,初始建堆比较次数较多,记录较少时不宜采用,在最坏情况下较快速排序而言是一个有点,记录较多时较为高效。


    • 归并排序

            归并排序类似与二分查找,都是二分当前区间,分别进行操作,可通过递归与送代进行实现,书面上定义是将两个或两个以上的有序表合成一个有序表的过程,将两个有序表合成一个有序表的过程称为2-路归并,2-路归并最为简单常用。

    归并排序的算法思想:

           假设初始序列含有n个记录,则可看成是n个有序的子序列,每个子序列的长度为1,然后两两归并,得到n/2个长度为2或1的有序子序列,再两两归并。。。如此重复,直到得到一个长度为n的有序序列为止。

    2-路归并排序将r[n]中的记录放到t[n]中,当序列长度等于1时,递归结束,否则:

    (1)将当前序列一分为二,求出分裂点mid=(l+r)/2

    (2)对子序列r[l]-r[mid]递归,进行归并排序,结果放在t[l,mid]中

    (3)对子序列r[mid+1,r]递归,进行归并排序,结果放在t[mid+1,r]

    (4)将两个有序的子序列t[l,mid],t[mid+1,r]归并为一个有序的序列放入r[l,r]中

    void Merge(int a[], int left, int center, int right, int n) 
    {
    	int *t = new int[n];//存放被排序的元素
    	int i = left;
    	int j = center + 1;
    	int k = 0;
    	while (i<=center && j<=right)
    		if (a[i] <= a[j])     t[k++] = a[i++];
    		else                  t[k++] = a[j++];
    
    	if (i == center+1)
    		while (j <= right) t[k++] = a[j++];
    	else
    		while (i <= center) t[k++] = a[i++];
    
    	//把t[]的元素复制回a[]中left到right段
    	for (i=left,k=0; i<=right; i++,k++)
    		a[i] = t[k];
    	//释放内存
    	delete []t;
    }
    void MergeSort(int a[], int left, int right) 
    {
    	if (left < right) 
    	{
    		int center = (left + right) / 2;//取得中点
    		MSort(a, left, center);
    		MSort(a, center+1, right);
    		Merge(a, left, center, right, right-left+1);
    	}
    }

    时间复杂度:O(nlog2n)

    空间复杂度:O(n)

    稳定性:稳定排序

    归并排序可用于链式结构,且不需要附加存储空间,但递归实现任需要开辟相应的递归工作栈。


    • 快速排序

          快速排序在算法竞赛中用到的比较多,快速排序比冒泡排序要快很多,C语言中也有快速排序的函数qsort(),不过最好去理解一下底层代码实现。在冒泡排序过程中,只对两个相邻的记录进行比较,因此每次比较只能消除一个逆序,如果能通过两个(不相邻)记录的一次交换,消除多个逆序,则会大大加快排序的速度,快速排序就是利用这个原理。

    基本步骤:

    (1)选择待排序记录中第一个记录作为基准,将基准暂存在r[0]的位置上,假设两个指针low和high,初始分别指向表的下界和上界

    (2)从表的最右侧位置向左寻找第一个比基准数小的位置,从表的最左侧寻找第一个比基准数大的位置,交换两个元素

    (3)重复(2)当low==high时,将基准数放到low位置处的元素判断大于还是小于后,与基准数交换

    (4)此时以基准数的位置为分界点,将序列分为两个子序列,分别进行(1),(2),(3)操作,直到序列的长度为1为止

    void QuickSort(int a[], int low ,int high) 
    {
    	if(low<high) 
    	{ //判断是否满足排序条件,递归的终止条件
    		int i = low, j = high;   
    		int x = a[low];    
    		while(i<j) 
    		{
    			while(i<j && a[j] >= x) j--;  
    			
    			if(i<j) a[i++] = a[j];   
    			
    			while(i<j && a[i] <= x) i++; 
    			
    			if(i<j) a[j--] = a[i];
    		}
    		a[i] = x;   
    		QuickSort(a, low ,i-1); 
    		QuickSort(a, i+1 ,high);
    	}
    }
    
    
    //---------------------------------
    //非递归版
    #include<bits/stdc++.h>
    using namespace std;
    
    int a[1000];
    
    int quick(int i, int j)
    {
    	int x = a[i];
    	
    	while(i < j)
    	{
    		while(i < j && a[j] >= x) j--;
    		if(i < j)
    			a[i++] = a[j];
    		
    		while(i < j && a[i] <= x) i++;
    		if(i < j)
    			a[j--] = a[i];
    	}
    	
    	a[i] = x;
    	
    	return i;
    }
    
    void quicksort(int len)
    {
    	stack<int> s;
    	
    	int i = 0, j = len - 1;
    	
    	s.push(i);
    	s.push(j);
    	
    	while(!s.empty())
    	{cout << 'd' << endl;
    		j = s.top(), s.pop();
    		i = s.top(), s.pop();
    		
    		int mid = quick(i, j);
    		
    		if(i < mid - 1)
    			s.push(i), s.push(mid - 1);
    		
    		if(j > mid + 1)
    			s.push(mid + 1), s.push(j);
    			
    			
    	}
    }
    
    int main()
    {
    	int n;
    	cin >> n;
    	for(int i = 0; i < n; i++)
    	cin >> a[i];
    	
    	quicksort(n);
    	
    	for(int i = 0; i < n; i++)
    	cout << a[i] << ' ';
    	
    	return 0;
    }
    
    
    
    /*
    6
    5 2 3 4 1 0
    */
    
    
    
    
    
    
    
    
    
    
    
    
    
    

    时间复杂度:O(nlogn)

    空间复杂度:O(log2n)—O(n)

    稳定性:不稳定

    快速排序过程中需要地位表的上界和下界,所以适合顺序结构,很难用于链式结构,当n非常大时,快速排序是所有排序过程中最快的一种,所以适合用于初始记录无序、n较大时的情况。


    • 后记

            这里讲了7个排序算法,其中堆排序和快速排序用的比较多,而C++中也有排序的函数,但是我们在学习的过程中还是很有必要了解一下原理的实现,去企业应聘的时候,也会常考这些东西,排序的目的主要用于查找,我这里只是笼统的归纳了一下,看了别人的blok发现他们讲的都很好,建议大家一定要理解原理,并把代码敲出来。

     

     

     

     

    展开全文
  • 下列排序方法中,不稳定的方法有 正确答案: C 你的答案: C (正确) 归并排序与基数排序 插进排序与希尔排序排序与快速排序 选择排序与冒泡排序 添加笔记 收藏 纠错 这道题同:将一个从大...

    在下列排序方法中,不稳定的方法有

    正确答案: C   你的答案: C (正确)

    归并排序与基数排序
    插进排序与希尔排序
    堆排序与快速排序
    选择排序与冒泡排序


    排序方法        平均情况        最好情况        最坏情况        辅助空间        稳定性
    冒泡排序         O(n^2)           O(n)              O(n^2)            O(1)                稳定
    选择排序         O(n^2)          O(n^2)            O(n^2)            O(1)              不稳定
    插入排序         O(n^2)           O(n)              O(n^2)            O(1)                稳定
    希尔排序O(n*log(n))~O(n^2) O(n^1.3)       O(n^2)            O(1)              不稳定
    堆排序          O(n*log(n))     O(n*log(n))    O(n*log(n))       O(1)              不稳定
    归并排序       O(n*log(n))     O(n*log(n))    O(n*log(n))       O(n)                稳定
    快速排序       O(n*log(n))     O(n*log(n))      O(n^2)            O(1)              不稳定

    冒泡排序经过优化以后,最好时间复杂度可以达到O(n)。设置一个标志位,如果有一趟比较中没有发生任何交换,可提前结束,因此在正序情况下,时间复杂度为O(n)。

    选择排序在最坏和最好情况下,都必须在剩余的序列中选择最小(大)的数,与已排好序的序列后一个位置元素做交换,依次最好和最坏时间复杂度均为O(n^2)。

    插入排序是在把已排好序的序列的后一个元素插入到前面已排好序(需要选择合适的位置)的序列中,在正序情况下时间复杂度为O(n)。

    堆是完全二叉树,因此树的深度一定是log(n)+1,最好和最坏时间复杂度均为O(n*log(n))。

    归并排序是将大数组分为两个小数组,依次递归,相当于二叉树,深度为log(n)+1,因此最好和最坏时间复杂度都是O(n*log(n))。

    快速排序在正序或逆序情况下,每次划分只得到比上一次划分少一个记录的子序列,用递归树画出来,是一棵斜树,此时需要n-1次递归,且第i次划分要经过n-i次关键字比较才能找到第i个记录,因此时间复杂度是\sum_{i=1}^{n-1}(n-i)=n(n-1)/2,即O(n^2)。


    展开全文
  • 综述 完整代码-顺序表版本 ...排序大的分类可以分为两:内排序和外排序。 内排序是指所有的数据已经读入内存,在内存进行排序的算法。排序过程不需要对磁盘进行读写。同时,内排序也一般假定所有用...
  • 数组排序的四种方法

    千次阅读 2018-11-26 11:36:49
    这篇博客,我就来介绍几种关于数组排序方法。 一)通过Arrays类的静态sort()方法,实现对数组进行排序,sort()方法提供了多种重载形式,可对任意类型的数组进行升序排序。 语法如下: Arrays.sort(object) //...
  • 快速排序几种常见实现及其性能对比

    万次阅读 多人点赞 2014-12-22 19:11:54
    快速排序算法是一不稳定的排序算法。其时间复杂度为O(nlogn),最坏复杂度为O(n^2);快排的空间复杂度为O(logn),这个不确定正确。 假设待排序的数组为a[],快速排序算法最常见的做法是将第一个元素设置为枢纽元。...
  • 1. 这本书对Python的知识点的描述很详细,而且排版看的很舒服. 2. 个例题:假装自己从零开始学,将一些有代表性、有意思的例题抽取出来. 3. 还有自己对一部分课后复习题,全部课后上机实践题的解题思路
  • Java集合面试题

    万次阅读 多人点赞 2019-06-25 14:46:19
    方法用来排序,该方法只有一个参数。 Comparator 接口,在 java.util 包下,用于传入的两个对象的比较,所以它有一个 #compare(Object obj1, Object obj2) 方法用来排序,该方法有两个参数。 详细的,...
  •  基本原理:归并排序也称合并排序,其算法思想是将待排序序列分为两部分,依次对分得的两个部分再次使用归并排序,之后再对其进行合并。操作步骤如下。 (1)将所要进行的排序序列分为左右两个部分,如果要进行排序的...
  • 数据结构面试题

    千次阅读 多人点赞 2018-01-22 10:21:28
    数据结构面试题 1.数据结构与算法常见笔试题    第一章 数据结构与算法 ...一....2.算法的基本要素:算法对数据的运算和操作、算法的控制结构。...3.算法设计的基本方法:列举法、归纳法、递推、递归
  • 入门学习Linux常用必会60个命令实例详解doc/txt

    千次下载 热门讨论 2011-06-09 00:08:45
    从图1可以看到,笔者系统可以使用的Shell有bash(缺省)、csh、sh、tcsh四。 exit 1.作用 exit命令的作用是退出系统,它的使用权限是所有用户。 2.格式 exit 3.参数 exit命令没有参数,运行后退出系统...
  • MySQL 面试题

    万次阅读 多人点赞 2019-09-02 16:03:33
    当年,我们记着个一定要掌握的重心: 重点的题目添加了【重点】前缀。 索引。 锁。 事务和隔离级别。 因为 MySQL 还会有部分内容和运维相关度比较高,所以本文我们分成两部分【开发】【运维】两部分。 对于...
  • 前端面试题

    万次阅读 多人点赞 2019-08-08 11:49:01
    如何在HTML添加事件,几种方法? 92 BOM对象有哪些,列举window对象? 92 请问代码实现 outerHTML 93 JS的简单继承 call方法! 94 bind(), live(), delegate()的区别 95 看下列代码输出什么? 96 看...
  • java的几种经典排序算法

    万次阅读 2012-07-09 16:28:11
    最近闲着没事,就想研究下java的数据结构,现在就从最简单的排序算法开始吧。... 排序是程序开发中一非常常见的操作,是对任意的一组数据经过排序操作后,就可以把他们变成一组按关键字排列的有序序
  • 2、字符串排序方法 3、键索引计数法 3.1、第一步:频率统计 3.2、第二步:将频率转换为索引 3.3、第三步:数据分类排序 3.4、第四步:回写排序好的数组 4、低位优先的字符串排序 5、高位优先的字符串排序 1...
  • 冒泡排序应该是排序中最简单的算法了 主要思路如下: 1: 比较相邻的元素。如果第一个比第二个大,就交换他们两个。 2:对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是...
  • 测试开发笔记

    万次阅读 多人点赞 2019-11-14 17:11:58
    各阶段输入、输出标准以及入口、出口准则:(测试阶段过程要素) 12 第三章 测试方法 14 测试方法对比 14 测试方法组合 16 第四章 软件质量 19 1.什么是软件质量 19 2.质量要素 19 3. 6大特性27个子特性ISO国际标准...
  • 什么是数据结构?

    千次阅读 2019-06-19 20:25:39
    什么是数据结构?数据结构是什么? 数据结构是计算机存储、组织数据的方式...数据结构是指相互之间存在着一或多种关系的数据元素的集合和该集合数据元素之间的关系组成。也就是说,数组结构指的是数据集合及...
  • 《数据库原理》— 数据库系统概论第五版习题解析

    万次阅读 多人点赞 2017-05-29 14:57:48
    数据库系统概论前七章习题解析 第1章绪论 1.试述数据、数据库、数据库系统、数据库管理系统的概念...早期的计算机系统主要用于科学计算,处理的数据是整数、实数、浮点数等传统数学的数据。现代计算机能存储和...
  • C#基础教程-c#实例教程,适合初学者

    万次阅读 多人点赞 2016-08-22 11:13:24
    请牢记C#Main()方法必须被包含在一个类,Main第一个字母必须大写,必须是一个静态方法,也就是Main()方法必须使用static修饰。static void Main()是类Welcome定义的主函数。静态方法意义见以后章节。 程序所...
  • 在下述几种,()可以表示静态查找表? A. 次优查找树 B. 二叉排序树 C. B-树 D. 平衡二叉树 解答 答案:A 静态查找表(Static Search Table):只作查找操作的查找表。 A:查询某个“特定”数据元素是否在查找...
  • 通过几组有代表意义的随机数据的比较,算出几种这几种排序算法的关键字比较次数和关键字移动次数,以便我们分析算法效率。 1、通过修改程序,实现程序在要求的数据量下求出以下六种内部排序算法的移动次数和比较次数...
  • 数据结构(C++)有关练习题

    热门讨论 2008-01-02 11:27:18
    <br>实验二 单链表结构及计算 实验目的: 通过实验掌握下列知识: 1、熟悉线性表的基本运算在两存储结构(顺序结构和链式结构)上的实现; 2、继续熟悉VC编程、编译和调试环境; 内容及步骤:...
  • 要求首先随机产生10000个数据存入磁盘文件,然后读入数据文件,分别采用不同的排序方法进行排序并将结果存入文件。一、算法思想描述(用一个长度为10的序列进行模拟)1.希尔排序希尔排序是对直接插入排序的改进,...
  • 数据结构的常用八种排序算法

    万次阅读 多人点赞 2018-04-14 12:02:23
    概述 排序有内部排序和外部排序,内部排序是数据记录在内存中进行排序,而外部排序是因排序的数据很大,一次不能容纳全部的排序记录,在排序过程中需要... 快速排序:是目前基于比较的内部排序中被认为是最好的方法
  • 12种排序算法

    千次阅读 2017-10-18 11:19:08
    作者:寒小阳 时间:2013年9月。 ...声明:版权所有,转载请... 从这一部分开始直接切入我们计算机互联网笔试面试的重头戏算法了,初始的想法是找一条主线,比如数据结构或者解题思路方法,将博主见过做过整理过
  • 数据结构课后习题八选择题总结

    千次阅读 2018-06-28 13:55:17
    从未排序序列依次取出元素与已排序序列(初始时为空)的元素进行比较,将其放入已排序序列的正确位置上的方法,这种方法称为(C)A.归并排序 B.冒泡排序 C.插入排序 D.选择排序2.从未排序序列挑选元素,并将其...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 60,462
精华内容 24,184
关键字:

下列几种排序方法中