排序設計

Ⅰ 設計一函數，實現4個數的從小到大排列。

#include<stdio.h>
void SortMum(float &a1,float &a2,float &a3,float &a4);
int main()
{
float a1,a2,a3,a4;
int i;
printf("請輸入四個浮點數[以空格區分]：\n");
scanf("%f %f %f %f",&a1,&a2,&a3,&a4);
fflush(stdin);
//printf("%.2f %.2f %.2f %.2f",a1,a2,a3,a4);
SortMum(a1,a2,a3,a4);
printf("四個數的排序如下：\n");
printf("%.2f %.2f %.2f %.2f",a1,a2,a3,a4);
return 0;
}
void SortMum(float &a1,float &a2,float &a3,float &a4)
{
float m;
//得出a1
if(a1>a2) {m=a1;a1=a2;a2=m;}
if(a1>a3) {m=a1;a1=a3;a3=m;}
if(a1>a4) {m=a1;a1=a4;a4=m;}
//得出a2
if(a2>a3) {m=a2;a2=a3;a3=m;}
if(a2>a4) {m=a2;a2=a4;a4=m;}
//得出a3
if(a3>a4) {m=a3;a3=a4;a4=m;}
}
=================================================================
代碼我替他給了吧！把那個函數形參的&去掉（即不用引用的方法傳遞參數），主函數中輸出的還是沒排序之前的數！

Ⅱ C++設計並實現一個排序類.

// 插入來排序
void InsertSort(int array[], int length)
{
int i, j, key;
for (i=1;i<length;i++)
{
key=array[i];
//把自i之前大於array[i]的數據向後移動
for (j=i-1;j>=0 && array[j]>key;j--)
{
array[j+1]=array[j];
}
//在合適位置安放當前元素
array[j+1]=key;
}
}

Ⅲ C++:設計排序典型演算法（冒泡與快速排序）

#include <iostream>
#include <vector>
#include <ctime>

using namespace std;

vector<int> quick_sort( vector<int> a )
{
if ( a.size() == 0 || a.size() == 1 )
{
a;
}

int k = a[ 0 ];
vector<int> pre, suc;
for ( int i = 1; i < a.size(); ++i )
{
if ( a[ i ] <= k )
{
pre.push_back( a[ i ] );
}
else
{
suc.push_back( a[ i ] );
}
}

pre = quick_sort( pre );
suc = quick_sort( suc );

a = pre;
a.push_back( k );
for ( i = 0; i < suc.size(); ++i )
{
a.push_back( suc[ i ] );
}

return a;
}

void main()
{
srand( time( 0 ) );
vector<int> a;

for ( int i = 0; i < 10; ++i )
{
a.push_back( rand() % 100 + 1 );
}

for ( i = 0; i < 10; ++i )
{
cout << a[ i ] << " ";
}
cout << endl;

a = quick_sort( a );

for ( i = 0; i < 10; ++i )
{
cout << a[ i ] << " ";
}
cout << endl;

return;
}

Ⅳ utterances可以設計評論排序功能嗎

你要問什麼問題呢？。規律是1個1，2個2，3個3，4個4，5個5，6個6，

Ⅳ Java類的設計，排序函數的設計

總歸是要存這個 課程名 - 成績 數據結構的，這里我用Map。

classCourse{
	finalpublicstaticStringYUWEN="YuWen";
	finalpublicstaticStringSHUXUE="ShuXue";
	finalpublicstaticStringYINGYU="YingYu";
}

classStudent{
publicintid;//學號
publicStringname;//姓名
publicMap<String,Integer>courseScore;//課程名-成績
publicaddScore(Stringcourse,intscore){
	this.courseScore.put(course,score);
}
//...
}

