十个元素排列算法

❶ 排列组合公式及算法

P(m,n)=n*(n-1)(n-2)...(n-m+1)=n!/(n-m)!【n个元素中，取m个的排列】
C(m,n)=P(m,n)/P(m,m)=n(n-1)(n-2)...(n-m+1)/m!
=n!/[(n-m)!*m!].【n个元素中取m个元素的组合】
满意请把我列为最佳答案~~~~

❷ c++10个整数怎么进行排序

冒泡排序法

原理：

它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

冒泡排序算法的运作如下：

1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。

2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

3.针对所有的元素重复以上的步骤，除了最后一个。

4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。


代码如下:


#include<iostream>

using namespace std;

int main(){

//按照升序排列

int a[10]={15,13,2,3,6,5,88,-3,30,40};

int i,j,t;

for(i=0;i<9;i++){

for(j=0;j<(9-i);j++){

if(a[j]>a[j+1]){

t=a[j+1];

a[j+1]=a[j];

a[j]=t;

}

}//通过每次循环，沉下去一个最大的数

}//一种10个数，沉下去9个最大的数，就可以排序了

for(i=0;i<10;i++){

cout<<a[i]<<' ';

}

cout<<endl;

return 0;

}

分析：通过两两比较，第一次排序，会将最大的数88放到最后面a[9]中。。。。第九趟，a[1]=2，然后就排序完成

选择排序法

原理：

选择排序的基本思想是：每一趟在n-i+1（i=1，2，…n-1）个记录中选取关键字最小的记录作为有序序列中第i个记录。

第i趟简单选择排序是指通过n-i次关键字的比较，从n-i+1个记录中选出关键字最小的记录，并和第i个记录进行交换。共需进行i-1趟比较，直到所有记录排序完成为止。例如：进行第i趟选择时，从当前候选记录中选出关键字最小的k号记录，并和第i个记录进行交换。

代码如下:

#include<iostream>

using namespace std;

int main(){

//按照升序排列

int a[10]={15,13,2,3,6,5,88,-3,30,40};

int i,j,t,k=0;

for(i=0;i<9;i++){

k=i;

for(j=i+1;j<10;j++){

if(a[j]<a[k]){

k=j;

}

}

t=a[k];

a[k]=a[i];

a[i]=t;

}

for(i=0;i<10;i++){

cout<<a[i]<<' ';

}

cout<<endl;

return 0;

}

❸ 排列组合A和C都有哪些计算方法

计算方法——

（1）排列数公式

排列用符号A(n,m)表示，m≦n。

计算公式是：A(n,m)＝n(n-1)(n-2)……(n-m+1)＝n!/(n-m)!

此外规定0!=1，n!表示n(n-1)(n-2)…1

例如：6!=6x5x4x3x2x1=720，4!=4x3x2x1=24。

（2）组合数公式

组合用符号C(n,m)表示，m≦n。

公式是：C(n,m)=A(n,m)/m!或C(n,m)=C(n,n-m)。

例如：C(5,2)=A(5,2)/[2!x(5-2)!]=(1x2x3x4x5)/[2x(1x2x3)]=10。

(3)十个元素排列算法扩展阅读：

排列有两种定义，但计算方法只有一种，凡是符合这两种定义的都用这种方法计算；定义的前提条件是m≦n，m与n均为自然数。

（1）从n个不同元素中，任取m个元素按照一定的顺序排成一列，叫做从n个不同元素中取出m个元素的一个排列。

（2）从n个不同元素中，取出m个元素的所有排列的个数，叫做从n个不同元素中取出m个元素的排列数。

❹ 排序算法有多少种

