排序演算法的流程圖
① 如何用傳統流程圖表示將四個數按從大到小順序排序的演算法
可以用冒泡排序法：定義一個數組a[n]，將n個數或更多的數存進去。
然後將a[i]和a[i+1]比較，小的往後移，如此下去，就得到了排序結果。程序段如下：
for(j=n;j>0;j--)
{
for(i=0;i<n;i++)
{
if(a[i]<a[i+1])
{
k=a[i];a[i]=a[i+1];a[i+1]=k;
}
}
}
還可以有其他的演算法，因為只有4個數，所以你可以先取出兩個數比較大小，並排序，然後用第3個數與排好的兩個數分別比較，然後插入到排序隊伍中，然後是第4個，這樣也很容易。
② 拓撲排序的流程圖
由AOV網構造拓撲序列的拓撲排序演算法主要是循環執行以下兩步，直到不存在入度為0的頂點為止：選擇一個入度為0的頂點並輸出之；從網中刪除此頂點及所有出邊。
循環結束後，若輸出的頂點數小於網中的頂點數，則輸出「有迴路」信息，否則輸出的頂點序列就是一種拓撲序列。
由AOV網構造出拓撲序列的實際意義是：如果按照拓撲序列中的頂點次序，在開始每一項活動時，能夠保證它的所有前驅活動都已完成，從而使整個工程順序進行，不會出現沖突的情況。
(2)排序演算法的流程圖擴展閱讀
拓撲排序（Topological Sorting）為一個有向無環圖（DAG，Directed Acyclic Graph）的所有頂點的線性序列。且該序列必須滿足下面兩個條件：每個頂點出現且只出現一次。若存在一條從頂點A到頂點B的路徑，那麼在序列中頂點A出現在頂點B的前面。
拓撲排序常用來確定一個依賴關系集中，事物發生的順序。例如，在日常工作中，可能會將項目拆分成A、B、C、D四個子部分來完成，但A依賴於B和D，C依賴於D。為了計算這個項目進行的順序，可對這個關系集進行拓撲排序，得出一個線性的序列，則排在前面的任務就是需要先完成的任務。
③ 排序演算法的N-S流程圖
我敲代碼敲了一年都未做過流程圖啊，上機考試時老師甚至都不讓我們帶草稿紙，說用不著(真正的程序員是不需要流程圖的)
以下是我以前敲過的代碼，隨便復制了一些
//直接插入排序
#include<iostream>
using namespace std;
void Print(int *ar,int n){
int i;
for(i=1;i<=n;i++)
cout<<ar[i]<<" ";
cout<<endl;
}
int main(){
int i,j,*ar,n;
cin>>n;
ar=new int[n+1];
for(i=1;i<=n;i++)
cin>>ar[i];
for(i=2;i<=n;i++){
if(ar[i-1]>ar[i]){
ar[0]=ar[i];
for(j=i-1;ar[0]<ar[j];j--)
ar[j+1]=ar[j];
ar[j+1]=ar[0];
}
Print(ar,n);
}
cout<<endl;
return 0;
}
//折半插入排序
#include<iostream>
using namespace std;
void Print(int *ar,int n){
int i;
for(i=1;i<=n;i++)
cout<<ar[i]<<" ";
cout<<endl;
}
int main(){
int i,n,*ar,h,l,m;
cin>>n;
ar=new int[n+1];
for(i=1;i<=n;i++)
cin>>ar[i];
for(i=2;i<=n;i++){
ar[0]=ar[i];
l=1;
h=i-1;
while(l<=h){
m=(l+h)/2;
if(ar[0]<ar[m])
h=m-1;
else
l=m+1;
}
for(m=i;m>h+1;m--)
ar[m]=ar[m-1];
ar[h+1]=ar[0];
Print(ar,n);
}
return 0;
}
//希爾排序
#include<iostream>
using namespace std;
void Print(int *ar,int n){
int i;
for(i=1;i<=n;i++)
cout<<ar[i]<<" ";
cout<<endl;
}
void ShellInsert(int *ar,int n,int dk){
int i,j;
for(i=1+dk;i<=n;i++){
if(ar[i-dk]>ar[i]){
ar[0]=ar[i];
for(j=i-dk;j>0&&ar[0]<ar[j];j-=dk)
ar[j+dk]=ar[j];
ar[j+dk]=ar[0];
}
}
}
void ShellSort(int *ar,int n){
int i;
for(i=n/2;i>0;i/=2){ //以n/2為dk
ShellInsert(ar,n,i);
Print(ar,n);
}
}
int main(){
int n,*ar,i;
cin>>n;
ar=new int[n+1];
for(i=1;i<=n;i++)
cin>>ar[i];
ShellSort(ar,n);
return 0;
}
//冒泡排序
#include<iostream>
using namespace std;
void Print(int *ar,int n){
int i;
for(i=0;i<n;i++)
cout<<ar[i]<<" ";
cout<<endl;
}
int main(){
int n,*ar,t,i,j;
bool b=0;
cin>>n;
ar=new int[n];
for(i=0;i<n;i++)
cin>>ar[i];
for(i=1;i<n;i++){
b=0;
for(j=0;j<n-i;j++){
if(ar[j]>ar[j+1]){
t=ar[j];
ar[j]=ar[j+1];
ar[j+1]=t;
b=1;
}
}
Print(ar,n);
if(b==0)
break;
}
return 0;
}
//快速排序
#include<iostream>
using namespace std;
void Print(int *ar,int n){
int i;
for(i=0;i<n;i++)
cout<<ar[i]<<" ";
cout<<endl;
}
int Por(int *ar,int l,int h){
int k=ar[l];
while(l<h){
while(l<h&&k<=ar[h])
h--;
ar[l]=ar[h];
while(l<h&&k>=ar[l])
l++;
ar[h]=ar[l];
}
ar[l]=k;
return l;
}
void QSort(int *ar,int l,int h,int n){
if(l<h){
int m=Por(ar,l,h);
Print(ar,n);
QSort(ar,l,m-1,n);
QSort(ar,m+1,h,n);
}
}
int main(){
int i,*ar,n;
cin>>n;
ar=new int[n];
for(i=0;i<n;i++)
cin>>ar[i];
QSort(ar,0,n-1,n);
return 0;
}
//簡單選擇排序
#include<iostream>
using namespace std;
void Print(int *ar,int n){
int i;
for(i=0;i<n;i++)
cout<<ar[i]<<" ";
cout<<endl;
}
int main(){
int i,j,t,*ar,n,max;
cin>>n;
ar=new int[n];
for(i=0;i<n;i++)
cin>>ar[i];
for(i=0;i<n-1;i++){
max=i;;
for(j=i+1;j<n;j++){
if(ar[max]>ar[j])
max=j;
}
t=ar[max];
ar[max]=ar[i];
ar[i]=t;
Print(ar,n);
}
return 0;
}
//堆排序
#include<iostream>
using namespace std;
void Print(int *ar,int n){
int i;
for(i=1;i<=n;i++)
cout<<ar[i]<<" ";
cout<<endl;
}
void HeapAdjust(int *ar,int i,int n){
int j,t=ar[i];
for(j=i*2;j<=n;j*=2){
if(j<n&&ar[j]<ar[j+1])
j++;
if(t>ar[j])
break;
ar[i]=ar[j];
i=j;
}
ar[i]=t;
}
void HeapSort(int *ar,int n){
int i;
for(i=n/2;i>=1;i--)
HeapAdjust(ar,i,n);
Print(ar,n);
for(i=n;i>1;i--){
ar[0]=ar[i];
ar[i]=ar[1];
ar[1]=ar[0];
HeapAdjust(ar,1,i-1);
Print(ar,n);
}
}
int main(){
int *ar,i,n;
cin>>n;
ar=new int[n+1];
for(i=1;i<=n;i++)
cin>>ar[i];
HeapSort(ar,n);
return 0;
}
//非遞歸歸並排序
#include<iostream>
using namespace std;
void Print(int *ar,int n){
int i;
for(i=0;i<n;i++)
cout<<ar[i]<<" ";
cout<<endl;
}
void MergeSort(int *ar,int n){
int i,*ar2,p,q,t,l,h,m;
ar2=new int[n];
for(i=1;i<n;i*=2){
l=0;
while(l<n){
p=t=l;
q=m=l+i;
if(m>=n)
break;
h=m+i;
if(h>n)
h=n;
while(p<m||q<h){
if(q>=h||(p<m&&ar[p]<=ar[q]))
ar2[t++]=ar[p++];
else
ar2[t++]=ar[q++];
}
l=h;
}
for(t=0;t<h;t++)
ar[t]=ar2[t];
Print(ar,n);
}
}
int main(){
int i,n,*ar;
cin>>n;
ar=new int[n];
for(i=0;i<n;i++)
cin>>ar[i];
MergeSort(ar,n);
return 0;
}
//基數排序
#include<iostream>
using namespace std;
typedef struct{
int num[10];
int next;
}Node;
Node sq[100];
int e[100];
int f[100];
void Distribute(int i,int n){
int t,j,k=sq[0].next;
for(j=0;j<n;j++){
t=sq[k].num[i];
if(f[t]==0)
f[t]=k;
else
sq[e[t]].next=k;
e[t]=k;
k=sq[k].next;
}
}
void Collect(){
int i,j;
for(i=0;i<10;i++){
if(f[i]!=0){
sq[0].next=f[i];
j=e[i];
break;
}
}
for(i++;i<10;i++){
if(f[i]!=0){
sq[j].next=f[i];
j=e[i];
}
}
}
void Print(int max,int n){
int i,j,k=sq[0].next;
for(i=0;i<n;i++){
for(j=max-1;j>=0;j--)
cout<<sq[k].num[j];
cout<<" ";
k=sq[k].next;
}
cout<<endl;
}
void RadixSort(int max,int n){
int i,j;
for(i=0;i<=n;i++)
sq[i].next=i+1;
for(i=0;i<max;i++){
for(j=0;j<10;j++)
e[j]=f[j]=0;
Distribute(i,n);
Collect();
Print(max,n);
}
}
int main(){
int i,j,imp,n,max=0;
cin>>n;
for(i=1;i<=n;i++){
cin>>imp;
for(j=0;j<10&&imp!=0;imp/=10)
sq[i].num[j++]=imp%10;
if(max<j)
max=j;
while(j<10)
sq[i].num[j++]=0;
}
RadixSort(max,n);
return 0;
}
④ 冒泡排序從小到大流程圖
略 可以按照冒泡排序的方法及過程對所給數據逐趟進行排序． 我們將第一趟的排序過程詳細寫出，其餘各趟的排序過程不再詳細列出，如圖所示； 第1趟 上述演算法的流程圖如圖所示： 冒泡排序的演算法過程中主要以循環結構和選擇結構為主，同時也用到了變數與賦值．
⑤ 求一張選擇法排序演算法的流程圖
#include<iostream>
#include<time.h>
#include<iomanip>
using namespace std;
const int N=10;
int main()
{
int a[N],i,j,temp,b;
srand(time(NULL));
for(i=0;i<N;i++)
a[i]=rand()%100;
for(i=0;i<N;i++)
cout<<setw(3)<<a[i];
cout<<endl;
for(i=0;i<N-1;i++)
{
temp=i;
for(j=i+1;j<N;j++)
{
if(a[temp]>a[j])
temp=j;
}
if(i!=temp)
{
b=a[temp];
a[temp]=a[i];
a[i]=b;}
}
for(i=0;i<N;i++)
cout<<setw(3)<<a[i];
cout<<endl;
}
⑥ 跪求選擇排序流程圖
1、選擇排序流程圖：
(6)排序演算法的流程圖擴展閱讀：
基本選擇排序：
選擇排序輸出的是原序列的一個重排＜a1＊，a2＊，a3＊，．．．，an＊＞；，使得a1＊＜＝a2＊＜＝a3＊＜＝．．．＜＝an＊
排序演算法有很多，包括插入排序，冒泡排序，堆排序，歸並排序，選擇排序，計數排序，基數排序，桶排序，快速排序等。插入排序，堆排序，選擇排序，歸並排序和快速排序，冒泡排序都是比較排序，它們通過對數組中的元素進行比較來實現排序，其他排序演算法則是利用非比較的其它方法來獲得有關輸入數組的排序信息。
思想
n個記錄的文件的直接選擇排序可經過n－1趟直接選擇排序得到有序結果：
①初始狀態：無序區為R［1．．n］，有序區為空。
②第1趟排序
在無序區R［1．．n］中選出關鍵字最小的記錄R［k］，將它與無序區的第1個記錄R［1］交換，使R［1．．1］和R［2．．n］分別變為記錄個數增加1個的新有序區和記錄個數減少1個的新無序區。
……
③第i趟排序
第i趟排序開始時，當前有序區和無序區分別為R［1．．i－1］和R（i．．n）。該趟排序從當前無序區中選出關鍵字最小的記錄R［k］，將它與無序區的第1個記錄R交換，使R［1．．i］和R分別變為記錄個數增加1個的新有序區和記錄個數減少1個的新無序區。［1］
解釋
對比數組中前一個元素跟後一個元素的大小，如果後面的元素比前面的元素小則用一個變數k來記住他的位置，接著第二次比較，前面「後一個元素」現變成了「前一個元素」，繼續跟它的「後一個元素」進行比較如果後面的元素比他要小則用變數k記住它在數組中的位置（下標），
等到循環結束的時候，應該找到了最小的那個數的下標了，然後進行判斷，如果這個元素的下標不是第一個元素的下標，就讓第一個元素跟它交換一下值，這樣就找到整個數組中最小的數了。然後找到數組中第二小的數，讓它跟數組中第二個元素交換一下值，以此類推。
⑦ 給出冒泡排序演算法的簡要說明，畫出流程圖，並寫出使用冒泡演算法對三個數3，4，1進行排序的過程。
以升序排序為例
第一步：對整個待排序數列，從頭開始，對相鄰的兩個數進行比較，如果前者>後者，則交換，直至末尾；（這個過程稱之為「一趟」，一趟完成之後，最末尾的數字一定是數列中最大的了。所以下一趟不再考慮最末尾的數字。）
第二步：待排序數列為除了最末尾數字的數列，重復上述步驟；
第三步：待排序數列為除了最末尾兩個數字的數列，重復第一步；
……
第n步：待排序數列為最開頭數字的數列，這時，所有的數都已排好序。
處理結束。
對三個數3，4，1進行排序的過程：
第一趟：對3,4,1排序，比較3,4——3>4?否，不交換；比較4,1，4>1?是，交換。沒有更多需要比較的數，第一趟結束，最大值4已經在末尾，下一趟不再考慮。
第二趟：對3,1排序，比較3,1——3>1?是，交換。沒有更多需要比較的數，第二趟結束，末尾的3，4，都不再考慮。
第三趟：對1排序，只剩一個數，沒什麼可以比較的了。處理結束。
最終排序結果即：1,3,4。
⑧ 排序演算法的設計（c語言）根據程序畫流程圖及對每句程序加註釋
#include "stdio.h"//標准io頭文件
#include "stdlib.h"//庫文件
#include "time.h"//時間系頭文件
#define N0 100000 //定義常量
typedef int keytype; //類型命名
typedef struct node //定義結構體
{ keytype key; //只是類型命名成keytype，其實就是int的
}Etp;//結構體類型叫做Etp
Etp R[N0+1]; // R[1]..R[n] //定義數組
int n=50, count;//全局變數
void readData( Etp R[], int n)//讀數據的函數
{ int i;
count=0;
srand( time( NULL ));//初始化時間種子
for( i=1; i<=n; i++) //對數組初始化
R[i].key=1000+
(int)((9999.0-1000)*rand()/RAND_MAX); // 0..RAND_MAX
}
void printData( Etp R[], int n )//列印顯示數據的函數
{ int i;
for( i=1; i<=n; i++)
printf("%8d%s", //格式化顯示數組的數據
R[i].key, i%5==0?"\n":"");
printf("\ncount=%d\n", count);
}
void bubberSort( Etp R[], int n )//冒泡排序的函數
{ int i,j;//（這個函數塊就是冒泡排序的演算法程序）
bool swap;
for( i=1; i<=n-1; i++)
{ swap=false;
for( j=1; j<=n-i; j++)
if( count++,R[j].key>R[j+1].key )
{ R[0]=R[j];
R[j]=R[j+1];
R[j+1]=R[0];
swap=true;
}
if( !swap ) break;
}
}
void bubberSort1( Etp R[], int n )//這個也是另一個冒泡排序的函數
{ int j;//跟上面不同的是這個演算法用的是遞歸的方式，上面的是非遞歸的
for( j=1; j<=n-1; j++)
if( count++,R[j].key>R[j+1].key )
{ R[0]=R[j];
R[j]=R[j+1];//________;//就是兩個變數交換值
R[j+1]=R[0];
}
if( n>1 ) bubberSort1( R, n-1); //___________;//遞歸調用
}
void selectSort( Etp R[], int n )//這個是選擇排序
{ int i,j,k;//（這個函數塊就是選擇排序的演算法程序）
for( i=1; i<=n-1; i++)
{
k=i;
for( j=i+1; j<=n; j++)
if( count++,R[j].key<R[k].key ) k=j;
if( k!=i )
{ R[0]=R[i];
R[i]=R[k];
R[k]=R[0];
}
}
}
void insertSort( Etp R[], int n )//這個是插入排序
{ int i,j;
for( i=2; i<=n; i++)
{
R[0]=R[i];
j=i-1;
while( count++,R[j].key>R[0].key ) R[j+1]=R[j--];
R[j+1]=R[0];
count++;
}
}
void sift( Etp R[], int i, int m)//堆排序中的步驟
{ int k=2*i;
R[0]=R[i];
while( k<=m )
{ if( count++, k+1<=m && R[k+1].key>R[k].key) k++;
if( count++,R[0].key<R[k].key ) R[i]=R[k];
else break;
i=k;
k=2*i;
}
R[i]=R[0];
}
void heapSort( Etp R[], int n )//這個是堆排序
{ int j;
for( j=n/2; j>=1; j--) sift( R, j, n);
for( j=n; j>=2; j--)
{ R[0]=R[1];
R[1]=R[j];
R[j]=R[0];
sift( R, 1, j-1 );
}
}
int main()//主函數的進入口
{
readData( R, n );//讀取數據
bubberSort1( R, n );//調用遞歸冒泡排序
printData( R, n);//顯示數據
readData( R, n );//讀取數據
selectSort( R, n );//調用選擇排序
printData( R, n);//顯示數據
readData( R, n );//讀取數據
insertSort( R, n );//調用插入排序
printData( R, n);//顯示數據
readData( R, n );//讀取數據
heapSort( R, n );//調用堆排序
printData( R, n);//顯示數據
return 0;
}
//誒·~注釋完我總算看出來了，難道你要我解釋各個排序的過程？
//那你還不如直接或者看書，你要是不理解原理是不可能看懂過程的。
//注釋也只是語句的解釋，但是過程的含義是無法描述的