求冒泡排序法 简单程序，从大到小排列，6个数字

假设你把这些都放入了数组[120,100,75,115,99,80]第一趟循环，排序的结果是[100,75,115,99,80,120],也就是说，将最大的那个数放到了最后。每次都将最大的往后挪。下面是算法：

for(int i=arrlength-1; i>1; i--)

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

if( arr[j] > arr[j+1] )

swap(j, j+1); //交换方法，自己写吧。

如果你是写手游的话，最好换个排序方法，插入或者希尔。冒泡排序效率有点低。

设有三个字序无符号数存放在buffer缓冲器中，现要对其按从大到小的排列

程序如下:

dseg segment

buffer db 78,90,11 ;假设的三个无符号数

dseg ends

;

cseg segment

assume cs:cseg,ds:dseg

start: mov ax,dseg

mov ds,ax

;

mov si,offset buffer

mov al,[si]

cmp al,[si+1] ;第一个数与第二个数比较

jbe next1

xchg al,[si+1]

mov [si],al

next1: mov al,[si]

cmp al,[si+2] ;第一个数与第三个数比较

jbe next2

xchg al,[si+2]

mov [si],al

next2: mov al,[si+1]

cmp al,[si+2] ;第三个数与第三个数比较

jbe next3

xchg al,[si+2]

mov [si+1],al

next3: mov ah,4ch

int 21h

cseg ends

end start

可以运用分而治之方法来解决排序问题，该问题是将n 个元素排成非递减顺序。分而治之方法通常用以下的步骤来进行排序算法：若n 为1，算法终止；否则，将这一元素集合分割成两个或更多个子集合，对每一个子集合分别排序，然后将排好序的子集合归并为一个集合。

假设仅将n 个元素的集合分成两个子集合。现在需要确定如何进行子集合的划分。一种可能性就是把前面n- 1个元素放到第一个子集中（称为A），最后一个元素放到第二个子集里（称为B）。按照这种方式对A递归地进行排序。由于B仅含一个元素，所以它已经排序完毕，在A排完序后，只需要用程序2 - 1 0中的函数i n s e r t将A和B合并起来。把这种排序算法与I n s e r t i o n S o r t（见程序2 - 1 5）进行比较，可以发现这种排序算法实际上就是插入排序的递归算法。该算法的复杂性为O (n 2 )。把n 个元素划分成两个子集合的另一种方法是将含有最大值的元素放入B，剩下的放入A中。然后A被递归排序。为了合并排序后的A和B，只需要将B添加到A中即可。假如用函数M a x（见程序1 - 3 1）来找出最大元素，这种排序算法实际上就是S e l e c t i o n S o r t（见程序2 - 7）的递归算法。

假如用冒泡过程（见程序2 - 8）来寻找最大元素并把它移到最右边的位置，这种排序算法就是B u b b l e S o r t（见程序2 - 9）的递归算法。这两种递归排序算法的复杂性均为(n2 )。若一旦发现A已经被排好序就终止对A进行递归分割，则算法的复杂性为O(n2 )（见例2 - 1 6和2 - 1 7）。

上述分割方案将n 个元素分成两个极不平衡的集合A和B。A有n- 1个元素，而B仅含一个元素。下面来看一看采用平衡分割法会发生什么情况： A集合中含有n/k 个元素，B中包含其余的元素。递归地使用分而治之方法对A和B进行排序。然后采用一个被称之为归并（ m e rg e）的过程，将已排好序的A和B合并成一个集合。

例2-5 考虑8个元素，值分别为[ 1 0，4，6，3，8，2，5，7 ]。如果选定k = 2，则[ 1 0 , 4 , 6 , 3 ]和[ 8 , 2 , 5 , 7 ]将被分别独立地排序。结果分别为[ 3 , 4 , 6 , 1 0 ]和[ 2 , 5 , 7 , 8 ]。从两个序列的头部开始归并这两个已排序的序列。元素2比3更小，被移到结果序列；3与5进行比较，3被移入结果序列；4与5比较，4被放入结果序列；5和6比较，。如果选择k= 4，则序列[ 1 0 , 4 ]和[ 6 , 3 , 8 , 2 , 5 , 7 ]将被排序。排序结果分别为[ 4 , 1 0 ]和[ 2 , 3 , 5 , 6 , 7 , 8 ]。当这两个排好序的序列被归并后，即可得所需要的排序序列。

图2 - 6给出了分而治之排序算法的伪代码。算法中子集合的数目为2，A中含有n/k个元素。