排序(Sorting) 是计算机程序设计中的一种重要操作，它的功能是将一个数据元素（或记录）的任意序列，重新排列成一个关键字有序的序列。
排序就是把集合中的元素按照一定的次序排序在一起。一般来说有升序排列和降序排列2种排序，在算法中有8中基本排序：
(1)冒泡排序；
(2)选择排序；
(3)插入排序；
(4)希尔排序；
(5)归并排序；
(6)快速排序；
(7)基数排序；
(8)堆排序；
(9)计数排序；
(10)桶排序。
插入排序
插入排序算法是基于某序列已经有序排列的情况下，通过一次插入一个元素的方式按照原有排序方式增加元素。这种比较是从该有序序列的最末端开始执行，即要插入序列中的元素最先和有序序列中最大的元素比较，若其大于该最大元素，则可直接插入最大元素的后面即可，否则再向前一位比较查找直至找到应该插入的位置为止。插入排序的基本思想是，每次将1个待排序的记录按其关键字大小插入到前面已经排好序的子序列中，寻找最适当的位置，直至全部记录插入完毕。执行过程中，若遇到和插入元素相等的位置，则将要插人的元素放在该相等元素的后面，因此插入该元素后并未改变原序列的前后顺序。我们认为插入排序也是一种稳定的排序方法。插入排序分直接插入排序、折半插入排序和希尔排序3类。
冒泡排序
冒泡排序算法是把较小的元素往前调或者把较大的元素往后调。这种方法主要是通过对相邻两个元素进行大小的比较，根据比较结果和算法规则对该二元素的位置进行交换，这样逐个依次进行比较和交换，就能达到排序目的。冒泡排序的基本思想是，首先将第1个和第2个记录的关键字比较大小，如果是逆序的，就将这两个记录进行交换，再对第2个和第3个记录的关键字进行比较，依次类推，重复进行上述计算，直至完成第(n一1)个和第n个记录的关键字之间的比较，此后，再按照上述过程进行第2次、第3次排序，直至整个序列有序为止。排序过程中要特别注意的是，当相邻两个元素大小一致时，这一步操作就不需要交换位置，因此也说明冒泡排序是一种严格的稳定排序算法，它不改变序列中相同元素之间的相对位置关系。
选择排序
选择排序算法的基本思路是为每一个位置选择当前最小的元素。选择排序的基本思想是，基于直接选择排序和堆排序这两种基本的简单排序方法。首先从第1个位置开始对全部元素进行选择，选出全部元素中最小的给该位置，再对第2个位置进行选择，在剩余元素中选择最小的给该位置即可；以此类推，重复进行“最小元素”的选择，直至完成第(n-1)个位置的元素选择，则第n个位置就只剩唯一的最大元素，此时不需再进行选择。使用这种排序时，要注意其中一个不同于冒泡法的细节。举例说明：序列58539．我们知道第一遍选择第1个元素“5”会和元素“3”交换，那么原序列中的两个相同元素“5”之间的前后相对顺序就发生了改变。因此，我们说选择排序不是稳定的排序算法，它在计算过程中会破坏稳定性。
快速排序
快速排序的基本思想是:通过一趟排序算法把所需要排序的序列的元素分割成两大块，其中，一部分的元素都要小于或等于另外一部分的序列元素，然后仍根据该种方法对划分后的这两块序列的元素分别再次实行快速排序算法，排序实现的整个过程可以是递归的来进行调用，最终能够实现将所需排序的无序序列元素变为一个有序的序列。
归并排序
归并排序算法就是把序列递归划分成为一个个短序列，以其中只有1个元素的直接序列或者只有2个元素的序列作为短序列的递归出口，再将全部有序的短序列按照一定的规则进行排序为长序列。归并排序融合了分治策略，即将含有n个记录的初始序列中的每个记录均视为长度为1的子序列，再将这n个子序列两两合并得到n/2个长度为2(当凡为奇数时会出现长度为l的情况)的有序子序列；将上述步骤重复操作，直至得到1个长度为n的有序长序列。需要注意的是，在进行元素比较和交换时，若两个元素大小相等则不必刻意交换位置，因此该算法不会破坏序列的稳定性，即归并排序也是稳定的排序算法。

❺ 给定一个有10个数的列表，应用冒泡排序算法，以升序输出列表。

#include"stdio.h"
#include"stdlib.h"
#include "string.h"
#define Max 100 //假设文件长度
typedef struct{ //定义记录类型
int key; //关键字项
}RecType;
typedef RecType SeqList[Max+1]; //SeqList为顺序表，表中第0个元素作为哨兵
int n; //顺序表实际的长度
//冒泡排序的基本思想：设想被排序的记录数组R[1‥n]垂直排序。根据轻气泡不能在重气泡之下的原则，从下往上扫描数组R，凡扫描到违反本原则的轻气泡，就使其向上"漂浮"（交换），如此反复进行，直到最后任意两个气泡都是轻者在上，重者在下为止。
//==========冒泡排序=======
typedef enum{FALSE,TRUE} Boolean; //FALSE为0，TRUE为1
void BubbleSort(SeqList R) { //自下向上扫描对R做冒泡排序
int i,j; Boolean exchange; //交换标志
for(i=1;i<n;i++) { //最多做n-1趟排序
exchange=FALSE; //本趟排序开始前，交换标志应为假
for(j=n-1;j>=i;j--) //对当前无序区R[i‥n] 自下向上扫描
if(R[j+1].key<R[j].key){ //两两比较，满足条件交换记录
R[0]=R[j+1]; //R[0]不是哨兵，仅做暂存单元
R[j+1]=R[j];
R[j]=R[0];
exchange=TRUE; //发生了交换，故将交换标志置为真
}
if(! exchange) //本趟排序未发生交换，提前终止算法
return;
}// endfor（为循环）
}//==========输入顺序表========
void input_int(SeqList R)
{
int i;
printf("Please input num(int):");
scanf("%d",&n);
printf("Plase input %d integer:",n);
for(i=1;i<=n;i++)
scanf("%d",&R[i].key);
}
//==========输出顺序表========
void output_int(SeqList R)
{
int i;
for(i=1;i<=n;i++)
printf("%4d",R[i].key);
}
//==========主函数======
void main()
{
SeqList R;
input_int(R);
BubbleSort(R);
printf("BubbleSort reult:");
output_int(R);
printf("\n");
}

