3. 用任意一种编程语言（C/C++/Java/C#/VB.NET）写出任意一种你所知的排序算法（比如：冒泡排序， 归并排

Answer 1

#include<stdio.h>
#include<stdlib.h>
void BubbleSort(int a[], const int first, const int last);//冒泡排序
void InsertSort(int a[], const int first, const int last);//插入排序
void SelectSort(int a[], const int first, const int last);//选择排序
void MergeSort(int a[], const int p, const int r);//合并排序
void QuickSort(int a[],const int p,const int r);//快速排序
void ShellSort(int a[],const int p,const int r,const int dlta[],const int t);//希尔排序
void HeapSort(int a[],const int p, int r); //堆排序
void StoogeSort(int a[],const int p,const int r);//Stooge排序(不用)算法复杂度没算清楚

void main()
{
//插入排序算法
int a[11] = {6,4,5,3,2,1};
int dlta[]={9,5,3,2,1};
//BubbleSort(a,0,5);
//InsertSort(a,0,5);
//SelectSort(a,0,5);
//MergeSort(a,0,5);
//QuickSort(a,0,5);
//ShellSort(a,0,5,dlta,5);
HeapSort(a,0,5);
//StoogeSort(a,0,5);

for(int i=0; i<=5;i++)
{
printf("%d ",a[i]);
}

}

