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;

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值