template

void sort( T E, int n)

{ / /对E中的n 个元素进行排序， k为全局变量

if (n >= k) {

i = n/k;

j = n-i;

令A 包含E中的前i 个元素

令B 包含E中余下的j 个元素

s o r t ( A , i ) ;

s o r t ( B , j ) ;

m e rge(A,B,E,i,j,); //把A 和B 合并到E

}

else 使用插入排序算法对E 进行排序

}

图14-6 分而治之排序算法的伪代码

从对归并过程的简略描述中，可以明显地看出归并n个元素所需要的时间为O (n)。设t (n)为分而治之排序算法（如图1 4 - 6所示）在最坏情况下所需花费的时间，则有以下递推公式：

其中c 和d 为常数。当n / k≈n-n / k 时，t (n) 的值最小。因此当k= 2时，也就是说，当两个子集合所包含的元素个数近似相等时， t (n) 最小，即当所划分的子集合大小接近时，分而治之算法通常具有最佳性能。

可以用迭代方法来计算这一递推方式，结果为t(n)= (nl o gn)。虽然这个结果是在n为2的幂时得到的，但对于所有的n，这一结果也是有效的，因为t(n) 是n 的非递减函数。t(n) =(nl o gn) 给出了归并排序的最好和最坏情况下的复杂性。由于最好和最坏情况下的复杂性是一样的，因此归并排序的平均复杂性为t (n)= (nl o gn)。

图2 - 6中k= 2的排序方法被称为归并排序（ m e rge sort ），或更精确地说是二路归并排序（two-way merge sort）。下面根据图1 4 - 6中k= 2的情况（归并排序）来编写对n 个元素进行排序的C + +函数。一种最简单的方法就是将元素存储在链表中（即作为类c h a i n的成员（程序3 -8））。在这种情况下，通过移到第n/ 2个节点并打断此链，可将E分成两个大致相等的链表。

归并过程应能将两个已排序的链表归并在一起。如果希望把所得到C + +程序与堆排序和插入排序进行性能比较，那么就不能使用链表来实现归并排序，因为后两种排序方法中都没有使用链表。为了能与前面讨论过的排序函数作比较，归并排序函数必须用一个数组a来存储元素集合E，并在a 中返回排序后的元素序列。为此按照下述过程来对图1 4 - 6的伪代码进行细化：当集合E被化分成两个子集合时，可以不必把两个子集合的元素分别复制到A和B中，只需简单地在集合E中保持两个子集合的左右边界即可。接下来对a 中的初始序列进行排序，并将所得到的排序序列归并到一个新数组b中，最后将它们复制到a 中。图1 4 - 6的改进版见图1 4 - 7。

template

M e rgeSort( T a[], int left, int right)

{ / /对a [ l e f t : r i g h t ]中的元素进行排序

if (left < right) {//至少两个元素

int i = (left + right)/2; //中心位置

M e rgeSort(a, left, i);

M e rgeSort(a, i+1, right);

M e rge(a, b, left, i, right); //从a 合并到b

Copy(b, a, left, right); //结果放回a

}

}

图14-7 分而治之排序算法的改进

可以从很多方面来改进图1 4 - 7的性能，例如，可以容易地消除递归。如果仔细地检查图1 4 - 7中的程序，就会发现其中的递归只是简单地重复分割元素序列，直到序列的长度变成1为止。当序列的长度变为1时即可进行归并 *** 作，这个过程可以用n 为2的幂来很好地描述。长度为1的序列被归并为长度为2的有序序列；长度为2的序列接着被归并为长度为4的有序序列；这个过程不断地重复直到归并为长度为n 的序列。图1 4 - 8给出n= 8时的归并（和复制）过程，方括号表示一个已排序序列的首和尾。

初始序列[8] [4] [5] [6] [2] [1] [7] [3]

归并到b [4 8] [5 6] [1 2] [3 7]

复制到a [4 8] [5 6] [1 2] [3 7]

归并到b [4 5 6 8] [1 2 3 7]

复制到a [4 5 6 8] [1 2 3 7]

归并到b [1 2 3 4 5 6 7 8]

复制到a [1 2 3 4 5 6 7 8]

图14-8 归并排序的例子

另一种二路归并排序算法是这样的：首先将每两个相邻的大小为1的子序列归并，然后对上一次归并所得到的大小为2的子序列进行相邻归并，如此反复，直至最后归并到一个序列，归并过程完成。通过轮流地将元素从a 归并到b 并从b 归并到a，可以虚拟地消除复制过程。二路归并排序算法见程序1 4 - 3。