/************************冒泡排序***********************/
void BubbleSort(int a[], int first, int last)
{
//实现对数组a[]中a[first]到a[last]升序的“冒泡”排序
int i,j,temp;
for(i=first; i<=last; i++)
{
for(j=first; j< last-i; j++)
{
if(a[j] > a[j+1])
{
temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}
}
}

/************************插入排序***********************/
void InsertSort(int a[], int first, int last)
{
//实现对数组a[]中a[first]到a[last]升序的“插入”排序
//最坏情况为n的平方，，多用于小数组
int i,j,temp;
for(i=first+1; i<=last; i++)
{
temp = a[i];
j = i - 1;
while((j >= 0) && (a[j] > temp))
{
a[j+1] = a[j];
j--;
}
a[j+1] = temp;
}
}

/************************选择排序***********************/
void SelectSort(int a[], int first, int last)
{
//实现对数组a[]中a[first]到a[last]升序的“选择”排序
int i, j, temp, num;
for(i=first; i<last; i++)
{
num = i;
for(j=i+1; j<=last; j++)
{
if(a[j] < a[num])
{
num = j;
}
}
if(i != num)
{
temp = a[num];
a[num] = a[i];
a[i] = temp;
}
}
}

/************************合并排序***********************/
void Merge(int a[],const int p,const int q,const int r)
{
//合并排序算法中的实现合并的子程序
int iLLength,iRLength;
int *L, *R, i, j, k;
iLLength = q - p + 1;
iRLength = r - q;
L = (int *)malloc(iLLength*sizeof(int)); //或者 C++中 new int[iLLength];
R = (int *)malloc(iRLength*sizeof(int)); //或者 C++中 new int[iRLength];
if(L == 0 || R== 0)
{
printf("内存分配失败！！！");
return;
}
for(i=0; i<iLLength; i++)
{
L[i] = a[p+i];
}
for(j=0; j<iRLength; j++)
{
R[j] = a[q+j+1];
}
i = 0;
j = 0;
for(k=p; k<=r; k++)
{
if((i<iLLength) && (j<iRLength) && (L[i]<=R[j]) || (j == iRLength))
{
a[k] = L[i];
i++;
}
else if(j<iRLength)
{
a[k] = R[j];
j++;
}
}

free(R);free(L);
}
void MergeSort(int a[],const int p,const int r)
{
//合并排序算法-主程序
//n*lg(n),系数较小
int q;
if(p<r)
{
q = (p+r)/2;
MergeSort(a,p,q);
MergeSort(a,q+1,r);
Merge(a,p,q,r);
}
}

/************************Stooge排序***********************/
void StoogeSort(int a[],const int p,const int r)
{
//Stooge算法
int temp, k;
if(a[p]>a[r])
{
temp = a[p];
a[p] = a[r];
a[r] = temp;
}
if((p+1) >= r)
{
return;
}
k = (r-p+1)/3;
StoogeSort(a,p,r-k);
StoogeSort(a,p+k,r);
StoogeSort(a,p,r-k);
}

/************************快速排序*********************/
int QuickPartition(int a[],const int p,const int r)
{
//快速排序的(关键)分治过程
int temp, x, i, j;
x = a[r];
i = p - 1;
for(j=p; j<r; j++)
{
if(a[j] <= x)
{
i = i + 1;
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
temp = a[i+1];
a[i+1] = a[r];
a[r] = temp;
return (i+1);
}
/*
void QuickSort(int a[],const int p,const int r)
{
//快速排序算法-主程序
//与下面的“尾递归实现方法”比较，缺点：右边数组的递归不是必须的，增加了运行堆栈深度和调用开销
int q;
if(p < r)
{
q = QuickPartition(a, p, r);
QuickSort(a, p, q-1);
QuickSort(a, q+1, r);
}
}
*/
void QuickSort(int a[],int p,const int r)
{
//快速排序算法-主程序
//“尾递归实现方法”是对上面的快速排序主程序实现的一种优化
//系数较小,常用大数组
int q;
while(p < r)
{
q = QuickPartition(a, p, r);
QuickSort(a, p, q-1);
p = q + 1;
}
}

/************************希尔排序**********************/
void ShellInsert(int a[],const int p,const int r, int dk)
{
//希尔排序算法的关键子程序-插入排序子程序
int i, j, temp;
for(i=p+dk; i<=r; i++)
{
if(a[i] < a[i-dk])
{
temp = a[i];
for(j=i-dk; ((j>=0) && (temp < a[j])); j -= dk)
{
a[j+dk] = a[j];
}
a[j+dk] = temp;
}
}
}

void ShellSort(int a[],const int p,const int r,const int dlta[],const int t)
{
//希尔排序算法-主程序
//按增量序列dlta[]中的前t个增量，实现对数组a[]中a[p]到a[r]的排序
//dlta[]可能取值如：1,2,3,5,9 dala[k]=2^(t-k+1)-1 其中0<=k<=t<=ld(b-1)
//增量序列的最后一个值必须是1
//增量序列中的值没有除1以外的因子， 其精确时间复杂度：数学上尚未解决的难题
int k;
for(k=0; k<t; k++)
{
ShellInsert(a,p,r,dlta[k]);
}
}

/************************堆排序***********************/
//堆排序，不如快速排序
//但是可用其来实现“优先级队列”
int Parent(int i)
{
return ((i+1)/2-1);
}

int Right(int i)
{
return (2*(i+1)-1);
}

int Left(int i)
{
return (2*(i+1));
}

void Max_Heapify(int a[],const int hplast,const int i)
{
int l, r,largest,temp;
l = Left(i);
r = Right(i);
largest = ((l<=hplast) && (a[l]>a[i])) ? l:i;
if((r<=hplast) && (a[r]>a[largest]))
{
largest = r;
}
if(largest != i)
{
temp = a[i];
a[i] = a[largest];
a[largest] = temp;
Max_Heapify(a,hplast,largest);
}

}

void Build_Max_Heap(int a[],const int p, const int r)
{
int i;
for(i = (p+r)/2; i>=p; i--)
{
Max_Heapify(a,r,i);
}
}

void HeapSort(int a[],const int p, int r)
{
int i,temp;
Build_Max_Heap(a,p,r);
for(i = r; i > p; i--)
{
temp = a[p];
a[p] = a[i];
a[i] = temp;
r -= 1;
Max_Heapify(a,r,0);
}
}

参考资料：http://hi.baidu.com/bbilu/blog/item/fbd6c6d4caa50602a08bb707.html

Answer 2

好吧 呵呵 这是冒泡排序（C＋＋）
#include<iostream>
using namespace std;

int main()
{
int arr[10]={5,6,8,1,2,4,9,3,7,0};
int i,j;
for(i=0;i<10;i++)／／冒泡排序
for(j=i;j<10;j++)
if(arr[i]>arr[j])
{
int temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
for(i=0;i<10;i++)／／输出排序后的结果
cout<<arr[i]<<" ";
cout<<endl;
return 0;
}

Answer 3

C语言写的 快排
#include <stdio.h>
#include <stdlib.h>
void sort(int l, int r, int *a)
{ int i, j, x;
x=a[l];
i=l;
j=r;
while(i<j){
while(i<j&&a[j]>=x) j--;
if(i<j) {swap(a+i,a+j); i++;}
while(i<j&&a[i]<=x) i++;
if(i<j) {swap(a+i,a+j); j--;}
}
if(l<r) {sort(l, i-1, a+l);
sort(i+1, r, a+i+1);}
}
void press(int n, int *a)
{ int i;
for(i=0;i<n;i++) printf("%d ", a[i]);
}

main()
{ int n;
int *a, i, j;
scanf("%d", &n);
a = (int*)malloc(sizeof(int)*(n));
for(i=0;i<n;i++) scanf("%d", a+i);
sort(0, n, a);
press(n, a);
free(a);
}

Answer 4

http://www.ericyue.info/archive/sorting-algorithm
里面有大学阶段所有的排序。已经调试

参考资料：http://www.ericyue.info/archive/sorting-algorithm

Answer 5

冒泡排序：
C语言
程序1：
void bubble_sort(int array[],int n)
{
int i,j,flag,temp;
for(i = 0; i < n-1; i++)
{
flag = 1;
for(j = 0; j < n-i-1; j++)
{
if(array[j] > array[j+1])
{
temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
flag = 0;
}
}
if(flag == 1) break;
printf("%d ",i);
}
return;
}
程序2：（可进行2个数以上大小比较，程序参考作者：苏祥）
#include<STDIO.H>
main()
{
long a,x,k,i[100],s;
char ch;
for(a=0;;a++)
{
printf("输入一个数，输完一个数按回车，最后一个数末尾要加n:");
scanf("%ld%c",&i[a],&ch);
if(ch=='n')
break;
}
do{
x=0;
for(k=0;k<a;k++)
{
if(i[k]>i[k+1])
{
s=i[k+1];i[k+1]=i[k];
i[k]=s;x++;
}
}
}while(x!=0);
printf("从小到大排列为:");
for(k=0;k<a;k++)
printf("%ld<",i[k]);
printf("%ld",i[a]);
}
C++
#include <iostream>
#define LEN 9
using namespace std;
int main()
{
int nArray[LEN];
for(int i=0;i<LEN;i++)nArray[i]=LEN-i;
cout<<"原始数据为："<<endl;
for(int i=0;i<LEN;i++)cout<<nArray[i]<<" ";
cout<<endl;
//开始冒泡
{
int temp;
for(int i=LEN-1;i>0;i--)
for(int j=0;j<i;j++)
{
if(nArray[j]>nArray[j+1])
{
temp=nArray[j];
nArray[j]=nArray[j+1];
nArray[j+1]=temp;
}
}
}
//结束冒泡
cout<<"排序结果:"<<endl;
for(int i=0;i<LEN;i++)cout<<nArray[i]<<" ";
return 0;
}
PHP
<?php
//冒泡排序（一维数组）
function bubble_sort($array)
{
$count = count($array);
if ($count <= 0) return false;
for($i=0; $i<$count; $i++)
{
for($j=$count-1; $j>$i; $j--)
{
if ($array[$j] < $array[$j-1])
{
$tmp = $array[$j];
$array[$j] = $array[$j-1];
$array[$j-1] = $tmp;
}
}
}
return $array;
}
//使用实例
$_array = array('5', '8' ,'5' ,'6' ,'9' ,'3' ,'2' ,'4');
$_array = bubble_sort($_array);
print ($_array);
?>
Ruby
def bubble(arr)
(arr.length-1).downto(1) do |j|
a1 = arr.dup
j.times do |i|
if arr > arr[i+1]
arr,arr[i+1] = arr[i+1],arr
end
end
break if a1 == arr
end
arr
end
Java
// 冒泡排序
public class BubbleSort {
public static void sort(Comparable[] data) {
// 数组长度
int len = data.length;
for (int i = 0; i < len - 1; i++) {
// 临时变量
Comparable temp = null;
// 交换标志,false表示未交换
boolean isExchanged = false;
for (int j = len - 1; j > i; j--) {
// 如果data[j]小于data[j - 1],交换
if (data[j].compareTo(data[j - 1]) < 0) {
temp = data[j];
data[j] = data[j - 1];
data[j - 1] = temp;
// 发生了交换,故将交换标志置为真
isExchanged = true;
}// end if
}// end for
// 本趟排序未发生交换,提前终止算法,提高效率
if (!isExchanged) {
return;
}// end if
}// end for
}// end sort
public static void main(String[] args) {
// 在JDK1.5版本以上,基本数据类型可以自动装箱
// int,double等基本类型的包装类已实现了Comparable接口
Comparable[] c = { 4, 9, 23, 1, 45, 27, 5, 2 };
sort(c);
for (Comparable data : c) {
System.out.println(data);
}
}
}
Visual Basic
Private Sub Form_Load()
Dim a, c As Variant
Dim i As Integer, j As Integer, temp As Integer, bSwap As Boolean
a = Array(17, 45, 12, 80, 50)
For j = 0 To UBound(a) - 1
bSwap = False
For i = 0 To UBound(a) - 1
If (a(i) > a(i + 1)) Then '若是递减,改为a(i)<a(i+1)
temp = a(i)
a(i) = a(i + 1)
a(i + 1) = temp
bSwap = True
End If
Next
If bSwap = False Then
Exit For
End If
Next
For Each c In a
Debug.Print c;
Next
End Sub
Pascal
program name;
var
a:array[1..N] of 1..MAX;
temp,i,j:integer;
begin
randomize;
for i:=1 to N do a:=1+random(MAX);
writeln('Array before sorted:');
for i:=1 to N do write(a,' ');
writeln;
for i:=N-1 downto 1 do
for j:=1 to i do
if a[j]<a[j+1] then
begin
temp:=a[j];
a[j]:=a[j+1];
a[j+1]:=temp
end;
writeln('Array sorted:');
for i:=1 to N do write(a,' ');
writeln;
writeln('End sorted.');
readln;
end.
C#
public void BubbleSort(int[] array)
{
int length = array.Length;
for (int i = 0; i <= length - 1; i++)
{
for (int j = length - 1; j > i; j--)
{
if (array[j] < array[j - 1] )
{
int temp = array[j];
array[j] = array[j - 1];
array[j - 1] = temp;
}
}
}
}
Python
#BubbleSort used python3.1 or python 2.x
def bubble(str):
tmplist = list(str)
count = len(tmplist)
for i in range(0,count-1):
for j in range(0,count-1):
if tmplist[j] > tmplist[j+1]:
tmplist[j],tmplist[j+1] = tmplist[j+1],tmplist[j]
return tmplist
#useage:
str = "zbac"
print(bubble(str)) # ['a', 'b', 'c', 'z']
number=[16,134,15,1]
print(bubble(number)) # [1, 15, 16, 134]
JS
function(array){
var i = 0, len = array.length,
j, d;
for(; i<len; i++){
for(j=0; j<len; j++){
if(array[i] < array[j]){
d = array[j];
array[j] = array[i];
array[i] = d;
}
}
}
return array;
}
伪代码
BUBBLESORT(A)
for i <- 1 to length[A]
do for j <- length[A] downto i + 1
do if A[j]<A[j - 1]
then exchange A[j] <-> A[j-1]

堆排序：
Pascal中的较简单实现
var
i,j,k,n:integer;
a:array[0..100] of integer;
procedure swap(var a,b:integer);
var t:integer;
begin t:=a;a:=b;b:=t;
end;
procedure heapsort(i,m:integer);
var t:integer;
begin
t:=i*2;
while t<=m do
begin
if (t<m) and (a[t]>a[t+1]) then inc(t);
if a[i]>a[t] then begin swap(a[i],a[t]);i:=t;t:=2*i; end
else break;
end;
end;
begin
readln(n);
for i:=1 to n do read(a[i]);
for i:=n div 2 downto 1 do heapsort(i,n);
for i:=n downto 2 do
begin
write(a[1],' ');
a[1]:=a[i];
heapsort(1,i-1);
end;
writeln(a[1]);
end.
堆排序的JAVA实现
public class Test {
public static int[] Heap = { 10, 32, 1, 9, 5, 7, 12, 0, 4, 3 }; // 预设数据数组
public static void main(String args[]) {
int i; // 循环计数变量
int Index = Heap.length; // 数据索引变量
System.out.print("排序前: ");
for (i = 1; i < Index - 1; i++)
System.out.printf("%3s", Heap);
System.out.println("");
HeapSort(Index - 2); // 堆排序
System.out.print("排序后: ");
for (i = 1; i < Index - 1; i++)
System.out.printf("%3s", Heap);
System.out.println("");
}
/**
* 建立堆
*/
public static void CreateHeap(int Root, int Index) {
int i, j; // 循环计数变量
int Temp; // 暂存变量
int Finish; // 判断堆是否建立完成
j = 2 * Root; // 子节点的Index
Temp = Heap[Root]; // 暂存Heap的Root 值
Finish = 0; // 预设堆建立尚未完成
while (j <= Index && Finish == 0) {
if (j < Index) // 找最大的子节点
if (Heap[j] < Heap[j + 1])
j++;
if (Temp >= Heap[j])
Finish = 1; // 堆建立完成
else {
Heap[j / 2] = Heap[j]; // 父节点 = 目前节点
j = 2 * j;
}
}
Heap[j / 2] = Temp; // 父节点 = Root值
}
public static void HeapSort(int Index) {
int i, j, Temp;
// 将二叉树转成Heap
for (i = (Index / 2); i >= 1; i--)
CreateHeap(i, Index);
// 开始进行堆排序
for (i = Index - 1; i >= 1; i--) {
Temp = Heap; // Heap的Root值和最后一个值交换
Heap = Heap[1];
Heap[1] = Temp;
CreateHeap(1, i); // 对其余数值重建堆
System.out.print("排序中: ");
for (j = 1; j <= Index; j++)
System.out.printf("%3s",Heap[j]);
System.out.println("");
}
}
}
编辑本段
堆排序的c++实现（降序）

/* 这是经过优化的代码。一般都用大根堆，但是如果用小根堆实现，每次都将最小的元素放到最后一个，可以省一半空间。用c数组是因为我写一道题目需要给c数组排序……直接粘过去，偷懒一下 &^_^& */
#include<iostream>
using namespace std;
int c[1000];
int n,m;
void check(int i)
{
int min;
if(m>=i*2+1) //不能用n，因为需要排序的元素个数在不断变化
{
if(c[i*2+1]<c[i*2])
min=i*2+1;
else
min=i*2;
if(c[min]<c[i])
{
swap(c[i],c[min]);
check(min);
}
} //这几行也可以换成判断然后交换c[i]和c[i*2+1]，又可以省去几行。哈哈。
else
if(m>=i*2 && c[i*2]<c[i])
{
swap(c[i*2],c[i]);
check(i*2);
}
}
//check函数用来维持小根堆
void tree()
{
m=n;
for(int i=m/2;i>=1;i--)
check(i);
while(m!=1)
{
swap(c[1],c[m]); //将最小的元素放到最后，这个元素以后的元素就是有序的，不用参加排序了
m--;
check(1);
}
}
//tree函数用来建堆
int main()
{
cin>>n;
for(int i=1;i<=n;i++)
cin>>c[i];
tree();
for(int i=1;i<=n;i++)
cout<<c[i]<<' ';
cout<<endl;
system("pause"); //为了方便观察结果才写的这一行，提交题目的时候一定要删掉！！！
return 0;
}
归并排序：
static void merge(int array[], int low, int mid, int high)
{
int i, k;
int *temp = (int *) malloc((high-low+1) * sizeof(int)); //申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
int begin1 = low;
int end1 = mid;
int begin2 = mid + 1;
int end2 = high;

for (k = 0; begin1 <= end1 && begin2 <= end2; ++k) //比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
if(array[begin1]<=array[begin2])
temp[k] = array[begin1++];
else
temp[k] = array[begin2++];
if(begin1 <= end1) //若第一个序列有剩余，直接拷贝出来粘到合并序列尾
memcpy(temp+k, array+begin1, (end1-begin1+1)*sizeof(int));
if(begin2 <= end2) //若第二个序列有剩余，直接拷贝出来粘到合并序列尾
memcpy(temp+k, array+begin2, (end2-begin2+1)*sizeof(int));
memcpy(array+low, temp, (high-low+1)*sizeof(int));//将排序好的序列拷贝回数组中
free(temp);
}
另一个Ruby语言的例子。
def merge(left, right)
final = []
until left.empty? or right.empty?
final << ( left.first < right.first ? left.shift : right.shift )
end
final + left + right
end
Java 语言
public int[] Two_Way_Merge_Sort(int[] A, int[] B) {
int[] C = new int[A.length + B.length];
int k = 0;
int i = 0;
int j = 0;
while(i < A.length && j < B.length) {
if (A[i] < B[j])
C[k++] = A[i++];
else
C[k++] = B[j++];
}
while (i < A.length)
C[k++] = A[i++];
while (j < B.length)
C[k++] = B[j++];
return C;
}
}
呵呵，累死我了，能不能加点分啊？