数组排列算法

⑴ 常见排序算法归纳

排序算法一般分类：

比较两个相邻的元素，将值大的元素交换至右端。

依次比较两个相邻的数，将小数放到前面，大数放到后面

即在第一趟：首先比较第1个数和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此一直继续下去，直到比较最后两个数，将小数放前，大数放后。然后重复第一趟步骤，直到所有排序完成。

第一趟比较完成后，最后一个数一定是数组中最大的一个数，所以第二趟比较的时候最后一个数不参与比较。

第二趟完成后，倒数第二个数也一定是数组中第二大的数，所以第三趟比较的时候最后两个数不参与比较。

依次类推......

输出结果：

冒泡排序的优点： 每进行一趟排序，就会少比较一次，因为每进行一趟排序都会找出一个较大值。如上例：第一趟比较之后，排在最后的一个数一定是最大的一个数，第二趟排序的时候，只需要比较除了最后一个数以外的其他的数，同样也能找出一个最大的数排在参与第二趟比较的数后面，第三趟比较的时候，只需要比较除了最后两个数以外的其他的数，以此类推……也就是说，没进行一趟比较，每一趟少比较一次，一定程度上减少了算法的量。

用时间复杂度来说：

从一个数组中随机选出一个数N，通过一趟排序将数组分割成三个部分，1、小于N的区域 2、等于N的区域 3、大于N的区域，然后再按照此方法对小于区的和大于区分别递归进行，从而达到整个数据变成有序数组。

如下图：

假设最开始的基准数据为数组的第一个元素23，则首先用一个临时变量去存储基准数据，即 tmp=23 ，然后分别从数组的两端扫描数组，设两个指示标志： low 指向起始位置， high 指向末尾。

首先从后半部分开始，如果 扫描到的值大于基准数据 就让 high-1 ，如果发现有元素比该基准数据的值小，比如上面的 18 <= tmp ，就让 high位置的值赋值给low位置 ，结果如下：

然后开始从前往后扫描，如果扫描到的值小于基准数据就让 low+1 ，如果发现有元素大于基准数据的值，比如上图 46 >= tmp ，就再将 low 位置的值赋值给 high 位置的值，指针移动并且数据交换后的结果如下：

然后再开始从前往后遍历，直到 low=high 结束循环，此时low或者high的下标就是 基准数据23在该数组中的正确索引位置 ，如下图所示：

这样一遍遍的走下来，可以很清楚的知道，快排的本质就是把比基准数据小的都放到基准数的左边，比基准数大的数都放到基准数的右边，这样就找到了该数据在数组中的正确位置。

然后采用递归的方式分别对前半部分和后半部分排序，最终结果就是自然有序的了。

输出结果：

最好情况下快排每次能恰好均分序列，那么时间复杂度就是O(nlogn)，最坏情况下，快排每次划分都只能将序列分为一个元素和其它元素两部分，这时候的快排退化成冒泡排序，时间复杂度为O(n^2)。

插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。

将一个数据插入到 已经排好序的有序数据 中

第一趟排序：

用数组的第二个数与第一个数( 看成是已有序的数据 )比较

第二趟排序：

用数组的第三个数与已是有序的数据 {2,3} (刚才在第一趟排的)比较

在第二步中：

...

后面依此类推

输出结果：

选择排序是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法。

举例：数组 int[] arr={5,2,8,4,9,1}

第一趟排序 ： 原始数据： 5 2 8 4 9 1

最小数据1，把1放在首位，也就是1和5互换位置，

排序结果： 1 2 8 4 9 5

第二趟排序 ：

第1以外的数据 {2 8 4 9 5} 进行比较，2最小，

排序结果： 1 2 8 4 9 5

第三趟排序 ：

除 1、2 以外的数据 {8 4 9 5} 进行比较，4最小，8和4交换

排序结果： 1 2 4 8 9 5

第四趟排序 :

除第 1、2、4 以外的其他数据 {8 9 5} 进行比较，5最小，8和5交换

排序结果： 1 2 4 5 9 8

第五趟排序：

除第 1、2、4、5 以外的其他数据 {9 8} 进行比较，8最小，8和9交换

排序结果： 1 2 4 5 8 9

输出结果：

归并排序（merge sort）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。

比如我们对 [8,4,5,7,1,3,6,2] 这个数组进行归并排序，我们首先利用分治思想的“分”将数组拆分。

输出结果：

⑵ 易语言 数组排列算法