程序14-3 二路归并排序

template

void MergeSort(T a[], int n)

{// 使用归并排序算法对a[0:n-1] 进行排序

T b = new T [n];

int s = 1; // 段的大小

while (s < n) {

MergePass(a, b, s, n); // 从a归并到b

s += s;

MergePass(b, a, s, n); // 从b 归并到a

s += s;

}

}

为了完成排序代码，首先需要完成函数M e rg e P a s s。函数M e rg e P a s s（见程序1 4 - 4）仅用来确定欲归并子序列的左端和右端，实际的归并工作由函数M e rg e (见程序1 4 - 5 )来完成。函数M e rg e要求针对类型T定义一个 *** 作符< =。如果需要排序的数据类型是用户自定义类型，则必须重载 *** 作符< =。这种设计方法允许我们按元素的任一个域进行排序。重载 *** 作符< =的目的是用来比较需要排序的域。

程序14-4 MergePass函数

template

void MergePass(T x[], T y[], int s, int n)

{// 归并大小为s的相邻段

int i = 0;

while (i <= n - 2 s) {

// 归并两个大小为s的相邻段

Merge(x, y, i, i+s-1, i+2s-1);

i = i + 2 s;

}

// 剩下不足2个元素

if (i + s < n) Merge(x, y, i, i+s-1, n-1);

else for (int j = i; j <= n-1; j++)

// 把最后一段复制到y

y[j] = x[j];

}

程序14-5 Merge函数

template

void Merge(T c[], T d[], int l, int m, int r)

{// 把c[l:m]] 和c[m:r] 归并到d [ l : r ]

int i = l, // 第一段的游标

j = m+1, // 第二段的游标

k = l; // 结果的游标

/ /只要在段中存在i和j，则不断进行归并

while ((i <= m) && (j <= r))

if (c[i] <= c[j]) d[k++] = c[i++];

else d[k++] = c[j++];

// 考虑余下的部分

if (i > m) for (int q = j; q <= r; q++)

d[k++] = c[q];

else for (int q = i; q <= m; q++)

d[k++] = c[q];

}

自然归并排序（natural merge sort）是基本归并排序（见程序1 4 - 3）的一种变化。它首先对输入序列中已经存在的有序子序列进行归并。例如，元素序列[ 4，8，3，7，1，5，6，2 ]中包含有序的子序列[ 4，8 ]，[ 3，7 ]，[ 1，5，6 ]和[ 2 ]，这些子序列是按从左至右的顺序对元素表进行扫描而产生的，若位置i 的元素比位置i+ 1的元素大，则从位置i 进行分割。对于上面这个元素序列，可找到四个子序列，子序列1和子序列2归并可得[ 3 , 4 , 7 , 8 ]，子序列3和子序列4归并可得[ 1 , 2 , 5 , 6 ]，最后，归并这两个子序列得到[ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 ]。因此，对于上述元素序列，仅仅使用了两趟归并，而程序1 4 - 3从大小为1的子序列开始，需使用三趟归并。作为一个极端的例子，假设输入的元素序列已经排好序并有n个元素，自然归并排序法将准确地识别该序列不必进行归并排序，但程序1 4 - 3仍需要进行[ l o g2 n] 趟归并。因此自然归并排序将在(n) 的时间内完成排序。而程序1 4 - 3将花费(n l o gn) 的时间。

排序算法是什么有多少种排序算法总结又是怎样以下是为您整理的排序算法总结，供您参考!

排序算法总结

排序算法：一种能将一串数据依照特定的排序方式进行排列的一种算法。

排序算法性能：取决于时间和空间复杂度，其次还得考虑稳定性，及其适应的场景。

稳定性：让原本有相等键值的记录维持相对次序。也就是若一个排序算法是稳定的，当有俩个相等键值的记录R和S，且原本的序列中R在S前，那么排序后的列表中R应该也在S之前。

以下来总结常用的排序算法，加深对排序的理解。

冒泡排序

原理

俩俩比较相邻记录的排序码，若发生逆序，则交换;有俩种方式进行冒泡，一种是先把小的冒泡到前边去，另一种是把大的元素冒泡到后边。

性能

时间复杂度为O(N^2)，空间复杂度为O(1)。排序是稳定的，排序比较次数与初始序列无关，但交换次数与初始序列有关。

