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

Posted 2023-03-22

#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

参考技术A 好吧 呵呵 这是冒泡排序（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;
参考技术B 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);
参考技术C http://www.ericyue.info/archive/sorting-algorithm
里面有大学阶段所有的排序。已经调试

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

参考技术D 冒泡排序：
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;


呵呵，累死我了，能不能加点分啊？

c语言

---恢复内容开始---

4. 今天突然想起来一个问题，但一时又想不起方法

C语言编程题,从键盘输入任意3个数,按从小到大的顺序输出

这个是第一种，正常的思考逻辑。

#include <stdio.h>

 

//输入三个数，按从小到大顺序输出 

 

int main(void)

    int a, b, c, min, median, max;

     

    scanf("%d%d%d", &a,&b,&c);

     

    if (a>b)

    

        if (a>c)

        

            max = a;

            if (b>c)

            

                median = b;

                min = c;

            

            else

            

                median = c;

                min = b;

            

        

        else

        

            max = c;

            median = a;

            min = b;

        

    

    else if (b>c)

    

        max = b;

        if(a>c)

        

            median = a;

            min = c;

        

        else

        

            median = c;

            min = a;

        

    

     

    printf("%d < %d < %d\n", min, median, max);

     

    return 0;

第二种：逆向思维

// 输入3个数，要求按从小到大顺序输出  

   

#include <stdio.h>  

   

int main()  

  

    int a,b,c,t;  

    printf("请输入三个数：");  

    scanf("%d%d%d",&a,&b,&c);  

    if(a > b)  

      

        t = a;  

        a = b;  

        b = t;  

      

    if(a > c)  

      

        t = a;  

        a = c;  

        c = t;  

      

    if(b > c)  

      

        t = b;  

        b = c;  

        c = t;  

      

    printf("从小到大的顺序是：%d  %d  %d\n",a,b,c);  

    return 0;  

---恢复内容结束---

4. 今天突然想起来一个问题，但一时又想不起方法

C语言编程题,从键盘输入任意3个数,按从小到大的顺序输出

这个是第一种，正常的思考逻辑。

#include <stdio.h>

 

//输入三个数，按从小到大顺序输出 

 

int main(void)

    int a, b, c, min, median, max;

     

    scanf("%d%d%d", &a,&b,&c);

     

    if (a>b)

    

        if (a>c)

        

            max = a;

            if (b>c)

            

                median = b;

                min = c;

            

            else

            

                median = c;

                min = b;

            

        

        else

        

            max = c;

            median = a;

            min = b;

        

    

    else if (b>c)

    

        max = b;

        if(a>c)

        

            median = a;

            min = c;

        

        else

        

            median = c;

            min = a;

        

    

     

    printf("%d < %d < %d\n", min, median, max);

     

    return 0;

第二种：逆向思维

// 输入3个数，要求按从小到大顺序输出  

   

#include <stdio.h>  

   

int main()  

  

    int a,b,c,t;  

    printf("请输入三个数：");  

    scanf("%d%d%d",&a,&b,&c);  

    if(a > b)  

      

        t = a;  

        a = b;  

        b = t;  

      

    if(a > c)  

      

        t = a;  

        a = c;  

        c = t;  

      

    if(b > c)  

      

        t = b;  

        b = c;  

        c = t;  

      

    printf("从小到大的顺序是：%d  %d  %d\n",a,b,c);  

    return 0;