锐客网

  1. 首页 > 睿知 > it技术 > >

堆排序算法vb.net 堆排序算法流程图

IT技术int

给定一组无序输入序列（例如：4，7，1，3，9），用堆排序实现由大到小排序 。#include stdio.h
//array是待调整的堆数组，i是待调整的数组元素的位置，nlength是数组的长度
//本函数功能是：根据数组array构建小根堆
void HeapAdjust(int array[],int i,int nLength)
{
int nChild;
int nTemp;
for(;2*i 1nLength;i=nChild)
{
//子结点的位置=2*（父结点位置） 1
nChild=2*i 1;
//得到子结点中较大的结点
if(nChildnLength-1array[nChild 1]array[nChild])nChild;
//如果较小的子结点小于父结点那么把较小的子结点往上移动，替换它的父结点
if(array[i]array[nChild])
{
nTemp=array[i];
array[i]=array[nChild];
array[nChild]=nTemp;
}
else break; //否则退出循环
}
}
//堆排序算法
void HeapSort(int array[],int length)
{
int i,j;
//调整序列的前半部分元素，调整完之后第一个元素是序列的最小的元素
//length/2-1是最后一个非叶节点，此处"/"为整除
for(i=length/2-1;i=0;--i)
HeapAdjust(array,i,length);
//从最后一个元素开始对序列进行调整，不断的缩小调整的范围直到第一个元素
for(i=length-1;i0;--i)
{
//把第一个元素和当前的最后一个元素交换，
//保证当前的最后一个位置的元素都是在现在的这个序列之中最小的
array[i]=array[0]^array[i];
array[0]=array[0]^array[i];
array[i]=array[0]^array[i];
//不断缩小调整heap的范围 ， 每一次调整完毕保证第一个元素是当前序列的最小值
HeapAdjust(array,0,i);
for(j=0;jlength;j)
printf("%d ",array[j]);
printf("\n");
}
}
int main()
{
int i;
int num[]={4,7,1,3,9};
HeapSort(num,sizeof(num)/sizeof(int));
printf("\nok\n");
return 0;
}
3. 用任意一种编程语言（C/C/Java/C#/VB.NET）写出任意一种你所知的排序算法（比如：冒泡排序 ， 归并排#includestdio.h
#includestdlib.h
void BubbleSort(int a[], const int first, const int last);//冒泡排序
void InsertSort(int a[], const int first, const int last);//插入排序
void SelectSort(int a[], const int first, const int last);//选择排序
void MergeSort(int a[], const int p, const int r);//合并排序
void QuickSort(int a[],const int p,const int r);//快速排序
void ShellSort(int a[],const int p,const int r,const int dlta[],const int t);//希尔排序
void HeapSort(int a[],const int p, int r); //堆排序
void StoogeSort(int a[],const int p,const int r);//Stooge排序(不用)算法复杂度没算清楚
void main()
{
//插入排序算法
int a[11] = {6,4,5,3,2,1};
int dlta[]={9,5,3,2,1};
//BubbleSort(a,0,5);
//InsertSort(a,0,5);
//SelectSort(a,0,5);
//MergeSort(a,0,5);
//QuickSort(a,0,5);
//ShellSort(a,0,5,dlta,5);
HeapSort(a,0,5);
//StoogeSort(a,0,5);
for(int i=0; i=5;i)
{
printf("%d ",a[i]);
}
}
/************************冒泡排序***********************/
void BubbleSort(int a[], int first, int last)
{
//实现对数组a[]中a[first]到a[last]升序堆排序算法vb.net的“冒泡”排序
int i,j,temp;
for(i=first; i=last; i)
{
for(j=first; j last-i; j)
{
if(a[j]a[j 1])
{
temp= a[j];
a[j]= a[j 1];
a[j 1] = temp;
}
}
}
}
/************************插入排序***********************/
void InsertSort(int a[], int first, int last)
{
//实现对数组a[]中a[first]到a[last]升序的“插入”排序
//最坏情况为n的平方， ， 多用于小数组
int i,j,temp;
for(i=first 1; i=last; i)
{
temp= a[i];
j = i - 1;
while((j = 0)(a[j]temp))
{
a[j 1]= a[j];
j--;
}
a[j 1] = temp;
}
}
/************************选择排序***********************/
void SelectSort(int a[], int first, int last)
{
//实现对数组a[]中a[first]到a[last]升序的“选择”排序
int i, j, temp, num;
for(i=first; ilast; i)
{
num = i;
for(j=i 1; j=last; j)
{
if(a[j]a[num])
{
num = j;
}
}
if(i != num)
{
temp= a[num];
a[num] = a[i];
a[i]= temp;
}
}
}
/************************合并排序***********************/
void Merge(int a[],const int p,const int q,const int r)
{
//合并排序算法中的实现合并的子程序
int iLLength,iRLength;
int *L, *R, i, j, k;
iLLength = q - p1;
iRLength = r - q;
L = (int *)malloc(iLLength*sizeof(int)); //或者 C中 new int[iLLength];
R = (int *)malloc(iRLength*sizeof(int)); //或者 C中 new int[iRLength];
if(L == 0 || R== 0)
{
printf("内存分配失败堆排序算法vb.net?。。?);
return;
}
for(i=0; iiLLength; i)
{
L[i] = a[p i];
}
for(j=0; jiRLength; j)
{
R[j] = a[q j 1];
}
i = 0;
j = 0;
for(k=p; k=r; k)
{
if((iiLLength)(jiRLength)(L[i]=R[j]) || (j == iRLength))
{
a[k] = L[i];
i;
}
else if(jiRLength)
{
a[k] = R[j];
j;
}
}
free(R);free(L);
}
void MergeSort(int a[],const int p,const int r)
{
//合并排序算法-主程序
//n*lg(n),系数较小
int q;
if(pr)
{
q = (p r)/2;
MergeSort(a,p,q);
MergeSort(a,q 1,r);
Merge(a,p,q,r);
}
}
/************************Stooge排序***********************/
void StoogeSort(int a[],const int p,const int r)
{
//Stooge算法
int temp, k;
if(a[p]a[r])
{
temp= a[p];
a[p]= a[r];
a[r]= temp;
}
if((p 1) = r)
{
return;
}
k = (r-p 1)/3;
StoogeSort(a,p,r-k);
StoogeSort(a,p k,r);
StoogeSort(a,p,r-k);
}
/************************快速排序*********************/
int QuickPartition(int a[],const int p,const int r)
{
//快速排序的(关键)分治过程
int temp, x, i, j;
x = a[r];
i = p - 1;
for(j=p; jr; j)
{
if(a[j] = x)
{
i = i1;
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
temp= a[i 1];
a[i 1] = a[r];
a[r]= temp;
return (i 1);
}
/*
void QuickSort(int a[],const int p,const int r)
{
//快速排序算法-主程序
//与下面的“尾递归实现方法”比较，缺点：右边数组的递归不是必须的，增加了运行堆栈深度和调用开销
int q;
if(pr)
{
q = QuickPartition(a, p, r);
QuickSort(a, p, q-1);
QuickSort(a, q 1, r);
}
}
*/
void QuickSort(int a[],int p,const int r)
{
//快速排序算法-主程序
//“尾递归实现方法”是对上面的快速排序主程序实现的一种优化
//系数较小,常用大数组
int q;
while(pr)
{
q = QuickPartition(a, p, r);
QuickSort(a, p, q-1);
p = q1;
}
}
/************************希尔排序**********************/
void ShellInsert(int a[],const int p,const int r, int dk)
{
//希尔排序算法的关键子程序-插入排序子程序
int i, j, temp;
for(i=p dk; i=r; i)
{
if(a[i]a[i-dk])
{
temp = a[i];
for(j=i-dk; ((j=0)(tempa[j])); j -= dk)
{
a[j dk] = a[j];
}
a[j dk] = temp;
}
}
}
void ShellSort(int a[],const int p,const int r,const int dlta[],const int t)
{
//希尔排序算法-主程序
//按增量序列dlta[]中的前t个增量 ， 实现对数组a[]中a[p]到a[r]的排序
//dlta[]可能取值如：1,2,3,5,9dala[k]=2^(t-k 1)-1 其中0=k=t=ld(b-1)
//增量序列的最后一个值必须是1
//增量序列中的值没有除1以外的因子 ， 其精确时间复杂度：数学上尚未解决的难题
int k;
for(k=0; kt; k)
{
ShellInsert(a,p,r,dlta[k]);
}
}
/************************堆排序***********************/
//堆排序，不如快速排序
//但是可用其来实现“优先级队列”
int Parent(int i)
{
return ((i 1)/2-1);
}
int Right(int i)
{
return (2*(i 1)-1);
}
int Left(int i)
{
return (2*(i 1));
}
void Max_Heapify(int a[],const int hplast,const int i)
{
int l, r,largest,temp;
l = Left(i);
r = Right(i);
largest = ((l=hplast)(a[l]a[i])) ? l:i;
if((r=hplast)(a[r]a[largest]))
{
largest = r;
}
if(largest != i)
{
temp= a[i];
a[i]= a[largest];
a[largest] = temp;
Max_Heapify(a,hplast,largest);
}
}
void Build_Max_Heap(int a[],const int p, const int r)
{
int i;
for(i = (p r)/2; i=p; i--)
{
Max_Heapify(a,r,i);
}
}
void HeapSort(int a[],const int p, int r)
{
int i,temp;
Build_Max_Heap(a,p,r);
for(i = r; ip; i--)
{
temp = a[p];
a[p] = a[i];
a[i] = temp;
r -= 1;
Max_Heapify(a,r,0);
}
}
vb.net 排列组合算法看了你说递归的效率低 。那么你可以不用的 。
给出的方法就是先生成第一个排列，然后每次调用下面的函数给出下一个排列，这样生成的效率很高，这个函数可以内联 。
这个是很经典的排列组合算法?。吭谕夏芩训揭淮蠖?。
大概是那种带指向的移动的算法 。我给你搜一个吧 。
我找了几个，这个是我觉得说的比较清楚的，你可以仔细参考一下，看不懂的话再搜点别的好了 。。
全排列的算法跟这个不太一样的 。需要有点改动的 。
至于语言的话，应该不会有太大问题吧 。。basic版的确实比较少，现在我也比较懒不想动手写 。。还是要靠你自己啦 。

    推荐阅读


    上一篇：家装照明怎么连接电视，家装照明线路走线图

    下一篇：chatgpt衍生职业，CHATGPT对会计职业的影响