以下是我收集并整理的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


请按任意键继续. . .