排序演算法演示程序

① 排序演算法程序（用C51或者匯編均可）

你那個數據是幾位數的啊？一位？兩位？三位？還是N位？
/*算了，就給你寫個一位數的吧，多位數的自己去想辦法*/
sfr led=0x80;//定義P0口為數碼管數據
unsigned char tab[8]={1,2,3,4,5,6,7,8};//存數據
unsigned char tmp[8]={0,0,0,0,0,0,0,0};//作比較用
unsigned char ledcode[16]="0123456789ABCDEF";//數組存入0123456789ABCDEF的段碼數據，這個數組我偷懶了，你自己要改哈O(∩_∩)O！

void main(){
unsigned char i,j,temp;
for(j=0;j<8;j++){ //循環比較8次(數組長度次)
temp=0;
for(i=0;i<8;i++){ //循環判斷8次取最大值(數組長度次)
if(temp<tab[i]){//比較，取大的一個數據
temp=tab[i];
}
if(i==7){
tmp[7-j]=temp;//將最大值存入比較數組
}
}
for(i=0;i<8;i++){ //將最大值從數據數組中刪除
if(temp==tab[i]){
tab[i]=0;
}
}
}
led=ledcode[tmp[7]]; //將最大值輸出到數碼管
}

② 如何製作排序演算法演示程序

首先你要知道怎麼排序......排序的方式是歸並 快排還是冒泡倍增...........然後接下來就都是一些操作上的細節了...............這個界面呃 目測可以用VB做吧......

③ 各種排序演算法演示系統的vb程序 怎麼寫代碼

可以搜索一下這個視頻： 」排序 演算法 舞蹈「

④ java 排序演示系統

呵呵，這個有點意思，要過程啊

1 輸入就不說了
2 排序演算法不說了，就是交換數據而已
3 這個你可以顯示數字的方塊，從左到右，每次交換，則移動方塊的Location到另一個，另一個則反向移動過來。移動的速度你得自己考慮了。不能太快。

⑤ 如何編寫冒泡排序演算法的演示程序

#include<stdio.h>
#define MAX_N 1024 /*存儲大小為1024*/

void bubsort(int a[],int n)/*冒泡排序*/
{
int i,j,tmp;
for(i=0;i<n;i++)
for(j=n-1;j>i;j--)
if(a[j]<a[j-1])/*如果a[j]比前面a[j-1]的小，則交換向上浮*/
{/*交換數組a[j]和a[j-1]*/
tmp=a[j];
a[j]=a[j-1];
a[j-1]=tmp;
}
}

int main(void)
{
int i,input,N;
int arr[MAX_N];/*arr為int線性數組*/

puts("請輸入排序數組的大小N:");
scanf("%d",&N);/*讀入N*/

printf("請輸入要排序的%d個數:\n",N);
for(i=0;i<N;i++)/*輸入*/
scanf("%d",&arr[i]);

bubsort(arr,N);/*排序函數*/

puts("排序之後....");
for(i=0;i<N-1;i++)/*輸出*/
printf("%d ",arr[i]);
printf("%d\n",arr[N-1]);
return 0;
}

⑥ 快速排序演算法的排序演示

假設用戶輸入了如下數組： 下標 0 1 2 3 4 5 數據 6 2 7 3 8 9 創建變數i=0（指向第一個數據）, j=5(指向最後一個數據), k=6(賦值為第一個數據的值)。
我們要把所有比k小的數移動到k的左面，所以我們可以開始尋找比6小的數，從j開始，從右往左找，不斷遞減變數j的值，我們找到第一個下標3的數據比6小，於是把數據3移到下標0的位置，把下標0的數據6移到下標3，完成第一次比較： 下標 0 1 2 34 5 數據 3 2 7 6 8 9 i=0 j=3 k=6
接著，開始第二次比較，這次要變成找比k大的了，而且要從前往後找了。遞加變數i，發現下標2的數據是第一個比k大的，於是用下標2的數據7和j指向的下標3的數據的6做交換，數據狀態變成下表： 下標 0 1 2 3 4 5 數據 3 2 6 7 8 9 i=2 j=3 k=6
稱上面兩次比較為一個循環。
接著，再遞減變數j，不斷重復進行上面的循環比較。
在本例中，我們進行一次循環，就發現i和j「碰頭」了：他們都指向了下標2。於是，第一遍比較結束。得到結果如下，凡是k(=6)左邊的數都比它小，凡是k右邊的數都比它大： 下標 0 1 2 3 4 5 數據 3 2 6 7 8 9 如果i和j沒有碰頭的話，就遞加i找大的，還沒有，就再遞減j找小的，如此反復，不斷循環。注意判斷和尋找是同時進行的。
然後，對k兩邊的數據，再分組分別進行上述的過程，直到不能再分組為止。
注意：第一遍快速排序不會直接得到最終結果，只會把比k大和比k小的數分到k的兩邊。為了得到最後結果，需要再次對下標2兩邊的數組分別執行此步驟，然後再分解數組，直到數組不能再分解為止（只有一個數據），才能得到正確結果。 在c++中可以用函數qsort（）可以直接為數組進行排序。
用 法:
void qsort(void *base, int nelem, int width, int (*fcmp)(const void *,const void *));
參數：1 待排序數組首地址2 數組中待排序元素數量3 各元素的佔用空間大小4 指向函數的指針，用於確定排序的順序

