java程序！

　　二叉堆的删除：每次进行一次堆调整之后，根节点必是最大的(最大堆)，每次把根节点a[0]取出和数组第n个数互换，然后再用数组第1个到第n-1个数再次建堆，如此反复取出再建堆，那么得到的新序列必是一个有序序列。

　　1 #include

　　2 using namespace std;

　　3

　　4 void BuildHeap(int *a, int i, int n) //建二叉堆

　　5 {

　　6 int j=(i-1)/2; //j为i节点的父亲节点

　　7 while(i>0)

　　8 {

　　9 if(a[j]>=a[i]) break;

　　10 swap(a[i],a[j]);

　　11 i=j;

　　12 j=(i-1)/2;

　　13 }

　　14 }

　　15

　　16 void MaxHeapSort(int *a, int i, int n) //二叉堆排序

　　17 {

　　18 int j=2*i+1, tmp=a[i];

　　19 while(j<n)< p="">

　　20 {

　　21 if(a[j+1]>a[j]&&j+1<n) p="" 选出i节点左右孩子节点的最大值<="" j++;="">

　　22 if(tmp>=a[j]) break;

　　23 a[i]=a[j];

　　24 i=j;

　　25 j=2*i+1;

　　26 }

　　27 a[i]=tmp;

　　28 }

　　29

　　30

　　31 int main()

　　32 {

　　33 int a[]= {1,99,2,88,3,77,4,66};

　　34 int n=sizeof(a)/4;

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

　　36 BuildHeap(a,i,n);

　　37 for(int i=n-1; i>=1; i--)

　　38 {

　　39 swap(a[i],a[0]);

　　40 MaxHeapSort(a,0,i);

　　41 }

　　42 cout 《 a[0] ;

　　43 for(int i=1; i<n; p="" a[i];<="" 《="" ?="" cout="" i++)="">

　　44 cout 《endl;

　　45 return 0;

　　46 }

　　6、归并排序

　　归并的意思就是两个或两个以上的有序表组合成一个新的有序表。整个归并排序需要进行【lgn取上限】次，总的时间复杂度为O(nlgn)。与快速排序相比，归并排序的最大特点是：它是一种稳定的排序方法。

　　1 #include

　　2 using namespace std;

　　3

　　4 void Merge(int *a, int s, int m, int t)

　　5 {

　　6 int *b=new int[10];

　　7 int i=s, j=m+1, num=0;

　　8 while(i<=m&&j<=t)

　　9 {

　　10 if(a[i]<=a[j]) b[num++]=a[i], i++;

　　11 else b[num++]=a[j],j++;

　　12 }

　　13 while(i<=m) b[num++]=a[i], i++;

　　14 while(j<=t) b[num++]=a[j], j++;

　　15 for(int i=s; i<=t; i++) a[i]=b[i-s];

　　16 delete[] b;

　　17 }

　　18

　　19 void MergeSort(int *a, int s, int t)

　　20 {

　　21 if(a==NULL) return ;

　　22 if(s<t)< p="">

　　23 {

　　24 int mid=(s+t)/2;

　　25 MergeSort(a,s,mid);

　　26 MergeSort(a,mid+1,t);

　　27 Merge(a,s,mid,t);

　　28 }

　　29 }

　　30

　　31

　　32 int main()

　　33 {

　　34 int a[]= {1,99,2,88,3,77,4,66};

　　35 int n=sizeof(a)/4;

　　36 MergeSort(a,0,n-1);

　　37 cout 《 a[0] ;

　　38 for(int i=1; i<n; p="" a[i];<="" 《="" ?="" cout="" i++)="">

　　39 cout 《endl;

　　40 return 0;

　　41 }

　　7、希尔排序

　　希尔排序就是利用无空位的跳跃值gap进行跳跃排序，如果n为8,为gap的取值则为8 4 2 1, gap=gap/2,gap初始值为n/2.

　　对于每个gap值，都要从后往前扫一遍(以gap值大小跳跃比较)，即i,i-gap,i-2*gap……注意：只限在相邻两个扫到的数比较。

　　时间复杂度：O(nlog(n*n))。

　　1 #include

　　2 using namespace std;

　　3

　　4 void ShellSort(int *a, int n)

　　5 {

　　6 for(int gap=n/2; gap>0; gap/=2)

　　7 for(int i=gap; i<n; p="" i++)<="">

　　8 for(int j=i-gap; j>=0; j-=gap)

　　9 if(a[j]>a[j+gap]) swap(a[j],a[j+gap]);

　　10 }

　　11

　　12 int main()

　　13 {

　　14 int a[]= {1,99,2,88,3,77,4,66,123,321,58,324,127,428};

　　15 int n=sizeof(a)/4;

　　16 ShellSort(a,n);

　　17 cout 《 a[0];

　　18 for(int i=1; i<n; p="" a[i];<="" 《="" ?="" cout="" i++)="">

　　19 cout 《 endl;

　　20 return 0;

　　21 }

　　8、二叉树排序

　　二叉树的性质：对于每个节点，它的左孩子的键值一定比它小，右孩子的键值一定比它大。

　　二叉树排序简单点说就是先随便设置一个根节点，然后将其他数一个一个插入到树中，权值小于此节点则往左走，大于往右走，一直找到合适的位置建立自己新的节点位置。

　　1 #include

　　2 #include

　　3 #include

　　4 #include

　　5 using namespace std;

　　6

　　7 struct Node

　　8 {

　　9 int key;

　　10 Node *l, *r;

　　11 Node(){ l=NULL; r=NULL;}

　　12 };

　　13

　　14 Node* Insert(Node *rt, int key)

　　15 {

　　16 if(rt==NULL)

　　17 {

　　18 Node *rt=new Node();

　　19 rt->key=key;

　　20 return rt;

　　21 }

　　22 if(keykey) rt->l=Insert(rt->l,key);

　　23 else rt->r=Insert(rt->r,key);

　　24 return rt;