以下是我收集并整理的8种排序算法代码,已经在Dev-C++中通过编译,可能有的排序算法并不准确,如果你发现什么不正确的地方,忘不吝赐教。
//=============== sort.cpp ===================================
#include <stdio.h>
#include <stdlib.h>
//======== 8种排序 ===============================
void Shell_Sort(int a[], int len);
void Half_Insert_Sort(int a[], int len);
void Insert_Sort(int a[], int len);
void Insert_Sort_With_Piquet(int a[], int len);
void Buble_Sort(int a[], int len);
void Select_Sort(int a[], int len);
void Quick_Sort(int a[], int left, int right);
void Heap_Sort(int a[], int len);
int Array_Adjust(int a[], int left, int right);
void Heap_Adjust_1(int a[], int s, int m);
void Heap_Adjust_2(int a[], int s, int m);
//=============== main主函数 ================================
int main(int argc, char* argv[])
{
int i;
int b[13];
int len=13;
int a[13]={49, 38, 65, 97, 76, 13, 27, 49, 55, 4, 345, 65, 23}; //从小到大排序结果应为: 4 13 27 38 49 49 55 76 97
printf("排序前的数组: ");
for(i=0; i<len; i++){printf("%d ",a[i]);b[i]=a[i];}
printf("\n\n");
//======== 1 ===========
Shell_Sort(a, len);
printf("1. Shell排序法结果: ");
for(i=0; i<len; i++){printf("%d ",a[i]);}
printf("\n\n");
//======== 2 ===========
for(i=0; i<len; i++){a[i]=b[i];}
Half_Insert_Sort(a, len);
printf("2. 二分插入法结果: ");
for(i=0; i<len; i++){printf("%d ",a[i]);}
printf("\n\n");
//======= 3 ============
for(i=0; i<len; i++){a[i]=b[i];}
Insert_Sort(a, len);
printf("3. 直接插入法结果: ");
for(i=0; i<len; i++){printf("%d ",a[i]);}
printf("\n\n");
//======= 4 ============
for(i=0; i<len; i++){a[i]=b[i];}
Insert_Sort_With_Piquet(a, len);
printf("4. 带哨兵的直接排序法结果: ");
for(i=0; i<len; i++){printf("%d ",a[i]);}
printf("\n\n");
//======= 5 ============
for(i=0; i<len; i++){a[i]=b[i];}
Buble_Sort(a, len);
printf("5. 冒泡排序法结果: ");
for(i=0; i<len; i++){printf("%d ",a[i]);}
printf("\n\n");
//======= 6 ============
for(i=0; i<len; i++){a[i]=b[i];}
Select_Sort(a, len);
printf("6. 选择排序法结果: ");
for(i=0; i<len; i++){printf("%d ",a[i]);}
printf("\n\n");
//======= 7 ============
for(i=0; i<len; i++){a[i]=b[i];}
Quick_Sort(a, 0, len-1);
printf("7. 快速排序法结果: ");
for(i=0; i<len; i++){printf("%d ",a[i]);}
printf("\n\n");
//======= 8 ============
for(i=0; i<len; i++){a[i]=b[i];}
Heap_Sort(a, len);
printf("8. 堆排序法结果: ");
for(i=0; i<len; i++){printf("%d ",a[i]);}
printf("\n\n");
system("pause");
return 0;
}
//======================== 1. Shell排序法 ================================================
void Shell_Sort(int a[], int len)
{
int gap, i, j, temp;
for(gap=len/2; gap>0; gap/=2) //设置排序的步长,步长gap每次减半,直到减到1
{
for(i=gap; i<len; i++) //定位到每一个元素
{
for(j=i-gap; (j>=0) && (a[j]>a[j+gap]); j-=gap) //比较相距gap远的两个元素的大小,根据排序方向决定如何调换
{
temp=a[j];
a[j]=a[j+gap];
a[j+gap]=temp;
int m;printf("len=%d; gap=%d; i=%d; j=%d: ",len,gap,i,j);for(m=0; m<len; m++){if(m==j || m==j+gap){printf("[%d] ",a[m]);}else{printf("%d ",a[m]);}}printf("\n");
}
}
}
}
//======================== 2. 二分插入法 ================================================
void Half_Insert_Sort(int a[], int len)
{
int i, j, temp;
int low, high, mid;
for(i=1; i<len; i++)
{
temp = a[i]; //保存当前元素
low = 0;
high = i-1;
while(low <= high) //在a[low...high]中折半查找有序插入的位置
{
mid = (low + high)/2; //找到中间元素
if(a[mid] > temp) //如果中间元素比但前元素大,当前元素要插入到中间元素的左侧
{
high = mid-1;
}
else //如果中间元素比当前元素小,但前元素要插入到中间元素的右侧
{
low = mid+1;
}
} //找到当前元素的位置,在low和high之间
for(j=i-1; j>high; j--) //元素后移
{
a[j+1] = a[j];
}
a[high+1] = temp; //插入
int m;printf("len=%d; i=%d; j=%d; low=%d; high=%d: ",len,i,j,low,high);for(m=0; m<len; m++){if(m==i || m==high+1){printf("[%d] ",a[m]);}else{printf("%d ",a[m]);}}printf("\n");
}
}
//======================== 3. 直接插入法 ================================================
void Insert_Sort(int a[], int len)
{
int i, j, temp;
for(i=1; i<len; i++)
{
temp = a[i]; //操作当前元素,先保存在其它变量中
for(j=i-1; j>-1 && a[j]>temp; j--) //从当前元素的上一个元素开始查找合适的位置
{
a[j+1] = a[j]; //一边找一边移动元素
a[j] = temp;
int m;printf("len=%d; i=%d; j=%d: ",len,i,j);for(m=0; m<len; m++){if(m==j || m==j+1){printf("[%d] ",a[m]);}else{printf("%d ",a[m]);}}printf("\n");
}
}
}
//======================== 4. 带哨兵的直接排序法 ================================================
/**************************************************************
* 带哨兵的直接插入排序,数组的第一个元素不用于存储有效数据
* 将a[0]作为哨兵,可以避免判定a[j]中,数组是否越界
* 因为在j--的过程中,当j减小到0时,变成了a[0]与a[0]
* 自身进行比较,很明显这个时候说明位置i之前的数字都比a[i]小
* 位置i上的数字不需要移动,直接进入下一轮的插入比较。
**************************************************************/
void Insert_Sort_With_Piquet(int a[], int len)
{
int i, j, temp;
for(i=1; i<len; i++)
{
temp = a[i]; //临时变量,不知是不是所谓的"哨兵"
for(j=i; j>0 && a[j-1]>temp; j--)
{
a[j] = a[j-1]; //交换顺序
}
a[j]=temp;
int m;printf("len=%d; i=%d; j=%d: ",len,i,j);for(m=0; m<len; m++){if(m==i || m==j){printf("[%d] ",a[m]);}else{printf("%d ",a[m]);}}printf("\n");
}
}
//======================== 5. 冒泡排序法 ================================================
/**************************************************************
* 此算法先把最大的元素进行排序
**************************************************************/
void Buble_Sort(int a[], int len)
{
int i, j, temp;
for(i=0; i<len; i++) //气泡法要排序len次
{
for(j=0; j<len-i-1; j++) //值比较大的元素沉下去后,只把剩下的元素中的最大值再沉下去就可以啦
{
if(a[j]>a[j+1]) //把值比较大的元素沉到底
{
temp=a[j];
a[j]=a[j+1]; //交换顺序
a[j+1]=temp;
int m;printf("len=%d; i=%d; j=%d: ",len,i,j);for(m=0; m<len; m++){if(m==j || m==j+1){printf("[%d] ",a[m]);}else{printf("%d ",a[m]);}}printf("\n");
}
}
}
}
//======================== 6. 选择排序法 ================================================
/**************************************************************
* 此算法与冒泡排序法刚好相反,先把最小的元素进行排序
**************************************************************/
void Select_Sort(int a[], int len)
{
int i, j, temp;
for(i=0; i<len; i++)
{
for(j=i+1; j<len; j++) //从j往前的数据都是排好的,所以从j开始往下找剩下的元素中最小的
{
if(a[i]>a[j]) //把剩下元素中最小的那个放到a[i]中
{
temp=a[i];
a[i]=a[j];
a[j]=temp;
int m;printf("len=%d; i=%d; j=%d: ",len,i,j);for(m=0; m<len; m++){if(m==i || m==j){printf("[%d] ",a[m]);}else{printf("%d ",a[m]);}}printf("\n");
}
}
}
}
//======================== 7. 快速排序法 ================================================
/**************************************************************
* 快速排序(quick sort)。在这种方法中,
* n 个元素被分成三段(组):左段left,
* 右段right和中段middle。中段
* 仅包含一个元素。左段中各元素都小于等
* 于中段元素,右段中各元素都大于等于中
* 段元素。因此left和right中的元
* 素可以独立排序,并且不必对left和
* right的排序结果进行合并。
* 使用快速排序方法对a[0:n-1]排序
* 从a[0:n-1]中选择一个元素作为middle,
* 该元素为支点把余下的元素分割为两段left
* 和right,使得left中的元素都小于
* 等于支点,而right 中的元素都大于等于支点
* 递归地使用快速排序方法对left 进行排序
* 递归地使用快速排序方法对right 进行排序
* 所得结果为left+middle+right
*
* 可以参考 http://www.cnblogs.com/morewindows/archive/2011/08/13/2137415.html
* 快速排序=挖坑填数+分治法
* 对挖坑填数进行总结
* 1.i=Left; j=Right; 将基准数挖出形成第一个坑a[i]。
* 2.j--由后向前找比它小的数,找到后挖出此数填前一个坑a[i]中。
* 3.i++由前向后找比它大的数,找到后也挖出此数填到前一个坑a[j]中。
* 4.再重复执行2,3二步,直到i==j,将基准数填入a[i]中。
* 照着这个总结很容易实现挖坑填数的代码:
**************************************************************/
void Quick_Sort(int a[], int left, int right)
{
if(left<right)
{
int mid=Array_Adjust(a,left,right);
if(left<mid-1) //避免栈溢出
Quick_Sort(a,left,mid-1); //递归调用
if(mid+1<right) //避免栈溢出
Quick_Sort(a,mid+1,right); //递归调用
}
}
/*******************************************
/* 要注意看清楚下面的数据之间是如何替换的,
* 首先选一个中间值,就是第一个元素a[low],
* 然后从该元素的最右侧开始找到比它小的元素,把
* 该元素复制到它中间值原来的位置(a[low]=a[high]),
* 然后从该元素的最左侧开始找到比它大的元素,把
* 该元素复制到上边刚刚找到的那个元素的位置(a[high]=a[low]),
* 最后将这个刚空出来的位置装入中间值(a[low]=a[0]),
* 这样一来比mid大的都会跑到mid的右侧,小于mid的会在左侧,
* 最后一行,返回的low是中间元素的位置,左右分别递归就可以排好序了。
********************************************/
int Array_Adjust(int a[], int left, int right)
{
int mid=a[left]; //a[left]就是第一个坑
while(left<right)
{
while((left<right) && (a[right]>=mid))
{
right--;
}
if(left<right)
{
a[left]=a[right]; //从right的位置开始往left的方向找,找到比a[left]小的元素,存到a[left]中
left++;
}
while((left<right) && (a[left]<mid)) //新得到的a[low]肯定小于原来的a[low]即mid
{
left++;
}
if(left<right)
{
a[right]=a[left]; //从left的位置开始往right的方向找,找到比a[right]小的元素,存到a[right]中
right--;
}
}
a[left]=mid; //把left的新位置存上原来的a[left]的数据
return left; //递归时,把它做为右侧元素的left
}
//======================== 8. 堆排序法 ================================================
/**************************************************************
* 堆的定义 n 个元素的序列 {k1,k2,...,kn}当且仅当满足下列关系时,
* 称为堆:
* ki<=k2i ki<=k2i+1 (i=1,2,...,n/2)
* 或
* ki>=k2i ki>=k2i+1 (i=1,2,...,n/2)
* 堆排序思路:
* 建立在树形选择排序基础上;
* 将待排序列建成堆(初始堆生成)后,序列的第一个元素(堆顶元素)就一定是序列中的最大元素;
* 将其与序列的最后一个元素交换,将序列长度减一;
* 再将序列建成堆(堆调整)后,堆顶元素仍是序列中的最大元素,再次将其与序列最后一个元素交换并缩短序列长度;
* 反复此过程,直至序列长度为一,所得序列即为排序后结果。
* 可以参考 http://blog.csdn.net/morewindows/article/details/6709644
**************************************************************/
void Heap_Sort(int a[], int len) //堆排序函数
{
int i, temp;
for(i=len/2-1; i>=0; i--) //先建立最大堆,升序排列
{
Heap_Adjust_1(a,i,len); //处理后,a[i]是这个数组后半部分的最大值
}
for(i=len-1; i>=1; i--)
{
temp=a[0]; //把根元素(剩下元素中最大的那个)放到结尾 ,下一次只要排剩下的数就可以啦
a[0]=a[i];
a[i]=temp;
Heap_Adjust_1(a,0,i);
}
}
void Heap_Adjust_1(int a[], int s, int n) //最大堆, s是start的意思,即第二叉树s个节点 ,m是节点总数,即数组长度
{
int j, temp;
temp=a[s]; //保存处理元素
for(j=2*s+1; j<n; j=2*s+1) //处理父亲元素
{
if(j+1<n && a[j]<a[j+1]) //在左右孩子中找最大的
{
j++;
}
if(a[j]<=temp)
{
break;
}
a[s]=a[j]; //把较大的子结点往上移动,替换它的父结点
s=j;
}
a[s]=temp;
}
void Heap_Adjust_2(int a[], int s, int n) //最小堆, s是start的意思,即二叉树第s个节点 ,m是节点总数,即数组长度
{
int j, temp;
temp=a[s]; //保存处理元素
for(j=2*s+1; j<n; j=2*s+1) //处理父亲元素
{
if(j+1<n && a[j+1]<a[j]) //在左右孩子中找最小的
{
j++;
}
if(a[j]>=temp)
{
break;
}
a[s]=a[j]; //把较小的子结点往上移动,替换它的父结点
s=j;
}
a[s]=temp;
}
//======================= 输出结果如下 ====================================================
排序前的数组: 49 38 65 97 76 13 27 49 55 4 345 65 23
len=13; gap=6; i=6; j=0: [27] 38 65 97 76 13 [49] 49 55 4 345 65 23
len=13; gap=6; i=8; j=2: 27 38 [55] 97 76 13 49 49 [65] 4 345 65 23
len=13; gap=6; i=9; j=3: 27 38 55 [4] 76 13 49 49 65 [97] 345 65 23
len=13; gap=6; i=12; j=6: 27 38 55 4 76 13 [23] 49 65 97 345 65 [49]
len=13; gap=6; i=12; j=0: [23] 38 55 4 76 13 [27] 49 65 97 345 65 49
len=13; gap=3; i=3; j=0: [4] 38 55 [23] 76 13 27 49 65 97 345 65 49
len=13; gap=3; i=5; j=2: 4 38 [13] 23 76 [55] 27 49 65 97 345 65 49
len=13; gap=3; i=7; j=4: 4 38 13 23 [49] 55 27 [76] 65 97 345 65 49
len=13; gap=3; i=12; j=9: 4 38 13 23 49 55 27 76 65 [49] 345 65 [97]
len=13; gap=1; i=2; j=1: 4 [13] [38] 23 49 55 27 76 65 49 345 65 97
len=13; gap=1; i=3; j=2: 4 13 [23] [38] 49 55 27 76 65 49 345 65 97
len=13; gap=1; i=6; j=5: 4 13 23 38 49 [27] [55] 76 65 49 345 65 97
len=13; gap=1; i=6; j=4: 4 13 23 38 [27] [49] 55 76 65 49 345 65 97
len=13; gap=1; i=6; j=3: 4 13 23 [27] [38] 49 55 76 65 49 345 65 97
len=13; gap=1; i=8; j=7: 4 13 23 27 38 49 55 [65] [76] 49 345 65 97
len=13; gap=1; i=9; j=8: 4 13 23 27 38 49 55 65 [49] [76] 345 65 97
len=13; gap=1; i=9; j=7: 4 13 23 27 38 49 55 [49] [65] 76 345 65 97
len=13; gap=1; i=9; j=6: 4 13 23 27 38 49 [49] [55] 65 76 345 65 97
len=13; gap=1; i=11; j=10: 4 13 23 27 38 49 49 55 65 76 [65] [345] 97
len=13; gap=1; i=11; j=9: 4 13 23 27 38 49 49 55 65 [65] [76] 345 97
len=13; gap=1; i=12; j=11: 4 13 23 27 38 49 49 55 65 65 76 [97] [345]
1. Shell排序法结果: 4 13 23 27 38 49 49 55 65 65 76 97 345
len=13; i=1; j=-1; low=0; high=-1: [38] [49] 65 97 76 13 27 49 55 4 34
len=13; i=2; j=1; low=2; high=1: 38 49 [65] 97 76 13 27 49 55 4 345 65
len=13; i=3; j=2; low=3; high=2: 38 49 65 [97] 76 13 27 49 55 4 345 65
len=13; i=4; j=2; low=3; high=2: 38 49 65 [76] [97] 13 27 49 55 4 345
len=13; i=5; j=-1; low=0; high=-1: [13] 38 49 65 76 [97] 27 49 55 4 34
len=13; i=6; j=0; low=1; high=0: 13 [27] 38 49 65 76 [97] 49 55 4 345
len=13; i=7; j=3; low=4; high=3: 13 27 38 49 [49] 65 76 [97] 55 4 345
len=13; i=8; j=4; low=5; high=4: 13 27 38 49 49 [55] 65 76 [97] 4 345
len=13; i=9; j=-1; low=0; high=-1: [4] 13 27 38 49 49 55 65 76 [97] 34
len=13; i=10; j=9; low=10; high=9: 4 13 27 38 49 49 55 65 76 97 [345]
len=13; i=11; j=7; low=8; high=7: 4 13 27 38 49 49 55 65 [65] 76 97 [3
len=13; i=12; j=1; low=2; high=1: 4 13 [23] 27 38 49 49 55 65 65 76 97
2. 二分插入法结果: 4 13 23 27 38 49 49 55 65 65 76 97 345
len=13; i=1; j=0: [38] [49] 65 97 76 13 27 49 55 4 345 65 23
len=13; i=4; j=3: 38 49 65 [76] [97] 13 27 49 55 4 345 65 23
len=13; i=5; j=4: 38 49 65 76 [13] [97] 27 49 55 4 345 65 23
len=13; i=5; j=3: 38 49 65 [13] [76] 97 27 49 55 4 345 65 23
len=13; i=5; j=2: 38 49 [13] [65] 76 97 27 49 55 4 345 65 23
len=13; i=5; j=1: 38 [13] [49] 65 76 97 27 49 55 4 345 65 23
len=13; i=5; j=0: [13] [38] 49 65 76 97 27 49 55 4 345 65 23
len=13; i=6; j=5: 13 38 49 65 76 [27] [97] 49 55 4 345 65 23
len=13; i=6; j=4: 13 38 49 65 [27] [76] 97 49 55 4 345 65 23
len=13; i=6; j=3: 13 38 49 [27] [65] 76 97 49 55 4 345 65 23
len=13; i=6; j=2: 13 38 [27] [49] 65 76 97 49 55 4 345 65 23
len=13; i=6; j=1: 13 [27] [38] 49 65 76 97 49 55 4 345 65 23
len=13; i=7; j=6: 13 27 38 49 65 76 [49] [97] 55 4 345 65 23
len=13; i=7; j=5: 13 27 38 49 65 [49] [76] 97 55 4 345 65 23
len=13; i=7; j=4: 13 27 38 49 [49] [65] 76 97 55 4 345 65 23
len=13; i=8; j=7: 13 27 38 49 49 65 76 [55] [97] 4 345 65 23
len=13; i=8; j=6: 13 27 38 49 49 65 [55] [76] 97 4 345 65 23
len=13; i=8; j=5: 13 27 38 49 49 [55] [65] 76 97 4 345 65 23
len=13; i=9; j=8: 13 27 38 49 49 55 65 76 [4] [97] 345 65 23
len=13; i=9; j=7: 13 27 38 49 49 55 65 [4] [76] 97 345 65 23
len=13; i=9; j=6: 13 27 38 49 49 55 [4] [65] 76 97 345 65 23
len=13; i=9; j=5: 13 27 38 49 49 [4] [55] 65 76 97 345 65 23
len=13; i=9; j=4: 13 27 38 49 [4] [49] 55 65 76 97 345 65 23
len=13; i=9; j=3: 13 27 38 [4] [49] 49 55 65 76 97 345 65 23
len=13; i=9; j=2: 13 27 [4] [38] 49 49 55 65 76 97 345 65 23
len=13; i=9; j=1: 13 [4] [27] 38 49 49 55 65 76 97 345 65 23
len=13; i=9; j=0: [4] [13] 27 38 49 49 55 65 76 97 345 65 23
len=13; i=11; j=10: 4 13 27 38 49 49 55 65 76 97 [65] [345] 23
len=13; i=11; j=9: 4 13 27 38 49 49 55 65 76 [65] [97] 345 23
len=13; i=11; j=8: 4 13 27 38 49 49 55 65 [65] [76] 97 345 23
len=13; i=12; j=11: 4 13 27 38 49 49 55 65 65 76 97 [23] [345]
len=13; i=12; j=10: 4 13 27 38 49 49 55 65 65 76 [23] [97] 345
len=13; i=12; j=9: 4 13 27 38 49 49 55 65 65 [23] [76] 97 345
len=13; i=12; j=8: 4 13 27 38 49 49 55 65 [23] [65] 76 97 345
len=13; i=12; j=7: 4 13 27 38 49 49 55 [23] [65] 65 76 97 345
len=13; i=12; j=6: 4 13 27 38 49 49 [23] [55] 65 65 76 97 345
len=13; i=12; j=5: 4 13 27 38 49 [23] [49] 55 65 65 76 97 345
len=13; i=12; j=4: 4 13 27 38 [23] [49] 49 55 65 65 76 97 345
len=13; i=12; j=3: 4 13 27 [23] [38] 49 49 55 65 65 76 97 345
len=13; i=12; j=2: 4 13 [23] [27] 38 49 49 55 65 65 76 97 345
3. 直接插入法结果: 4 13 23 27 38 49 49 55 65 65 76 97 345
len=13; i=1; j=0: [38] [49] 65 97 76 13 27 49 55 4 345 65 23
len=13; i=2; j=2: 38 49 [65] 97 76 13 27 49 55 4 345 65 23
len=13; i=3; j=3: 38 49 65 [97] 76 13 27 49 55 4 345 65 23
len=13; i=4; j=3: 38 49 65 [76] [97] 13 27 49 55 4 345 65 23
len=13; i=5; j=0: [13] 38 49 65 76 [97] 27 49 55 4 345 65 23
len=13; i=6; j=1: 13 [27] 38 49 65 76 [97] 49 55 4 345 65 23
len=13; i=7; j=4: 13 27 38 49 [49] 65 76 [97] 55 4 345 65 23
len=13; i=8; j=5: 13 27 38 49 49 [55] 65 76 [97] 4 345 65 23
len=13; i=9; j=0: [4] 13 27 38 49 49 55 65 76 [97] 345 65 23
len=13; i=10; j=10: 4 13 27 38 49 49 55 65 76 97 [345] 65 23
len=13; i=11; j=8: 4 13 27 38 49 49 55 65 [65] 76 97 [345] 23
len=13; i=12; j=2: 4 13 [23] 27 38 49 49 55 65 65 76 97 [345]
4. 带哨兵的直接排序法结果: 4 13 23 27 38 49 49 55 65 65 76 97 345
len=13; i=0; j=0: [38] [49] 65 97 76 13 27 49 55 4 345 65 23
len=13; i=0; j=3: 38 49 65 [76] [97] 13 27 49 55 4 345 65 23
len=13; i=0; j=4: 38 49 65 76 [13] [97] 27 49 55 4 345 65 23
len=13; i=0; j=5: 38 49 65 76 13 [27] [97] 49 55 4 345 65 23
len=13; i=0; j=6: 38 49 65 76 13 27 [49] [97] 55 4 345 65 23
len=13; i=0; j=7: 38 49 65 76 13 27 49 [55] [97] 4 345 65 23
len=13; i=0; j=8: 38 49 65 76 13 27 49 55 [4] [97] 345 65 23
len=13; i=0; j=10: 38 49 65 76 13 27 49 55 4 97 [65] [345] 23
len=13; i=0; j=11: 38 49 65 76 13 27 49 55 4 97 65 [23] [345]
len=13; i=1; j=3: 38 49 65 [13] [76] 27 49 55 4 97 65 23 345
len=13; i=1; j=4: 38 49 65 13 [27] [76] 49 55 4 97 65 23 345
len=13; i=1; j=5: 38 49 65 13 27 [49] [76] 55 4 97 65 23 345
len=13; i=1; j=6: 38 49 65 13 27 49 [55] [76] 4 97 65 23 345
len=13; i=1; j=7: 38 49 65 13 27 49 55 [4] [76] 97 65 23 345
len=13; i=1; j=9: 38 49 65 13 27 49 55 4 76 [65] [97] 23 345
len=13; i=1; j=10: 38 49 65 13 27 49 55 4 76 65 [23] [97] 345
len=13; i=2; j=2: 38 49 [13] [65] 27 49 55 4 76 65 23 97 345
len=13; i=2; j=3: 38 49 13 [27] [65] 49 55 4 76 65 23 97 345
len=13; i=2; j=4: 38 49 13 27 [49] [65] 55 4 76 65 23 97 345
len=13; i=2; j=5: 38 49 13 27 49 [55] [65] 4 76 65 23 97 345
len=13; i=2; j=6: 38 49 13 27 49 55 [4] [65] 76 65 23 97 345
len=13; i=2; j=8: 38 49 13 27 49 55 4 65 [65] [76] 23 97 345
len=13; i=2; j=9: 38 49 13 27 49 55 4 65 65 [23] [76] 97 345
len=13; i=3; j=1: 38 [13] [49] 27 49 55 4 65 65 23 76 97 345
len=13; i=3; j=2: 38 13 [27] [49] 49 55 4 65 65 23 76 97 345
len=13; i=3; j=5: 38 13 27 49 49 [4] [55] 65 65 23 76 97 345
len=13; i=3; j=8: 38 13 27 49 49 4 55 65 [23] [65] 76 97 345
len=13; i=4; j=0: [13] [38] 27 49 49 4 55 65 23 65 76 97 345
len=13; i=4; j=1: 13 [27] [38] 49 49 4 55 65 23 65 76 97 345
len=13; i=4; j=4: 13 27 38 49 [4] [49] 55 65 23 65 76 97 345
len=13; i=4; j=7: 13 27 38 49 4 49 55 [23] [65] 65 76 97 345
len=13; i=5; j=3: 13 27 38 [4] [49] 49 55 23 65 65 76 97 345
len=13; i=5; j=6: 13 27 38 4 49 49 [23] [55] 65 65 76 97 345
len=13; i=6; j=2: 13 27 [4] [38] 49 49 23 55 65 65 76 97 345
len=13; i=6; j=5: 13 27 4 38 49 [23] [49] 55 65 65 76 97 345
len=13; i=7; j=1: 13 [4] [27] 38 49 23 49 55 65 65 76 97 345
len=13; i=7; j=4: 13 4 27 38 [23] [49] 49 55 65 65 76 97 345
len=13; i=8; j=0: [4] [13] 27 38 23 49 49 55 65 65 76 97 345
len=13; i=8; j=3: 4 13 27 [23] [38] 49 49 55 65 65 76 97 345
len=13; i=9; j=2: 4 13 [23] [27] 38 49 49 55 65 65 76 97 345
5. 冒泡排序法结果: 4 13 23 27 38 49 49 55 65 65 76 97 345
len=13; i=0; j=1: [38] [49] 65 97 76 13 27 49 55 4 345 65 23
len=13; i=0; j=5: [13] 49 65 97 76 [38] 27 49 55 4 345 65 23
len=13; i=0; j=9: [4] 49 65 97 76 38 27 49 55 [13] 345 65 23
len=13; i=1; j=5: 4 [38] 65 97 76 [49] 27 49 55 13 345 65 23
len=13; i=1; j=6: 4 [27] 65 97 76 49 [38] 49 55 13 345 65 23
len=13; i=1; j=9: 4 [13] 65 97 76 49 38 49 55 [27] 345 65 23
len=13; i=2; j=5: 4 13 [49] 97 76 [65] 38 49 55 27 345 65 23
len=13; i=2; j=6: 4 13 [38] 97 76 65 [49] 49 55 27 345 65 23
len=13; i=2; j=9: 4 13 [27] 97 76 65 49 49 55 [38] 345 65 23
len=13; i=2; j=12: 4 13 [23] 97 76 65 49 49 55 38 345 65 [27]
len=13; i=3; j=4: 4 13 23 [76] [97] 65 49 49 55 38 345 65 27
len=13; i=3; j=5: 4 13 23 [65] 97 [76] 49 49 55 38 345 65 27
len=13; i=3; j=6: 4 13 23 [49] 97 76 [65] 49 55 38 345 65 27
len=13; i=3; j=9: 4 13 23 [38] 97 76 65 49 55 [49] 345 65 27
len=13; i=3; j=12: 4 13 23 [27] 97 76 65 49 55 49 345 65 [38]
len=13; i=4; j=5: 4 13 23 27 [76] [97] 65 49 55 49 345 65 38
len=13; i=4; j=6: 4 13 23 27 [65] 97 [76] 49 55 49 345 65 38
len=13; i=4; j=7: 4 13 23 27 [49] 97 76 [65] 55 49 345 65 38
len=13; i=4; j=12: 4 13 23 27 [38] 97 76 65 55 49 345 65 [49]
len=13; i=5; j=6: 4 13 23 27 38 [76] [97] 65 55 49 345 65 49
len=13; i=5; j=7: 4 13 23 27 38 [65] 97 [76] 55 49 345 65 49
len=13; i=5; j=8: 4 13 23 27 38 [55] 97 76 [65] 49 345 65 49
len=13; i=5; j=9: 4 13 23 27 38 [49] 97 76 65 [55] 345 65 49
len=13; i=6; j=7: 4 13 23 27 38 49 [76] [97] 65 55 345 65 49
len=13; i=6; j=8: 4 13 23 27 38 49 [65] 97 [76] 55 345 65 49
len=13; i=6; j=9: 4 13 23 27 38 49 [55] 97 76 [65] 345 65 49
len=13; i=6; j=12: 4 13 23 27 38 49 [49] 97 76 65 345 65 [55]
len=13; i=7; j=8: 4 13 23 27 38 49 49 [76] [97] 65 345 65 55
len=13; i=7; j=9: 4 13 23 27 38 49 49 [65] 97 [76] 345 65 55
len=13; i=7; j=12: 4 13 23 27 38 49 49 [55] 97 76 345 65 [65]
len=13; i=8; j=9: 4 13 23 27 38 49 49 55 [76] [97] 345 65 65
len=13; i=8; j=11: 4 13 23 27 38 49 49 55 [65] 97 345 [76] 65
len=13; i=9; j=11: 4 13 23 27 38 49 49 55 65 [76] 345 [97] 65
len=13; i=9; j=12: 4 13 23 27 38 49 49 55 65 [65] 345 97 [76]
len=13; i=10; j=11: 4 13 23 27 38 49 49 55 65 65 [97] [345] 76
len=13; i=10; j=12: 4 13 23 27 38 49 49 55 65 65 [76] 345 [97]
len=13; i=11; j=12: 4 13 23 27 38 49 49 55 65 65 76 [97] [345]
6. 选择排序法结果: 4 13 23 27 38 49 49 55 65 65 76 97 345
7. 快速排序法结果: 4 13 23 27 38 49 49 55 65 65 76 97 345
8. 堆排序法结果: 4 13 23 27 38 49 49 55 65 65 76 97 345
请按任意键继续. . .