.版本 2
.程序集 窗口程序集_启动窗口
.子程序 _按钮1_被单击
.局部变量 a, 整数型, , "5"
a ＝ { 1, 2, 3, 4, 5 }
排列 (a, 3)
.子程序 排列
.参数 a, 整数型, 数组
.参数 n, 整数型
.局部变量 i, 整数型
.局部变量 j, 整数型
.局部变量 k, 整数型
.局部变量 临时文本, 文本型
.计次循环首 (到整数 (求次方 (2, 取数组成员数 (a))) － 1, i)
k ＝ 0
临时文本 ＝ “”
j ＝ 1
.判断循环首 (i ≠ 0)
.如果真 (i ％ 2 ＝ 1)
k ＝ k ＋ 1
临时文本 ＝ 临时文本 ＋ 到文本 (a [j])
.如果真结束
i ＝ i ÷ 2
j ＝ j ＋ 1
.判断循环尾 ()
.如果真 (k ＝ n)
编辑框1.加入文本 (临时文本 ＋ #换行符)
.如果真结束
.计次循环尾 ()

⑶ VB中如何给指定的数组排序

这个就没有什么函数了吧,排序的算法很多.要这种给定的数组只有几个元素的,用最笨的方法就行了,那就是一个一个比较,如果边比较代码都不想写的话还有一个办法那就是把这些元素全部加到一个listbox控件里,设置Sorted属性=true则自动排好序了,想要降序反过来输出就行了.注意listbox的SORTED属性是只读的要在过程中改变排序方式可以使用MSHFlexGrid控件的sort属性支持多种排序方式.

⑷ 基本排序算法原理

算法原理：每次对相邻的两个元素进行比较，若前者大于后者则进行交换，如此一趟下来最后一趟的就是最大元素，重复以上的步骤，除了已经确定的元素 。

算法原理：每次对相邻的两个元素进行比较，若前者大于后者则进行交换，如此一趟下来最后一趟的就是最大元素，重复以上的步骤，除了已经确定的元素

算法步骤

1)  设置两个变量i、j，排序开始的时候：i=0，j=n-1；

2）第一个数组值作为比较值，首先保存到temp中，即temp=A[0]；

3）然后j-- ,向前搜索,找到小于temp后,因为s[i]的值保存在temp中,所以直接赋值,s[i]=s[j]

4）然后i++,向后搜索,找到大于temp后,因为s[j]的值保存在第2步的s[i]中,所以直接赋值,s[j]=s[i],然后j--,避免死循环

5）重复第3、4步，直到i=j,最后将temp值返回s[i]中

6)  然后采用“二分”的思想,以i为分界线,拆分成两个数组 s[0,i-1]、s[i+1,n-1]又开始排序

排序图解

算法原理：从第一个元素开始，左边视为已排序数组，右边视为待排序数组，从左往右依次取元素，插入左侧已排序数组，对插入新元素的左侧数组重新生成有序数组 。需要注意的是，在往有序数组插入一个新元素的过程中，我们可以采用按 顺序循环 比较，也可以通过 折半查找法 来找到新元素的位置，两种方式的效率 取决于数组的数据量

算法原理：希尔排序也是利用插入排序的思想来排序。希尔排序通过将比较的全部元素分为几个区域来提升插入排序的性能。这样可以让一个元素可以一次性地朝最终位置前进一大步。然后算法再取越来越小的步长进行排序，算法的最后一步就是普通的插入排序，但是到了这步，需排序的数据几乎是已排好的了，插入效率比较高。

排序图解

选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。选择排序的主要优点与数据移动有关。如果某个元素位于正确的最终位置上，则它不会被移动。选择排序每次交换一对元素，它们当中至少有一个将被移到其最终位置上，因此对n个元素的表进行排序总共进行至多n-1次交换。在所有的完全依靠交换去移动元素的排序方法中，选择排序属于非常好的一种。

归并排序，顾名思义就是一种 “递归合并” 的排序方法（这个理解很重要）。对于一个数列，我们把它进行二分处理，依次递归下去，然后将小范围的数进行排序，最后将其合并在一起。就实现了归并排序。

这实际上是运用了 分治思想 ，显然，想要把一个数列排好序，最终达到的目的就是它的任何一部分都是有序的。这样的话，我们可以考虑分别把数列分成N多个部分，让每个部分分别有序，然后再将其统一，变成所有的东西都有序。这样就实现了排序。这个想法就叫分治思想。

排序图解

排序图解

⑸ 求C语言将数组元素大小排序！！

C语言将数组元素大小排序方法：

以下使用的是冒泡排序法实线数组从小到大排序。

思想：每次相邻两个数比较，若升序，则将大的数放到后面，一次循环过后，就会将最大的数放在最后。

10、2、3、4、5、6、9、8、7、1是输入的待排序的数列，经过第一次排序，将最大的,10放在最后，第二次排序，将剩下的2、3、4、5、6、9、8、7、1进行冒泡，将当前最大的9放在倒数第二的位置，以此类推。

以下是具体代码：

#include <stdio.h>

