精华内容
下载资源
问答
  • 常见排序算法

    2013-04-08 10:35:46
    常见排序算法
  • 常见排序算法-C语言

    2021-01-10 14:57:05
    C语言实现常见排序算法。编译环境:VS2010。 包括: 冒泡排序 快速排序 直接插入排序 Shell排序 直接选择排序 堆排序 归并排序(递归和非递归两种) 桶式排序 基数排序:顺序和静态队列两种方法 索引排序(采用简单...
  • 常见排序算法–直接插入法vs希尔排序法 首先,我们通过一个例子来了解直接插入算法 例如,对原始数组{15,24,3,49,10}进行直接插入排序(由小到大进行排序) 第一个数15无法比较,第二个数24与15比较,不做...

    常见排序算法–直接插入法vs希尔排序法

    首先,我们通过一个例子来了解直接插入算法

    例如,对原始数组{15,24,3,49,10}进行直接插入排序(由小到大进行排序)

    第一个数15无法比较,第二个数24与15比较,不做改变,第三个数3先后与24,15进行比较移到24的前面,第四个数49先后与24,15,3进行比较49不做改变,10分别与49,24,15,3相比,10移到3的前面。

    如下

    初始态 数15 数24 数3 数49 数10
    第一步排序后 15 24 3 49 10
    第二步排序后 3 15 24 49 10
    第三步排序后 3 15 24 49 10
    第四步排序后 3 10 15 24 49
    //将每个数与前面数组依次比对,知道这个数排到合适的位置
    void insert(int a[],int n)
    {
        for(i=1;i<n;i++)
        {
        //依次比对,直到该值大于数组中比较的值,后面的数组依次后移。
            for(j=i-1;j>=0;j--)
            {
                if(a[i]<a[j])
                {
                    a[j+1]=a[j];
                }
                else
                {
                    a[j+1]=a[i];
                    break;
                }
            }
            if(j==-1&&a[i]<a[j+1])
                a[0]=a[i];//对(j==-1&&a[i]<a[j+1)进行单独分析
        }
    }

    希尔排序法:我们也通过一个例子来了解希尔排序法

    如下一个无序数组(12 35 20 67 3)

    首先进行第一次希尔排序,将数组每两个为一组,则{a[0],a[2],a[4]}为一大类进行直接插入排序,将{a[1],a[3]}为一类进行直接插入排序

    然后进行第一次希尔排序,将数组每1个分为一组(就是直接插入排序),则{a[0],a[1],a[2],a[3],a[4]}进行直接插入排序.过程如下图。

    初始状态 12 35 20 67 3
    两个一组排序
    排序前 12 20 3
    35 67
    排序后得到 3 12 20
    35 67
    整理 3 35 12 67 20
    一个一组进行排序
    排序前 3 35 12 67 20
    排序后 3 12 20 35 67

    代码如下

    //分为两种情况,依次比较a[i]与a[j],a[j-k],a[j-2k],a[j-3k]...的值,直到a[i]>a[j]或者j<0;
    void xier(int a[],int n,int v)//引入的v指的是分组的标准间隔,该算法表示经过一个间隔为k的希尔排序。
    {
        for(i=v;i<n;i++)
        {
            j=i-v;
            while(a[j]>a[i]&&j>=0)
            {
                a[j+v]=a[j];
                j-=v;
            }
            a[i]=a[j+v];
        }
    }
    展开全文
  • 主要介绍了php实现的常见排序算法汇总,包括插入排序、选择排序、冒泡排序、快速排序、归并排序与堆排序,并附有对排序算法的详细说明,需要的朋友可以参考下
  • 用JavaScript实现的常见排序算法:冒泡排序,选择排序,插入排序,谢尔排序,快速排序(递归),快速排序(堆栈),归并排序,堆排序。
  • js代码-常见排序算法:比较排序
  • 常见排序算法.doc

    2020-07-19 01:00:44
    常见排序算法的实现与性能比较 目录 一试验描述 二试验的目的 三试验的具体实现 四排序算法的语言描述java语言描述 五演示界面 六. 算法效率分析重要 七算法理论效率于实际效率对应比较重要 一试验描述实现合并排序...
  • 常见排序算法效率比较

    常见排序算法效率比较

    在这里插入图片描述

    展开全文
  • 常见排序算法总结

    2012-08-08 15:45:46
    常见排序算法总结,虽然现有的开发组件中对排序算法已经有很好的实现,但是通过研究这些算法的思路,对我们思维能力的提高还是很有帮助的
  • 1常见排序算法的实现

    2011-06-23 13:39:57
    常见排序算法的实现(一)-插入排序 常见排序算法的实现(二)-shell排序 常见排序算法的实现(三)-堆排序 常见排序算法的实现(四)-冒泡排序 常见排序算法的实现(五)-快速排序 常见排序算法的实现(六)→归并排序
  • 各种常见排序算法实现 近日受一兄台影响,也想学习记录些东西,于是也尝试开始写博客。 排序算法算是最为简单经典的算法问题了,因此从这个开始学习记录,以加深印象。 其中常见的排序算法有: 选择排序 冒泡排序...

    各种常见排序算法实现

    近日受一兄台影响,也想学习记录些东西,于是也尝试开始写博客。

    排序算法算是最为简单经典的算法问题了,因此从这个开始学习记录,以加深印象。

    其中常见的排序算法有:

    1. 选择排序
    2. 冒泡排序
    3. 插入排序
    4. 合并排序
    5. 快速排序
    6. 堆排序

    以上排序算法一定无法罗列全部排序算法的大家族,但是暂且讨论以上的算法。

    选择排序和冒泡排序属于蛮力解决问题的表现;
    插入排序则使用减治法;
    合并排序和快速排序使用分治法;
    堆排序使用变治法。

    选择排序

    蛮力法去解决排序问题没有那么多弯弯道,选择排序的思路:

    n个元素,先找到最小的元素,然后将它交换到它该在的位置,对于升序来说即第一个位置,然后第一个元素就是有序元素了,随后再将从剩下的n-1个寻找最小的元素,放到第二个位置上,以此类推,交换n-1次就可以得到一个有序的集合了。

    实现代码

     int ChooseSort(arr* a) {
    	//使用选择排序
    	//输入:无序元素列表
    	//输出:成功返回1,失败返回0
    	for (int i = 0; i < a->length - 1; i++) {
    		int min = i;
    		for (int j = i; j < a->length; j++) {
    			if (a->ite[min] > a->ite[j]) {
    				min = j;
    			}
    		}
    		if (!Swap(a, i, min)) {
    			return 0;
    		}
    	}
    	return 1;
    }
    

    冒泡排序

    冒泡排序很形象,过程也和冒泡一样,思路:

    从第一个元素开始,比较相邻元素,若是有序,则不变,若是无序,则交换相邻元素,这样做的结果就是会将最大的元素给“顶”到最后一个位置,接着将上述过程在前n-1个元素中重复。以此类推,最后就会得到一个有序的集合。

    代码实现:

    int BubbleSort(arr * a)
    {
    	//使用冒泡排序得到有序列表
    	//输入:无序元素的列表
    	//输出:成功返回1,失败返回0
    	for (int i = a->length; i > 0; i--) {
    		for (int j = 0; j < i-1; j++) {
    			if (a->ite[j] > a->ite[j + 1]) {
    				if (!Swap(a, j, j + 1)) return 0;
    			}
    		}
    	}
    	return 1;
    }
    

    插入排序

    记得第一次看到插入排序,书上是拿扑克牌举例的,思路:

    我们先认为列表的第一个元素是有序的,那么拿起第二个元素,寻找在前面第一个元素的合适的位置,插进去,现在有序的集合元素就变成两个了。以此类推,第三个找到合适的位置插入,一直到第n个元素,这样,就得到了有序元素的集合。

    代码实现:

    int InserSort(arr * a)
    {
    	//使用插入排序
    	//输入:无序元素的列表
    	//输出:返回1
    	for (int i = 1; i < a->length; i++) {
    		for (int j = 0; j < i; j++) {
    			if (a->ite[j] >= a->ite[i]) {
    				int temp = a->ite[i];
    				for (int k = i - 1; k >= j; k--)
    					a->ite[k + 1] = a->ite[k];
    				a->ite[j] = temp;
    			}
    		}
    	}
    	return 1;
    }
    

    合并排序

    一直都掌握不好递归的思想,一递归就感觉很乱,很多问题都想不清楚,还要多加了解啊。

    合并排序是使用递归的思路来做的,也即上文提到的分治法。思路:

    将其中每一个元素都看作为有序的集合,虽然每个集合只有一个元素,然后将两个有序集合合并成一个,依次合并,最终就生成了最后的有序集合。

    代码实现:

    int MergeSort(arr * a)
    {
    	//使用合并排序
    	//输入:无序元素列表
    	//输出:成功返回1
    	if (a->length > 1) {
    		arr *a1 = Cut(a, 0, a->length / 2 - 1);
    		arr *a2 = Cut(a, (a->length / 2), a->length - 1);
    		MergeSort(a1);
    		MergeSort(a2);
    		arr* b = Merge(a1, a2);
    		for (int i = 0; i < b->length; i++) {
    			a->ite[i] = b->ite[i];
    		}
    		a->length = b->length;
    		free(a1); free(a2); free(b);
    	}
    	return 1;
    }
    

    这是上述代码中Merge函数,即合并有序集合的函数:

    arr * Merge(arr * a1, arr * a2)
    {
    	//合并过程,将两个有序列表合并成一个有序列表,并释放这两个有序列表内存
    	//输入:两个有序列表
    	//输出:一个有序列表
    	arr *a = (arr*)malloc(sizeof(arr));
    	a->length = 0;
    	int i, j, k;
    	for (i = 0, j = 0, k = 0; i < a1->length && j < a2->length; k++) {
    		if (a1->ite[i] > a2->ite[j]) {
    			a->ite[k] = a2->ite[j];
    			j++;
    		}
    		else
    		{
    			a->ite[k] = a1->ite[i];
    			i++;
    		}
    		a->length++;
    	}
    	if (i == a1->length) {
    		for (; j < a2->length; j++, k++) {
    			a->ite[k] = a2->ite[j];
    			a->length++;
    		}
    	}
    	else
    	{
    		for (; i < a1->length; i++, k++) {
    			a->ite[k] = a1->ite[i];
    			a->length++;
    		}
    	}
    	return a;
    }
    

    上面代码写的很失败,因为指针以及在堆中申请空间,结果把东西弄的都很乱,什么时候释放内存空间都是个问题,最后结果如何返回也是个问题。果然还是能避免这么写还是避免这么写吧。

    快速排序

    快速排序与前面的合并排序一样,也用到了递归的思想。但是在实际实现上与合并排序有很大的不同,合并排序在实现上倾向于合并上,即将每个有序元素集合合并成一个更大的有序元素集合。快速排序则是划分与交换,从线性集合的两端开始,选取基准数,用基准数将整个集合划分为两个区间,左边全部是比基准数小的数,右边全部是比基准数大的数。然后通过分治法继续划分下去,而划分则是通过交换来实现。

    代码实现:

    int QuickSort(arr * a, int l, int m)
    {
    	//实现快速排序算法
    	//输入:无序元素列表a,列表开始区间坐标和结束区间坐标
    	//输出:成功返回1
    	int s;
    	if (l < m) {
    		s = PartPostion(a, l, m);
    		QuickSort(a, l, s-1);
    		QuickSort(a, s+1, m);
    	}
    	return 1;
    }
    

    其中的ParPosition函数如下:

    int PartPostion(arr* a, int l, int m) {
    	//实现快速排序算法中的划分区间
    	//输入:无序元素列表a,列表开始区间坐标和结束区间坐标
    	//输出:作为中轴的下标
    	int i = l, j = m;
    	int key = a->ite[l];
    	while (i < j) {
    		while (key > a->ite[i] && i < m) {
    			i++;
    		}
    		while (key < a->ite[j]) {
    			j--;
    		}
    		Swap(a, i, j);
    	}
    	Swap(a, i, j);
    	Swap(a, i, j);
    	return j;
    }
    

    快速排序算法的分治思想还是不太行,虽然对于总体有些把握了,但是具体到执行细节上还是不足的很。因为一个小细节,调了半天递归都是个死循环。

    堆排序

    堆排序顾名思义,用到了堆,最大堆就是一棵完全二叉树,其中的每一个节点的值都要大于其子女的值。

    堆排序的具体思路正是用到了这个最大堆:

    使用这些数构造一个最大堆,然后删除堆的最大键。以此类推,便可得到有序元素的集合。其中删除最大键的操作其实就是删除最大堆的根,先将根与堆最后的元素进行交换,然后删除最后的元素,即交换后的根,然后把此时在根上的那个小数再拉下来,让大数顶上去即可。

    代码实现:

    int HeapSort(arr * a)
    {
    	//使用堆排序的算法排序
    	//输入:无序元素列表
    	//输出:成功返回1
    	int size = a->length;
    	BuildHeap(a, size);
    	while (size != 1) {
    		Swap(a, 0, size - 1); size--;
    		BuildHeap(a, size);
    	}
    	
    	return 1;
    }
    

    以上实现的BuildHeap函数如下,作用为构造最大堆:

    int BuildHeap(arr* a, int size) {
    	//构造一个最大堆
    	//输入:要转化成最大堆的无序元素列表和要生成最大堆的规模
    	//输出:成功返回1
    	for (int n = size/2; n > 0; n--)
    		for (int i = size - 1; i > 0; i--)
    			if (a->ite[(i - 1) / 2] < a->ite[i]) Swap(a, (i - 1) / 2, i);
    	return 1;
    }
    

    这里我使用了从底而上的构建堆的方法。

    总结

    这些排序前三个思路都比较简单,尤其是前两个蛮力法的选择排序与冒泡排序。那两个分治法的排序方法还是不太行,合并排序感觉上要比快速排序好懂点,快速排序在通过交换来划分区间的方法感觉还是不太理解,剩下的堆排序感觉上也比较简单。

    展开全文
  • Java实现的常见排序算法.pdfJava实现的常见排序算法.pdfJava实现的常见排序算法.pdfJava实现的常见排序算法.pdfJava实现的常见排序算法.pdfJava实现的常见排序算法.pdf
  • Java常见排序算法

    2017-11-14 00:38:00
  • 十种常见排序算法欢聚一堂

    万次阅读 多人点赞 2016-03-04 22:59:03
    1.常见排序算法分类 十种常见排序算法一般分为以下几种: (1)非线性时间比较类排序:交换类排序(快速排序和冒泡排序)、插入类排序(简单插入排序和希尔排序)、选择类排序(简单选择排序和堆排序)、归并排序...
  • 常见排序算法之冒泡排序 冒泡排序(Bubble Sort),是一种较简单的排序算法。它重复地走访过要排序的元素列,依次比较两个相邻的元素,如果他们的顺序(如从小到大、首字母从A到Z)错误就把他们交换过来。 冒泡...
  • 常见排序算法java实现,包括快速排序,归并排序,堆排序三个常用nlogn复杂度的算法
  • 面试常见排序算法

    2017-03-03 11:11:28
    一、常见排序算法总结稳定性:假定在待排序的记录序列中,存在多个具有相同的关键字的记录,若经过排序,这些记录的相对次序保持不变,即在原序列中,ri=rj,且ri在rj之前,而在排序后的序列中,ri仍在rj之前,则称...
  • 排序什么是排序常见排序算法排序算法复杂度及稳定性分析 什么是排序 常见排序算法 排序算法复杂度及稳定性分析
  • 常见排序算法实践

    2016-07-06 23:58:26
    常见排序算法实践介绍各种排序可能是很多公司面试时候会问的算法题,但是由于基础不扎实我们有一部分人可能没法当场写出代码实现。其实掌握些数据结构和算法知识对我们的成长是很有帮助的。常见的排序算法有,冒泡...
  • 常见排序算法的复杂度

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 196,211
精华内容 78,484
关键字:

常见排序算法