⑦ C#冒泡法排序過程演示程序

基本思想：

在要排序的一組數中，對當前還未排好序的范圍內的全部數，自上而下對相鄰的兩個數依次進行比較和調整，讓較大的數往下沉，較小的往上冒。即：每當兩相鄰的數比較後發現它們的排序與排序要求相反時，就將它們互換。

冒泡排序的示例：

voidBubble_2(intr[],intn){
intlow=0;
inthigh=n-1;//設置變數的初始值
inttmp,j;
while(low<high){
for(j=low;j<high;++j)//正向冒泡,找到最大者
if(r[j]>r[j+1]){
tmp=r[j];r[j]=r[j+1];r[j+1]=tmp;
}
--high;//修改high值,前移一位
for(j=high;j>low;--j)//反向冒泡,找到最小者
if(r[j]<r[j-1]){
tmp=r[j];r[j]=r[j-1];r[j-1]=tmp;
}
++low;//修改low值,後移一位
}
}

⑧ 用VB編制一個動態的演示排序操作的實用程序

現在VB的話一般用ADO連接數據的比較多，可以用控制項ADODC直接生成連接數據的語句，最好把最後連接的機器的名稱改成IP。
1.在資料庫中建立HM和HM2兩個表，注意你建立數據表的時候各列名稱設定好。
2.VB中觸發時間是List1的CLICK時間，然後檢測是否收到ASC碼13（即回車符）檢測到後往下執行
3.對輸入的字元串做檢測，可以先檢測長度是否7位或11位，然後對各個位是否為數字做檢測（可以循環去ASC的辦法），是則往下執行，否則List1清零。
4.VB連接資料庫，去其中號碼與List1對用的那條記錄，然後去各個列的內容分別填入list2、list3、list4、list5就OK了。

總體而言的話這個程序應該不難，不過我沒用VB連接ACESS所以不能給你全部的代碼，其他的我有部分類似的程序，你要的話發消息給我吧。

⑨ 用Javascript寫排序演算法的動畫演示

1.讓JavaScript暫停下來，慢下來。
JavaScript排序是很快的，要我們肉眼能看到它的實現過程，我首先想到的是讓排序慢下來。 排序的每一個循環都讓它停300ms然後再繼續進行。 怎麼樣才能停下來呢。查了一下JavaScript貌似沒有sleep()這樣的函數。暫停做不到，但是可以想辦法讓實現跟暫停差不多的效果。比如在循環里做一些無關的事情 。
首先嘗試了讓while(true)來一直執行一個空操作。執行一段時間再回到排序邏輯。代碼大致是這樣：
for (var i = 0; i < 3; i++) {
document.writeln(i); //DOM操作
var now = new Date().getTime();
while(new Date().getTime() - now < 3000){}
}

慢是慢下來了。不過太耗資源，排序進行過程中dom並不會有任何改變，直到排序結束， DOM會變成排序好之後的樣子。 但是如果設置斷點一步步執行的時候 又可以看到一步步的排序變化。估計是因為這個操作太耗資源導致瀏覽器下達了一個DOM操作的命令但是一直騰不出資源來進行DOM操作。所以真正DOM操作的時候在js代碼執行結束之後。
所以讓JavaScript排序慢來來還是沒有實現。
另一種讓JavaScript暫停下來的思路：
寫這個文章的時候又想到一種方法來讓JavaScript停下來。 那就是AJAX的同步請求，以及超時操作。 也就是在要停下來的地方放一個AJAX請求，同步請求， 然後設置超時。超時的時間就是我們要暫停的時間。為了避免在到達超時請求之前服務 器就返回了我們的AJAX請求。可以在服務端運行類似 sleep()的程序 。從而保證AJAX不會返回。直接超時然後返回到我們的循環。不過這只是個設想。有興趣的可以去嘗試一下。
2.閉包和定時器。 這種思路不需要讓排序過程慢下來。而是使用閉包緩存排序過程中數組的變化。然後使用setTimeout來確定展示每一個數組狀態的順序。在排序循環中放入類似下面的代碼。
(function(){
var theArr = arr.slice();//當前數組狀態的備份
setTimeout(function(){
bubbleSortDom(theArr);//排序的DOM操作。
},500*timeCount);
timeCount++;//定時器的順序。
})();