int main(){

int nums[10] = {10, 2, 3, 4, 5, 6, 9, 8, 7, 1};

int i, j, temp, isSorted;

//优化算法：最多进行 n-1 轮比较

for(i=0; i<10-1; i++){

isSorted = 1; //假设剩下的元素已经排序好了

for(j=0; j<10-1-i; j++){

if(nums[j] > nums[j+1]){

temp = nums[j];

nums[j] = nums[j+1];

nums[j+1] = temp;

isSorted = 0; //一旦需要交换数组元素，就说明剩下的元素没有排序好

}

}

if(isSorted) break; //如果没有发生交换，说明剩下的元素已经排序好了

}

for(i=0; i<10; i++){

printf("%d ", nums[i]);

}

printf(" ");

return 0;

}

(5)数组排列算法扩展阅读：

其他将数组从小到大排序的算法

以下使用的是选择排序法实现数组从小到大排序。

思想：从第一个数开始，每次和后面剩余的数进行比较，若升序，则如果后边的数比当前数字小，进行交换，和后面的所有的数比较、交换后，就会将当前的最小值放在当前的位置

输入的序列为10、2、3、4、5、6、9、8、7、1进行一次排序后将最小的数放在了第一位(a[0]与它后面的所有数进行比较，若a[0]比后面的数大，进行交换)，以此类推。

以下是具体代码：

#include <stdio.h>

int main(void){

int a[1001];

int n,i,j,t;

scanf("%d",&n);//n为要排序的数的个数

//输入需要排序的数

for(i=0;i<n;++i)

scanf("%d",a+i);

//接下来进行排序

for(i=0;i<n-1;++i)//因为每次需要和a[i]后面的数进行比较,所以到a[n-2](倒数第2个元素)就行

{

for(j=i+1;j<n;++j)//j从i后一个开始,a[i]与a[j]进行比较

{

if(a[i]>a[j])//a[i]为当前值,若是比后面的a[j]大,进行交换

{

t=a[i];

a[i]=a[j];

a[j]=t;

}

}//每排序一次,就会将a[i](包括a[i])之后的最小值放在a[i]的位置

for(j=0;j<n;++j)

printf("%-5d",a[j]);

printf(" ");

}

return 0;

}

⑹ JS数组排序

JS数组排序方法有两个： reverse() 和 sort() ，其中 reverse() 可将数组进行倒序，而 sort() 则可将数组项灵活地进行升序或降序排列。

可以看出， reverse() 会直接改变原数组，并且返回值也是倒序后的数组。

记得当年学C语言时，要学各种各样的排序算法，比如经典的冒泡排序法、二分排序法等，现在抛开这些算法不说，JS就自带原生的排序函数，用起来非常方便，它就是 sort() 。

可以看出， sort() 不传参数时会按升序方式对数组项进行排序，并且与 reverse() 一样既改变原数组，同时返回的也是排序后的数组。

我们再来看下一个例子：

这时你可能会说，不对呀，最终排序返回的不应该是 [8, 9, 16, 90] 吗？然鹅事实返回的却是 [16, 8, 9, 90] ，这到底是哪门子逻辑？

事实上， sort() 并不是按照数值进行排序，而是按字符串字母的ASCII码值进行比较排序的，所以当数组项为数字时， sort() 也会自动先将数字转换成字符串，然后再按字母比较的规则进行排序处理。

现在我们再回头看看前面两个例子。当 arr 为 [8,4,9,1] 时，数组每一项转换成字符串后进行排序的结果正好与数字排序结果相同；而当 arr 为 [8,90,9,16] 时，数组每一项转换成字符串后就得按顺序一位一位进行比较，比如升序排序时，“16”应该排在最前面，因为“16”的第一位是“1”，比“8”和“9”的ASCII码值都要小。

啰嗦了这么多，其实我们实际很少会使用这种排序方式，而更多的应该就是纯数字的排序。那么我们该如何正确地使用 sort() 来达到预期的排序效果呢？

接下来就来看看传参后的 sort() 能给我们怎样的精彩表现。

这个函数参数功能其实很简单，实际上就是告诉 sort() 排序方式到底是升序还是降序，我们还是来看具体实例吧~

这种用法的规则是，当 sort() 传入函数中的第一个参数a位于第二个参数b之前，则返回一个负数，相等则返回0，a位于b之后则返回正数。

比如，当要做升序排序时，我们需要想到前面的数肯定是要比后面的数小，所以传入的这个函数参数返回值应该要是个负数，因此函数参数返回 a - b 。

如果实在不好理解，我们可以干脆记下来， a - b 升序， b - a 降序，但是需要注意的是，如果按照这种记忆方式的话，函数括号内的两个参数 a 和 b 的书写顺序可不能颠倒哦~