publicclassTest{

	publicstaticvoidsortStudent(List<Student>ss,StringsortKey){
		Collections.sort(ss,newComparator(){
			@Override
			publicintcompare(Studentarg0,Studentarg1){
				ints0=arg0.courseScore.get(sortKey);
				ints1=arg1.courseScore.get(sortKey);
				returns0-s1;
			}
		});
	}

	publicstaticvoidmain(String[]args){
		List<Student>ss=newArrayList<Student>();
		Studentx=newStudent();
		Student.addScore(Course.YUWEN,100);
		Student.addScore(Course.SHUXUE,100);
		Student.addScore(Course.YINGYU,100);
		//...
		try{
			sortStudent(ss,Course.YUWEN);
		}catch{//nullPointerException
			;
		}
	}

}

大致是這樣。為了防止亂取課程名，在使用的時候必須用Course類里的常量。其實改成Enum更恰當一些。

另外還有些介面函數我省略沒寫，偷懶把很多數據都public了。

Ⅵ 如何設計幼兒排序教案

一、活動目標
1.學習觀察並發現遞增遞減排序規律，會接著往下排。
2.用自己的的方式大膽表達操作的結果。
3.感受規則排序在生活中的運用及其產生的美感。
二、活動准備
課件、幼兒操作材料等。
三、活動過程
1.情景引入，尋找排列規律。
師：小朋友，我是中都中心幼兒園的老師，我的幼兒園可漂亮了。我們一起來看看，但看完後老師要請說說你看到了什麼？
(1)出示課件1，引導幼兒觀察"幼兒園"的排列裝飾。
師：小朋友，剛才你們都看了我的幼兒園，怎麼樣，好看嗎？現在我想問問你看到了什麼？(幼兒回答)它好看在哪？是怎麼設計的？
(2)出示門、圍牆圖片，觀察比較發現等差關系，引發幼兒思考如何排列。
師：這是新幼兒的圍牆、(大門)，請小朋友仔細觀察它們的設計的，你發現了什麼秘密？我們想一想該如何來設計？
(3)小結。剛才小朋友都看了我幼兒園的大門是兩種顏色，左扇門是一種顏色的數量不變，另一種顏色的數量越來越多；而右扇門是一種顏色的數量不變，另一種顏色的數量越來越少。還有圍牆也和右扇門一樣，一種顏色的數量不變，另一種顏色的數量越來越少。小朋友真棒，發現了新的排列規律。
2.幼兒操作，學習遞增遞減的規律排序規律。
(1)引導幼兒觀察操作卡上設計材料，找出規律，並繼續進行排列。
師：今天老師帶來了許多設計材料，我幼兒園的設計師因有事沒設計完，現在我請小朋友幫忙把這些沒有設計院完的接著往下設計。但小朋友先看看設計師是按什麼規律設計的，然後我們一起來接著往下設計。
(2)幼兒分組操作，並將操作卡分成兩類(遞增和遞減)，展示在展板上。
(3)觀察評價，總結規律。
①師幼共同觀察評價大家設計的排列正誤。
②教師小結規律：
師：剛才小朋友們都設計得很美！比如(門簾等)是按照一種顏色的數量固定不變，另一種顏色後面一次的數量比前面一次的數量增加1，這種設計的排序規律，我們叫它遞增規律。還有(汽球等)是按照一種顏色的數量固定不變，另一種顏色後面一次的數量比前面一次的數量減少1，這種設計的排序規律，我們叫它遞減規律。
3.幼兒分組操作"裝扮幼兒園"，鞏固知識。
師：我剛才看到你們幼兒園也新建一座新樓房，可是我發現新樓房四周還空盪盪的，沒有種樹、沒有圍牆等等，要不我們也一起來裝扮它。
(1)介紹各組材料。
※設計圍牆：用兩種形狀的圖形，按照不同規律在操作卡上"掛設計圍牆"。
※掛彩旗：用兩種顏色的圖形，按照不同規律在操作卡上"掛彩旗"。
※種樹：用兩種不同的種類，按照不同規律在操作卡上"種花圃"。
※鋪地磚：用兩種顏色的卡紙，按照不同規律在操作卡上"鋪地磚"。
※設計大門：用兩種顏色的汽球，按照不同規律在操作卡上"設計大門"。
(2)幼兒操作，教師巡迴指導，重點觀察幼兒是否按照遞增遞減的規律來排列。
(3)幼兒分享交流：你做了什麼，是按照哪種規律進行排列的？
4.知識拓展：感受規律排序在生活中的作用。
師播放生活中一些常見按一定規律排序的東西，讓幼兒感受數學與生活的聯系，感受規律排序在生活中的作用。