优化

若初始序列就是排序好的，对于冒泡排序仍然还要比较O(N^2)次，但无交换次数。可根据这个进行优化，设置一个flag，当在一趟序列中没有发生交换，则该序列已排序好，但优化后排序的时间复杂度没有发生量级的改变。

代码

插入排序

原理

依次选择一个待排序的数据，插入到前边已排好序的序列中。

性能

时间复杂度为O(N^2)，空间复杂度为O(1)。算法是稳定的，比较次数和交换次数都与初始序列有关。

优化

直接插入排序每次往前插入时，是按顺序依次往前找，可在这里进行优化，往前找合适的插入位置时采用二分查找的方式，即折半插入。

折半插入排序相对直接插入排序而言：平均性能更快，时间复杂度降至O(NlogN)，排序是稳定的，但排序的比较次数与初始序列无关，总是需要foor(log(i))+1次排序比较。

使用场景

当数据基本有序时，采用插入排序可以明显减少数据交换和数据移动次数，进而提升排序效率。

代码

希尔排序

原理

插入排序的改进版，是基于插入排序的以下俩点性质而提出的改进方法：

插入排序对几乎已排好序的数据 *** 作时，效率很高，可以达到线性排序的效率。

但插入排序在每次往前插入时只能将数据移动一位，效率比较低。

所以希尔排序的思想是：

先是取一个合适的gap

缩小间隔gap，例如去gap=ceil(gap/2)，重复上述子序列划分和排序

直到，最后gap=1时，将所有元素放在同一个序列中进行插入排序为止。

性能

开始时，gap取值较大，子序列中的元素较少，排序速度快，克服了直接插入排序的缺点;其次，gap值逐渐变小后，虽然子序列的元素逐渐变多，但大多元素已基本有序，所以继承了直接插入排序的优点，能以近线性的速度排好序。

代码

选择排序

原理

每次从未排序的序列中找到最小值，记录并最后存放到已排序序列的末尾

性能

时间复杂度为O(N^2)，空间复杂度为O(1)，排序是不稳定的(把最小值交换到已排序的末尾导致的)，每次都能确定一个元素所在的最终位置，比较次数与初始序列无关。

代码

快速排序

原理

分而治之思想：

Divide：找到基准元素pivot，将数组A[pr]划分为A[ppivotpos-1]和A[pivotpos+1…q]，左边的元素都比基准小，右边的元素都比基准大;

Conquer：对俩个划分的数组进行递归排序;

Combine：因为基准的作用，使得俩个子数组就地有序，无需合并 *** 作。

性能

快排的平均时间复杂度为O(NlogN)，空间复杂度为O(logN)，但最坏情况下，时间复杂度为O(N^2)，空间复杂度为O(N);且排序是不稳定的，但每次都能确定一个元素所在序列中的最终位置，复杂度与初始序列有关。

优化

当初始序列是非递减序列时，快排性能下降到最坏情况，主要因为基准每次都是从最左边取得，这时每次只能排好一个元素。

所以快排的优化思路如下：

优化基准，不每次都从左边取，可以进行三路划分，分别取最左边，中间和最右边的中间值，再交换到最左边进行排序;或者进行随机取得待排序数组中的某一个元素，再交换到最左边，进行排序。

在规模较小情况下，采用直接插入排序

代码

归并排序

原理

分而治之思想：

Divide：将n个元素平均划分为各含n/2个元素的子序列;

Conquer：递归的解决俩个规模为n/2的子问题;

Combine：合并俩个已排序的子序列。

性能

时间复杂度总是为O(NlogN)，空间复杂度也总为为O(N)，算法与初始序列无关，排序是稳定的。

优化

优化思路：

在规模较小时，合并排序可采用直接插入;

在写法上，可以在生成辅助数组时，俩头小，中间大，这时不需要再在后边加俩个while循环进行判断，只需一次比完。

代码

堆排序

原理

堆的性质：

是一棵完全二叉树

每个节点的值都大于或等于其子节点的值，为最大堆;反之为最小堆。

堆排序思想：

将待排序的序列构造成一个最大堆，此时序列的最大值为根节点

依次将根节点与待排序序列的最后一个元素交换

再维护从根节点到该元素的前一个节点为最大堆，如此往复，最终得到一个递增序列

性能

时间复杂度为O(NlogN)，空间复杂度为O(1)，因为利用的排序空间仍然是初始的序列，并未开辟新空间。算法是不稳定的，与初始序列无关。