❻ c语言编程:对10个数冒泡排序（升序）。

#include<stdio.h>

intmain(){

intnumber[10]={95,45,15,78,84,51,24,12，34，23};

for(int j=0;j< 9;j++)

for(int i=0;i< 9 -j;i++） {

if(a[i]>a[i+1]) {

a[i]=a[i+1];

a[i+1]=temp; }

}

for(int i=0;i< 10;i++）{

printf（“%d”，a[i]）; }

}

插入排序

已知一组升序排列数据a[1]、a[2]、……a[n]，一组无序数据b[1]、b[2]、……b[m]，需将二者合并成一个升序数列。

首先比较b[1]与a[1]的值，若b[1]大于a[1]，则跳过，比较b[1]与a[2]的值，若b[1]仍然大于a[2]，则继续跳过，直到b[1]小于a数组中某一数据a[x]，则将a[x]~a[n]分别向后移动一位，将b[1]插入到原来a[x]的位置这就完成了b[1]的插入。

b[2]~b[m]用相同方法插入。

快速排序

快速排序是大家已知的常用排序算法中最快的排序方法。已知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。首先任取数据a[x]作为基准。

比较a[x]与其它数据并排序，使a[x]排在数据的第k位，并且使a[1]~a[k-1]中的每一个数据<a[x]，a[k+1]~a[n]中的每一个数据>a[x]，然后采用分治的策略分别对a[1]~a[k-1]和a[k+1]~a[n]两组数据进行快速排序。

希尔排序

已知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。

首先取一增量d(d<n)，将a[1]、a[1+d]、a[1+2d]……列为第一组，a[2]、a[2+d]、a[2+2d]……列为第二组……，a[d]、a[2d]、a[3d]……列为最后一组以次类推，在各组内用插入排序，然后取d'<d，重复上述操作，直到d=1。

❼ 用C语言编程:用选择法对10个整数排序,10个整数用scanf函数输入

1、打开visual C++ 6.0，准备一个空白的c语言文件，引入头文件，在main函数中定义变量和数组：

❽ 输入十个正整数,采用选择排序法对其进行升序排列,排序要求采用函数实现。并利

#include <stdio.h>

#include<stdlib.h>

int i,j,a[10];

void sort(int a[],int n)

{

int i,j,t;

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

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

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

{t=a[j];a[j]=a[j+1];a[j+1]=t;}

}

void main()

{

int i,j;

srand((int)time(0));

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

{

a[i]=10+rand()%90;

printf("%d ", a[i]);

}

sort(a,10);

printf("After Sort:");

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

{

printf("%d ", a[i]);

if(i%5==4)printf("");

}

getch();

}

❾ 编程对一个具有十个元素的数组进行排序。

procere swap(var x,y:integer);
var
temp:integer;
begin
temp:=x;
x:=y;
y:=temp;
end;

//冒泡排序
procere BubbleSort(var A: array of Integer);
var
I, J, T: Integer;
begin
for I := High(A) downto Low(A) do
for J := Low(A) to High(A) - 1 do
if A[J] > A[J + 1] then
begin
swap(A[J], A[J + 1]);
T := A[J];
A[J] := A[J + 1];
A[J + 1] := T;
end;
end;

//选择排序
procere SelectionSort(var A: array of Integer);
var
I, J, T: Integer;
begin
for I := Low(A) to High(A) - 1 do
for J := High(A) downto I + 1 do
if A[I] > A[J] then
begin
Swap(A[I], A[J]);
T := A[I];
A[I] := A[J];
A[J] := T;
if Terminated then Exit;
end;
end;

//快速排序
procere QuickSort(var A: array of Integer);

procere QuickSortSub(var A: array of Integer; iLo, iHi: Integer);
var
Lo, Hi, Mid, T: Integer;
begin
Lo := iLo;
Hi := iHi;
Mid := A[(Lo + Hi) div 2];
repeat
while A[Lo] < Mid do Inc(Lo);
while A[Hi] > Mid do Dec(Hi);
if Lo <= Hi then
begin
Swap(A[Lo], A[Hi]);
T := A[Lo];
A[Lo] := A[Hi];
A[Hi] := T;
Inc(Lo);
Dec(Hi);
end;
until Lo > Hi;
if Hi > iLo then QuickSortSub(A, iLo, Hi);
if Lo < iHi then QuickSortSub(A, Lo, iHi);
end;

begin
QuickSortSub(A, Low(A), High(A));
end;
直接插入排序（Pascal)2007-04-18 16:16program InsSort;
const max=100;
type arr=array[0..max]of integer;
var a:arr;
i,n:integer;
fin:text;
procere InsSort(var r:arr; rn:integer); { 直接插入排序算法 }
var i,j:integer;
begin
for i:=2 to rn do
begin
r[0]:=r[i]; { 将待插入记录存放到监视哨r[0]里 }
j:=i-1;
while(r[0]<r[j]) do { 寻找插入位置 }
begin
r[j+1]:=r[j]; { 记录后移 }
dec(j);
end;
r[j+1]:=r[0]; { 将待插入记录插入到已排序的序列中 }
end;
end;

begin
assign(fin,'input.txt');
reset(fin);
readln(fin,n);
for i:=1 to n do read(fin,a[i]);
write('before sort:');
for i:=1 to n do write(a[i]:5); writeln;
InsSort(a,n);
write('after sort: ');
for i:=1 to n do write(a[i]:5); writeln;
close(fin);
readln;
end.

归并排序[Pascal]
type element=array[0..10001]of integer;
var arrhead,arrend:longint;
n,i:longint;
a:element;

procere merge(var a:element;x,y,z:longint);
var temp1,temp2:element;
lengthA,lengthB,i,j,count:longint;

begin
for i:=x to y do temp1[i-x+1]:=a[i];
for j:=y+1 to z do temp2[j-y]:=a[j];
lengthA:=y-x+1;
lengthB:=z-y;
i:=1; j:=1; count:=x-1;
while (i<=lengthA)and(j<=lengthB) do
begin
inc(count);
if temp1[i]>temp2[j] then begin a[count]:=temp2[j]; inc(j); end
else begin a[count]:=temp1[i]; inc(i); end;

end;
if i>lengthA then for i:=j to lengthB do a[count+i-j+1]:=temp2[i]
else for j:=i to lengthA do a[count+j-i+1]:=temp1[j];
end;

procere sort(var a:element;x,y:longint);
var mid:longint;
begin
mid:=(x+y) div 2;
if mid<>x then sort(a,x,mid);
if mid+1<>y then sort(a,mid+1,y);
merge(a,x,mid,y);
end;

begin
read(n);
for i:=1 to n do read(a[i]);
arrhead:=1;
arrend:=n;
sort(a,arrhead,arrend);
for i:=1 to n do begin write(a[i],' '); if i mod 5=0 then writeln; end;
end.

起泡法排序
procere Bubblesort (var R:filetype)
begin
for i:=1 to n-1 do //做N-1次排序
noswap:=true;//交换的标志
for j:=n-1 downto i do //从后往前扫描
if R[j+1].key < R[j].key then
temp :=R[j+1];
R[j+1]:=R[j];
R[j]:=temp;
noswap:=false
endif
endfor;
if noswap then //未发生交换则停止算法
return;
endif
endfor
end;
直接选择排序
procere selectsort (var R:filetype);
begin
for i:=1 to n-1 do
k:=i;
for j:=i+1 to n do
if R[j].key < R[k].key then
k:=j
endif
endfor;
if k不等于i then//靠TMD不能用那个符号,屏蔽的够多的
temp:R[i];
R[i]:=R[k];
R[k]:=temp
endif
endfor
end;

.堆排序的pascal实现
//此程序实现的为小根堆（满足性质父亲要比儿子小）
//程序实现的功能有:堆排序，以及取最小的元素
//数组最终将排序成降序
const maxn=1000;
var a:array[1..maxn] of longint;
size:longint;
i,n:longint;
procere swap(var a,b:longint);
var t:longint;
begin
t:=a;
a:=b;
b:=t;
end;
procere insert(x:longint);
var p:longint;
begin
inc(size);
p:=size;
while (a[p div 2]>x) and (p>1) do begin
a[p]:=a[p div 2];
p:=p div 2;
end;
a[p]:=x;
end;
procere heapfy(idx:longint);
var l,r,low:longint;
begin
l:=2*idx;
r:=2*idx+1;
if (a[l]<a[idx]) and (l<=size) then low:=l
else low:=idx;
if (a[r]<a[low]) and (r<=size) then low:=r;
if idx<>low then begin
swap(a[idx],a[low]);
heapfy(low);
end;
end;
function getmin:longint;
begin
exit(a[1]);
end;
function pop:longint;
begin
pop:=a[1];
a[1]:=a[size];
dec(size);
heapfy(1);
end;
begin
readln(n);
size:=0;
for i:=1 to n do
insert(random(1000));
for i:=1 to n do
a[n-i+1]:=pop;
for i:=1 to n do write(a[i],' ');
writeln;
end.
9