Ⅶ 排序系統的設計，

你好，是要求用什麼語言與資料庫的，詳說吧與我

Ⅷ 排序演算法的實現與比較的課程設計

;
#include<stdio.h>
#define NUM 7 //宏定義
int i; //變數類型定義
typedef struct Node{
int data ; //數據域
struct Node *next; //指針域
}Node,*LNode; //用結構體構造結點及相應的指針

typedef struct Tree{
int data ;
struct Tree *left ;
struct Tree *right ;
}Tree,*LTree ; //用結構體構造樹及相應的指針

CreateList( LNode Head ) //創建單鏈表
{
for(int i=1 ; i <=NUM ; i++) //創建循環，依次輸入NUM個數據
{
LNode temp ; //中間結點
temp = (LNode) malloc( sizeof( Node ) ); //動態存儲分配

temp-> next = NULL; //中間結點初始化
scanf("%2d",&temp-> data); //輸入賦值到結點temp數據域
temp-> next = Head-> next ;
Head-> next = temp ; //將temp結點插入鏈表

}
return 1 ;//返回1
}

InsertSqTree( LTree &root , LNode temp ) //二叉樹排序原則的設定
{
if(!root) //root為NULL時執行
{
root = (LTree)malloc(sizeof(Tree)); //動態存儲分配

root-> left =NULL;
root-> right=NULL; //初始化
root-> data = temp-> data ; //賦值插入
return 1 ; //函數正常執行，返回1
}
else
{
if(root-> data>= temp-> data)
return InsertSqTree( root-> left , temp ) ; //比較插入左子樹
else if(root-> data <temp-> data)
return InsertSqTree( root-> right , temp ); //比較插入右子樹
}
return 1 ; //如果滿足，就不做處理，返回1
}

void BianLiTree(LTree root) //採用中序遍歷，實現將所有數字按從左向右遞增的順序排序
{
if(root) //root不為空執行
{BianLiTree(root-> left); //左遞歸處理至葉子結點，當root-> left為NULL時不執行
printf("%4d ",root-> data); //輸出
BianLiTree(root-> right); //處理右結點
}
}

int main()
{
LNode Head = NULL;
LTree root = NULL ; //初始化
Head = (LNode) malloc(sizeof(Node)); //動態存儲分配

Head-> next = NULL ; //初始化
printf("please input numbers:\n");//輸入提示語句
if(!CreateList( Head )) //建單鏈表成功返回1不執行下一語句
return 0; //結束函數，返回0
LNode temp = Head-> next ; //將頭指針的指針域賦值予中間結點
while( temp ) //temp為NULL時停止執行
{
if(!InsertSqTree( root ,temp )) //排序正常執行，返回1不執行下一語句
return 0 ; //結束函數，返回0
Head-> next = temp-> next ; //將中間指針的指針域賦值予頭結點指針域
free(temp); //釋放空間
temp = Head-> next ; //將頭指針的指針域賦值予中間結點，以上三句實現了temp指針後移
}
printf("the result is:\n");//輸出提示語句
BianLiTree(root); //採用中序遍歷，輸出並觀察樹結點
return 1; //函數正常結，返回1
}

Ⅸ 任何簡單排序方法都可以設計成穩定的排序方法