使用场景

想知道最大值或最小值时，比如优先级队列，作业调度等场景。

代码

计数排序

原理

先把每个元素的出现次数算出来，然后算出该元素所在最终排好序列中的绝对位置(最终位置)，再依次把初始序列中的元素，根据该元素所在最终的绝对位置移到排序数组中。

性能

时间复杂度为O(N+K)，空间复杂度为O(N+K)，算法是稳定的，与初始序列无关，不需要进行比较就能排好序的算法。

使用场景

算法只能使用在已知序列中的元素在0-k之间，且要求排序的复杂度在线性效率上。

代码

桶排序

原理

根据待排序列元素的大小范围，均匀独立的划分M个桶

将N个输入元素分布到各个桶中去

再对各个桶中的元素进行排序

此时再按次序把各桶中的元素列出来即是已排序好的。

性能

时间复杂度为O(N+C)，O(C)=O(M(N/M)log(N/M))=O(NlogN-NlogM)，空间复杂度为O(N+M)，算法是稳定的，且与初始序列无关。

使用场景

算法思想和散列中的开散列法差不多，当冲突时放入同一个桶中;可应用于数据量分布比较均匀，或比较侧重于区间数量时。

基数排序

原理

对于有d个关键字时，可以分别按关键字进行排序。有俩种方法：

MSD：先从高位开始进行排序，在每个关键字上，可采用计数排序

LSD：先从低位开始进行排序，在每个关键字上，可采用桶排序

性能

时间复杂度为O(d(N+K))，空间复杂度为O(N+K)。

总结

以上排序算法的时间、空间与稳定性的总结如下：

#include <stdioh>

#include <stdlibh>

//申明链表

typedef struct node

{

char num;

struct node next;

}list;

void Bubble_sort(list L);//链表的冒泡排序

void Dis_list(list L);//遍历单链表

int main()

{

//建表

list r,s,p;

int n=26;//存储数据的个数

s=NULL;

for(int i='Z';i>='A';i--)

{

r=(list )malloc(sizeof(list));

r->num = i;

if(!s){s=r;p=s;}

p->next=r;

p=r;

}

p->next=NULL;

printf("排序前:\t");

Dis_list(s);

//排序

Bubble_sort(s);

printf("排序后:\t");

Dis_list(s);

return 0;

}

void Dis_list(list L)

{

list r;

r=L;

while(r!=NULL)

{

printf("%c\t",r->num);

r=r->next;

}

printf("\n");

}

void Bubble_sort(list L)

{

list r,s;

char temp;

for(r=L;r;r=r->next)

{

for(s=r;s;s=s->next)

{

if(r->num>s->num)

{

temp=r->num;

r->num=s->num;

s->num=temp;

}

}

}

}

import javautilArrays;

import javautilScanner;

//必须实现Comparable接口

public class Word implements Comparable<Word>{

private final  String word;

public String getWord() {

return word;

}

//构造器什么的无视吧

public Word(String word) {

if(word == null)

throw new NullPointerException("不可以创造空单词!");

thisword = word;

}

//实现compareTo方法主要的排序思路在这里

@Override

public int compareTo(Word target) {

if(target == null)

return 1;

if(targetgetWord()equalsIgnoreCase(getWord()))

return 0;

char[] selfLetters = getWord()toLowerCase()toCharArray();

char[] targetLetters = targetgetWord()toLowerCase()toCharArray();

int selfLength = selfLetterslength;

int targeLength =targetLetterslength;

int minLength = Mathmin(selfLength, targeLength);

for(int index = 0;index < minLength;index++){

if(selfLetters[index] > targetLetters[index]){

return 1;

}

else if (selfLetters[index] < targetLetters[index]){

return -1;

}

continue;

}

return selfLength > targeLength  1 : -1 ;

}

//重写 ToString 方法以便打印输出

@Override

public String toString() {

return word;

}

//主方法用来查看效果

public static void main(String[] args) {

 

int size = 5;//测试用的数组长度(单词数);

// 创造一个Word的数组用来保存输入的单词

Word[] words =  new Word[size];

Scanner sc = new Scanner(Systemin);

for(int i=0;i<size;i++)

{

Systemoutprintln("请输入第"+(i+1)+"个单词");

words[i] = new Word(scnextLine());

}

scclose();//关闭流

Systemoutprintln("排序结果为:");

//使用Arrayssort方法排序,sort对自动调用你的compareTo方法来比较

Arrayssort(words);

//打印出结果

Systemoutprintln(ArraystoString(words));

}

}