不過後來發現這樣子寫的話代碼量會比較大，邏輯有修改的話要修改的地方會有點多。局限性很多，比如要實現排序動畫加快或減慢操作幾乎是很困難的。所以還要另想辦法。
3.緩存排序中的數組狀態。
也就是在排序過程中。將數組的每一輪循環的狀態保存到一個數組。然後再用這個數組依次將排序狀態保存下來。 只需要在排序中加入一句就行。
this.pushHis(arr.slice(),i-1,j,k,temp);

這樣就只需要一個setInterval()就可以了。並且可以很方便的實現動畫的加快與減慢。邏輯也比較好理解 。
問題二：如何實現JavaScript排序動畫的加快與減慢。
我們問題一使用的第三種方法。 得到一個保存了每一步排序狀態的數組arr。 然後我們可以使用一個setInterval()定時器一步步展現排序狀態。 如果要加快速度或減慢速度。就clearInterval()，修改定時器的執行間隔，重新setInterval()，從前一個定時器執行到數組中的位置開始執行。
問題三：對於使用遞歸實現的數組怎麼辦？ 不是在原數組上進行操作的怎麼辦？
使用遞歸實現的排序。 可能並沒有在一個數組上進行操作，只是最後返回一個排序好的數組出來。那麼我們要如何獲得排序中的數組的完整狀態呢。
比如快速排序。
最開始不考慮動畫，我的實現是這樣的：
function quickSort(arr){
var len = arr.length,leftArr=[],rightArr=[],tag;
if(len<2){
return arr;
}
tag = arr[0];
for(i=1;i<len;i++){
if(arr[i]<=tag){
leftArr.push(arr[i])
}else{
rightArr.push(arr[i]);
}
}
return quickSort(leftArr).concat(tag,quickSort(rightArr));
}

然後為了考慮動畫，我改寫了它的邏輯，讓它在同一個數組上進行了實現。 其實是在遞歸的時候傳入了當前的的子數組在原數組中的起始位置。從而在原數組上進行了操作。
用了兩種方法來實現方式。在排序邏輯上略有不同。
第一種是先跟遠處的對比。遇到比自己小的放到自己前面去。循環序號+1。比自己大的放到當前排序子數組的最後面去，循環序號不變。直到排列完成。
這種方法的缺點是即使是一個有序數組。它也會重新排。
第二種方法是 除了標記位，再設置一個對比位。 遇到比自己小的，放到前面去，標記位的位置+1，標記位與對比位之間所有的往後面移動一個位置。
遇到比自己大的。標記位不變，對比位+1。
這種方法的缺點是對數組進行的操作太多。優點是對有序數組不會再排。
方式一：
function quickSort(arr,a,b,qArr){

var len = arr.length,leftArr=[],rightArr=[],tag,i,k,len_l,len_r,lb,ra,temp;
if(a == undefined && b == undefined){
a = 0; b= arr.length-1;//初始化起始位置。
}
if(qArr == undefined){
qArr = arr.slice();
}

if((len == 2 && arr[0] == arr[1])||len<2){
return arr;
}

tag = qArr[a];
for (i = 1; i < len;) {
if(qArr[a+i]<=tag){
leftArr.push(qArr[a+i]);
qArr[a+i-1] = qArr[a+i];
qArr[a+i] = tag;
k = a+i;
i++;
}else{
if(leftArr.length+rightArr.length == len-1){
break;
}
temp = qArr[a+i];
qArr[a+i] = qArr[b-rightArr.length];
qArr[b-rightArr.length] = temp;
rightArr.push(temp);
k = a+i-1;
}
this.pushHis(qArr.slice(),a,b,k);
}

len_l = leftArr.length;
len_r = rightArr.length;
if(len_l== 0){
lb = a;
}else{
lb = a+len_l -1;
this.sort(leftArr,a,lb,qArr);
}

if(len_r == 0){
ra = b;
}else{
ra = b + 1 - len_r;
this.sort(rightArr,ra,b,qArr)
}
return qArr
}