由於各種不同的排序方法具體所具有的特點，並不是任何簡單排序方法都可以設計成穩定的排序方法的。在常見的各種排序方法中穩定的排序方法有：冒泡排序。插入排序。歸並排序等等。

Ⅹ 排序演算法課程設計

// 各種排序演算法匯總.cpp : 定義控制台應用程序的入口點。
//
#include "stdafx.h"
#include <iostream>
#include <string>
using namespace std;

#include <stack>
#include <time.h>
#include <stdlib.h>

template < typename T >
class SqList
{
private:
int length;
T * r;
public://介面
SqList(int n = 0);//構造長度為n的數組
~SqList()
{
length = 0;
delete r;
r = NULL;
}
void InsertSort();//順序插入排序
void DisPlay();//輸出元素
void BInsertSort();//折半插入排序
void ShellSort(int dlta[],int t);//希爾排序
void QuickSort();//快速排序
void SelectSort();//簡單選擇排序
void BubbleSort();//改進冒泡排序
void Bubble_Sort2();//相鄰兩趟是反方向起泡的冒泡排序演算法
void Bubble_Sort3();//對相鄰兩趟反方向演算法進行化簡,循環體中只包含一次冒泡
void HeapSort();//堆排序
void Build_Heap_Sort();//堆排序由小到大序號建立大根堆
void MergeSort();//歸並排序
void OE_Sort();//奇偶交換排序的演算法

void Q_Sort_NotRecurre();//非遞歸快速排序
void HeapSort_3();//三叉堆排序

public://調用
void ShellInsert(int dk);//一趟希爾排序
void QSort(int low,int high);//快速排序
int Partition(int low,int high);//一趟快速排序
int SelectMinKey(int i);//從i到length中選擇最小值下標
void HeapAdjust(int s,int m);//調整s的位置,其中s+1~m有序
void HeapAdjust_3(int s,int m);//三叉堆****調整s的位置,其中s+1~m有序
void Merge(T SR[],T TR[],int i,int m,int n);//歸並
void MSort(T SR[],T TR1[],int s,int t);//歸並
void Easy_Sort(int low,int high);//3個數直接排序
void Build_Heap(int len);//從低下標到高下標逐個插入建堆的演算法***建立大根堆**但為排序

};
template < typename T >
SqList<T>::SqList(int n = 0)
{
//srand( time(0) );
length = n;
r=new T[length+1];
T t;
cout<<"隨機生成"<<n<<"個值:"<<endl;
for (int i=1;i<=length;i++)
{
//cin>>t;
r[i] = rand()%1000;
//r[i] = t;
}
for (int i=1; i<=length;i++)
cout<<r[i]<<",";
cout<<endl;
}
template < typename T >
void SqList<T>::InsertSort()
{
int i,j;
for (i=2;i<=length;i++)
{
if (r[i]<r[i-1])
{
r[0]=r[i];
r[i]=r[i-1];
for (j=i-2;r[0]<r[i-2];j--)
r[j+1]=r[j];
r[j+1]=r[0];
}
}
}
template < typename T >
void SqList<T>::DisPlay()
{
int i;
cout<<length<<" 元素為："<<endl;
for (i = 1;i < length+1;i++ )
{
cout<<r[i]<<" ,";
}
cout<<endl;
}
template < typename T >
void SqList<T>::BInsertSort()
{
int i, j, m;
int low,high;
for (i = 2;i<= length;i++)
{
r[0]=r[i];
low=1;
high=i-1;
while (low<=high)
{
m = (low+high)/2;
if ( r[0] < r[m] )
high=m-1;
else
low=m+1;
}
for ( j=i-1;j >=high+1; j--)
{
r[j+1] = r[j];
}
r[high+1] = r[0];
}
}