这是我刚写的。测试结果还可以。逻辑可能不是很严谨 不过作为作业应该应付足够了

#include "stdioh"//标准io头文件

#include "stdlibh"//库文件

#include "timeh"//时间系头文件

#define N0 100000 //定义常量

typedef int keytype; //类型命名

typedef struct node //定义结构体

{ keytype key; //只是类型命名成keytype，其实就是int的

}Etp;//结构体类型叫做Etp

Etp R[N0+1]; // R[1]R[n] //定义数组

int n=50, count;//全局变量

void readData( Etp R[], int n)//读数据的函数

{ int i;

count=0;

srand( time( NULL ));//初始化时间种子

for( i=1; i<=n; i++) //对数组初始化

R[i]key=1000+

(int)((99990-1000)rand()/RAND_MAX); // 0RAND_MAX

}

void printData( Etp R[], int n )//打印显示数据的函数

{ int i;

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

printf("%8d%s", //格式化显示数组的数据

R[i]key, i%5==0"\n":"");

printf("\ncount=%d\n", count);

}

void bubberSort( Etp R[], int n )//冒泡排序的函数

{ int i,j;//（这个函数块就是冒泡排序的算法程序）

bool swap;

for( i=1; i<=n-1; i++)

{ swap=false;

for( j=1; j<=n-i; j++)

if( count++,R[j]key>R[j+1]key )

{ R[0]=R[j];

R[j]=R[j+1];

R[j+1]=R[0];

swap=true;

}

if( !swap ) break;

}

}

void bubberSort1( Etp R[], int n )//这个也是另一个冒泡排序的函数

{ int j;//跟上面不同的是这个算法用的是递归的方式，上面的是非递归的

for( j=1; j<=n-1; j++)

if( count++,R[j]key>R[j+1]key )

{ R[0]=R[j];

R[j]=R[j+1];//________;//就是两个变量交换值

R[j+1]=R[0];

}

if( n>1 ) bubberSort1( R, n-1); //___________;//递归调用

}

void selectSort( Etp R[], int n )//这个是选择排序

{ int i,j,k;//（这个函数块就是选择排序的算法程序）

for( i=1; i<=n-1; i++)

{

k=i;

for( j=i+1; j<=n; j++)

if( count++,R[j]key<R[k]key ) k=j;

if( k!=i )

{ R[0]=R[i];

R[i]=R[k];

R[k]=R[0];

}

}

}

void insertSort( Etp R[], int n )//这个是插入排序

{ int i,j;

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

{

R[0]=R[i];

j=i-1;

while( count++,R[j]key>R[0]key ) R[j+1]=R[j--];

R[j+1]=R[0];

count++;

}

}

void sift( Etp R[], int i, int m)//堆排序中的步骤

{ int k=2i;

R[0]=R[i];

while( k<=m )

{ if( count++, k+1<=m && R[k+1]key>R[k]key) k++;

if( count++,R[0]key<R[k]key ) R[i]=R[k];

else break;

i=k;

k=2i;

}

R[i]=R[0];

}

void heapSort( Etp R[], int n )//这个是堆排序

{ int j;

for( j=n/2; j>=1; j--) sift( R, j, n);

for( j=n; j>=2; j--)

{ R[0]=R[1];

R[1]=R[j];

R[j]=R[0];

sift( R, 1, j-1 );

}

}

int main()//主函数的进入口

{

readData( R, n );//读取数据

bubberSort1( R, n );//调用递归冒泡排序

printData( R, n);//显示数据

readData( R, n );//读取数据

selectSort( R, n );//调用选择排序

printData( R, n);//显示数据

readData( R, n );//读取数据

insertSort( R, n );//调用插入排序

printData( R, n);//显示数据

readData( R, n );//读取数据

heapSort( R, n );//调用堆排序

printData( R, n);//显示数据

return 0;

}

//诶·~注释完我总算看出来了，难道你要我解释各个排序的过程？

//那你还不如直接baidu或者看书，你要是不理解原理是不可能看懂过程的。

//注释也只是语句的解释，但是过程的含义是无法描述的

以上就是关于求冒泡排序法 简单程序，从大到小排列，6个数字全部的内容，包括:求冒泡排序法 简单程序，从大到小排列，6个数字、用有符号数实现排序的汇编语言程序、谁能给个以C++语言为基础的归并排序法啊，最好有例子哈````等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！