十個元素排列演算法

❶ 排列組合公式及演算法

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