template < typename T >
void SqList<T>::ShellInsert(int dk)
{
int i,j;
for (i=dk+1;i<=length;i++)
if (r[i] < r[i-dk])
{
r[0] = r[i];
for ( j=i-dk; j>0 && r[0] < r[j]; j-=dk)
{
r[j+dk]=r[j];
}
r[j+dk] = r[0];
}
}
template < typename T >
void SqList<T>::ShellSort(int dlta[],int t)
{
int k=0;
for (;k<t;k++)
{
ShellInsert(dlta[k]);
}
}
template < typename T >
int SqList<T>::Partition(int low,int high)
{
int pivotkey;
r[0] = r[low];//記錄樞軸值
pivotkey = r[low];
while (low < high)
{
while (low < high&& r[high] >= pivotkey)
high--;
r[low] = r[high];
while (low < high&& r[low] <= pivotkey)
low++;
r[high] = r[low];
}
r[low] = r[0];//樞軸記錄到位
return low;//返回樞軸位置
}
template < typename T >
void SqList<T>::QSort(int low,int high)
{
int pivotloc;
if (low < high)
{
pivotloc = Partition(low,high);
QSort(low,pivotloc-1);
QSort(pivotloc+1,high);
}
}
template < typename T >
void SqList<T>::QuickSort()
{
QSort(1,length);
}
template < typename T >
int SqList<T>::SelectMinKey(int i)
{
int j,min=i;
for (j=i;j <= length;j++)
{
if (r[min] > r[j])
{
min = j;
}
}
return min;
}
template < typename T >
void SqList<T>::SelectSort()
{
int i,j;
T t;
for (i=1;i < length;i++)//循環length-1次不是length次
{
j=SelectMinKey(i);
if (i != j)
{
t= r[j];
r[j]=r[i];
r[i]=t;
}
}
}
template < typename T >
void SqList<T>::BubbleSort()
{
int i,j;
int flag=1;//標識位，如果出現0，則沒有交換，立即停止
T t;
for (i=1;i < length && flag;i++)
{
flag = 0;
for (j=length-1;j>=i;j--)
if (r[j]>r[j+1])
{
t=r[j];
r[j]=r[j+1];
r[j+1]=t;
flag=1;
}
}
}
template < typename T >
void SqList<T>::Bubble_Sort2()
{
bool change = true;
int low = 1, high = length;
int i;
T t;
while ( (low < high) && change )
{
change = false;
for ( i = low; i < high; i++ )
{
if ( r[i] > r[i+1] )
{
t = r[i];
r[i] = r[i+1];
r[i+1] = t;
change = true;
}
}
high-=1;
for ( i = high; i > low; i-- )
{
if ( r[i] < r[i-1] )
{
t = r[i];
r[i] = r[i-1];
r[i-1] = t;
change = true;
}
}
low+=1;
}
}