方式二：
function quickSort2(arr,a,b,qArr){
var len = arr.length,leftArr=[],rightArr=[],tag,i,j,k,temp,len_l,len_r,lb,ra;
if(a == undefined && b == undefined){
a = 0; b= arr.length-1;//初始化起始位置。
}
if(qArr == undefined){
qArr = arr.slice();
}
if(len<2){
return arr;
}
if(len == 2 && arr[0] == arr[1]){
return arr;
}
tag = qArr[a];
for (i = 1,k = 0; i < len;) {
if(qArr[a+i]>=tag){
rightArr.push(qArr[a+i]);
i++;
}else{
temp = qArr[a+i];
for(j = a+i;j>a+k;j--){
qArr[j] = qArr[j-1];
// this.pushHis(qArr.slice(),a,b,a+k);
}
qArr[a+k] = temp;
leftArr.push(temp);
k++;
i++;
}
this.pushHis(qArr.slice(),a,b,a+k,i-1);
}
len_l = leftArr.length;
len_r = rightArr.length;
if(len_l== 0){
lb = a;
}else{
lb = a+len_l -1;
this.sort(leftArr,a,lb,qArr);
}
if(len_r == 0){
ra = b;
}else{
ra = b + 1 - len_r;
this.sort(rightArr,ra,b,qArr)
}
return qArr;
}

具體的不同下面會有動畫演示。
問題四：動畫的流暢。
排序動畫的DOM操作是很多的很快的。這里我做的優化只是讓每一個排序步驟只涉及一個DOM操作。 全部由JavaScript拼接好，一次替換。類似下面的代碼。
效果圖：

主要實現了：
冒泡排序JavaScript動畫演示
插入排序JavaScript動畫演示
選擇排序JavaScript動畫演示
快速排序JavaScript動畫演示
歸並排序JavaScript動畫演示
希爾排序JavaScript動畫演示

⑩ 各種內部排序演算法演示用C語言實現 排序過程中用動態的顯示

#include<stdio.h>
#defineMAX1000

intquick(int*a,intl,intr,intlength)
{
intcounter=0,i;
a[0]=a[l];
while(l<r)
{
while(l<r&&a[0]<=a[r])
r--;
a[l]=a[r];
while(l<r&&a[0]>a[l])
l++;
a[r]=a[l];
}
a[l]=a[0];
printf("Step%d:",++counter);
for(i=1;i<length;i++)
printf("%d",a[i]);
printf("%d
",a[length]);
returnl;
}

voidquicksort(int*a,intl,intr,intlength)//快速排序
{
intp;
if(l<r)
{
p=quick(a,l,r,length);
quicksort(a,l,p-1,length);
quicksort(a,p+1,r,length);
}
}

voidheap(int*a,intlength,inti)
{
ints=i,t;
if(2*i<=length&&a[2*i]>a[s])
s=2*i;
if(2*i+1<=length&&a[2*i+1]>a[s])
s=2*i+1;
if(s!=i)
{
t=a[i];
a[i]=a[s];
a[s]=t;
heap(a,length,s);
}
}

voidheapsort(int*a,intlength)//堆排序
{
inti,t,counter=0,k=length;
for(i=length/2;i>=1;i--)
heap(a,length,i);
while(length>1)
{
t=a[1];
a[1]=a[length];
a[length]=t;
heap(a,--length,1);
printf("Step%d:",++counter);
for(i=1;i<k;i++)
printf("%d",a[i]);
printf("%d
",a[k]);
}
}

voidinsertsort(int*a,intlength)//插入排序
{
inti,j,t,k,counter=0;
if(length==1)
{
printf("Step%d:%d
",++counter,a[1]);
return;
}
for(i=2;i<=length;i++)
{
t=a[i];
for(j=i-1;j>0&&a[j]>=t;j--);
for(k=i-1;k>=j+1;k--)
a[k+1]=a[k];
a[k+1]=t;
printf("Step%d:",++counter);
for(k=1;k<length;k++)
printf("%d",a[k]);
printf("%d
",a[length]);
}
}

intmain()
{
intn,i;
inta[MAX];
while(scanf("%d",&n)&&n)
{
for(i=1;i<=n;i++)
scanf("%d",&a[i]);
quicksort(a,1,n,n);
}
return0;
}