template < typename T >
void SqList<T>::Bubble_Sort3()
{
int i,d=1;
bool change = true;
int b[3] = {1,0,length};//b[0]為冒泡的下界,b[ 2 ]為上界,b[1]無用
T t;
while (change)//如果一趟無交換，則停止
{
change = false;
for ( i=b[1-d]; i!=b[1+d]; i=i+d )//統一的冒泡演算法
{
if ( (r[i]-r[i+d])*d > 0 )///注意這個交換條件
{
t = r[i];
r[i] = r[i+d];
r[i+d] = t;
change = true;
}
}
d = d*(-1);//換個方向
}
}
template < typename T >
void SqList<T>::HeapAdjust(int s,int m)
{
/* 已知H.r[s..m]中記錄的關鍵字除H.r[s].key之外均滿足堆的定義，本函數 */
/* 調整H.r[s]的關鍵字,使H.r[s..m]成為一個大頂堆(對其中記錄的關鍵字而言) */
int j;
T rc = r[s];
for (j=2*s;j <= m;j*=2)
{
/* 沿key較大的孩子結點向下篩選 */
if (j < m && r[j] < r[j+1])
j++;/* j為key較大的記錄的下標 */
if (rc >= r[j])
break;/* rc應插入在位置s上 ,無需移動*/
r[s]=r[j];
s=j;
}
r[s]=rc;/* 插入 */
}
template < typename T >
void SqList<T>::HeapSort()
{
/* 對順序表H進行堆排序。演算法10.11 */
T t;
int i;
for (i=length/2;i>0;i--)/* 把H.r[1..H.length]建成大頂堆 */
HeapAdjust(i,length);
for (i=length;i>1;i--)
{
/* 將堆頂記錄和當前未經排序子序列H.r[1..i]中最後一個記錄相互交換 */
t=r[1];
r[1]=r[i];
r[i]=t;
HeapAdjust(1,i-1);/* 將H.r[1..i-1]重新調整為大頂堆 */
}
}
template < typename T >
void SqList<T>::Build_Heap_Sort()
{
int i;
Build_Heap(length);
for ( i = length; i > 1; i-- )
{
T t;
t = r[i];
r[i] = r[1];
r[1] = t;
Build_Heap(i-1);
}

}
template < typename T >
void SqList<T>::Build_Heap(int len)
{
T t;
for (int i=2; i <= len; i++ )
{
int j = i;
while ( j != 1 )
{
int k = j/2;
if ( r[j] > r[k] )
{
t = r[j];
r[j] = r[k];
r[k] = t;
}
j = k;
}
}

}
template < typename T >
void SqList<T>::Merge(T SR[],T TR[],int i,int m,int n)
{
/* 將有序的SR[i..m]和SR[m+1..n]歸並為有序的TR[i..n] 演算法10.12 */
int j,k,x;
for (j=m+1,k=i;j<=n&&i<=m;k++)/* 將SR中記錄由小到大地並入TR */
{
if (SR[i]<SR[j])
TR[k]=SR[i++];
else
TR[k]=SR[j++];
}
if (i<=m)
for (x=0;x<=m-i;x++)
TR[k+x]=SR[i+x];/* 將剩餘的SR[i..m]復制到TR */
if (j<=n)
for (x=0;x<=n-j;x++)
TR[k+x]=SR[j+x];/* 將剩餘的SR[j..n]復制到TR */
}
template < typename T >
void SqList<T>::MSort(T SR[],T TR1[],int s,int t)
{
/* 將SR[s..t]歸並排序為TR1[s..t]。演算法10.13 */
int m;
T *TR2=new T[length+1];
if (s==t)
TR1[s]=SR[s];
else
{
m=(s+t)/2;/* 將SR[s..t]平分為SR[s..m]和SR[m+1..t] */
MSort(SR,TR2,s,m);/* 遞歸地將SR[s..m]歸並為有序的TR2[s..m] */
MSort(SR,TR2,m+1,t);/* 遞歸地將SR[m+1..t]歸並為有序的TR2[m+1..t] */
Merge(TR2,TR1,s,m,t);/* 將TR2[s..m]和TR2[m+1..t]歸並到TR1[s..t] */
}
}
template < typename T >
void SqList<T>::MergeSort()
{
MSort(r,r,1,length);
}
template < typename T >
void SqList<T>::OE_Sort()
{
int i;
T t;
bool change = true;
while ( change )
{
change = false;
for ( i=1;i<length;i+=2 )
{
if (r[i] > r[i+1])
{
t = r[i];
r[i] = r[i+1];
r[i+1] = t;
change = true;
}
}
for ( i=2;i<length;i+=2 )
{
if ( r[i] > r[i+1] )
{
t = r[i];
r[i] = r[i+1];
r[i+1] = t;
change = true;
}
}

}

}
typedef struct
{
int low;
int high;
}boundary;
template <typename T >
void SqList<T>::Q_Sort_NotRecurre()
{
int low=1,high=length;
int piv;
boundary bo1,bo2;
stack<boundary> st;
while (low < high)
{
piv = Partition(low,high);
if ( (piv-low < high-piv) && (high-piv > 2) )
{
bo1.low = piv+1;
bo1.high = high;
st.push(bo1);
high = piv-1;
}
else if ( (piv-low > high-piv) && (piv-low >2) )
{
bo1.low = low;
bo1.high = piv-1;
st.push(bo1);
low = piv+1;
}
else
{
Easy_Sort(low,high);
high = low;
}
}
while ( !st.empty() )
{
bo2 = st.top();
st.pop();
low = bo2.low;
high = bo2.high;
piv = Partition(low, high);
if ( (piv-low < high-piv) && (high-piv > 2) )
{
bo1.low = piv+1;
bo1.high = high;
st.push(bo1);
high = piv-1;
}
else if ( (piv-low > high-piv) && (piv-low >2) )
{
bo1.low = low;
bo1.high = piv-1;
st.push(bo1);
low = piv+1;
}
else
{
Easy_Sort(low,high);
}
}

}
template < typename T >
void SqList<T>::Easy_Sort(int low,int high)
{
T t;
if ( (high-low) == 1 )
{
if ( r[low] > r[high] )
{
t = r[low];
r[low] = r[high];
r[high] = t;
}
}
else
{
if ( r[low] > r[low+1] )
{
t = r[low];
r[low] = r[low+1];
r[low+1] = t;
}
if ( r[low+1] > r[high] )
{
t = r[low+1];
r[low+1] = r[high];
r[high] = t;
}
if ( r[low] > r[low+1] )
{
t = r[low];
r[low] = r[low+1];
r[low+1] = t;
}
}

}

template < typename T >
void SqList<T>::HeapAdjust_3(int s,int m)
{
T rc = r[s];
for (int j = 3*s-1; j <= m;j=j*3-1)
{
if (j+1<m)//有3個孩子結點
{
if ( rc>=r[j] && rc>=r[j+1] && rc>=r[j+2] )
break;
else
{
if ( r[j] > r[j+1] )
{
if ( r[j] > r[j+2] )
{
r[s]=r[j];
s=j;
}
else//r[j]<=r[j+2]
{
r[s]=r[j+2];
s=j+2;
}
}
else//r[j]<=r[j+1]
{
if ( r[j+1] > r[j+2] )
{
r[s]=r[j+1];
s=j+1;
}
else//r[j+1]<=r[j+2]
{
r[s]=r[j+2];
s=j+2;
}
}
}
}
if ( j+1==m )//有2個孩子結點
{
if ( rc>=r[j] && rc>=r[j+1] )
break;
else
{
if ( r[j] > r[j+1] )
{
r[s]=r[j];
s=j;
}
else//r[j]<=r[j+1]
{
r[s]=r[j+1];
s=j+1;
}
}
}
if (j==m)//有1個孩子結點
{
if ( rc>=r[j] )
break;
else
{
r[s]=r[j];
s=j;
}
}
}
r[s]=rc;
}

template <typename T >
void SqList<T>::HeapSort_3()
{
int i;
T t;
for (i=length/3; i>0; i--)
HeapAdjust_3(i,length);
for ( i=length; i > 1; i-- )
{
t = r[i];
r[i] = r[1];
r[1] = t;
HeapAdjust_3(1,i-1);
}
}

int _tmain(int argc, _TCHAR* argv[])
{
SqList<int> Sq(15);
//Sq.InsertSort();
//Sq.BInsertSort();
/* 希爾排序*/
// int a[5]={5,4,3,2,1};
// Sq.ShellSort(a,5);

/* Sq.QuickSort();*/

// Sq.SelectSort();

/* Sq.BubbleSort();*/

/* Sq.HeapSort();*/

/* Sq.MergeSort();*/

/* Sq.Q_Sort_NotRecurre();*/

/* Sq.Bubble_Sort2();*/
/* Sq.OE_Sort();*/
/* Sq.Bubble_Sort3();*/

/* Sq.Build_Heap_Sort();*/

Sq.HeapSort_3();

Sq.DisPlay();
system("pause");
return 1;
}