C# 算法

 

usingSystem;
usingSystem.Collections.Generic;
usingSystem.Linq;
usingSystem.Text;

namespacec_sharp_sort
{
classProgram
{
staticvoidMain(string[]args)
{
int[]test7={21,13,321,231,43,7,65,18,48,6};
heapsort(test7,0,9);//堆排序
foreach(intaintest7)
Console.Write(a.ToString().PadRight(4));
Console.WriteLine();

int[]test6={21,13,321,231,43,7,65,18,48,6};
radixsort(test6,0,9,2);//基数排序（第4个参数是数组中最大数的10的最大次瞑）
foreach(intaintest6)
Console.Write(a.ToString().PadRight(4));
Console.WriteLine();

int[]test0={21,13,321,231,43,7,65,18,48,6};
insertsort(test0,10);//插入排序
foreach(intaintest0)
Console.Write(a.ToString().PadRight(4));
Console.WriteLine();

int[]test1={21,13,321,231,43,7,65,18,48,6};
newinsertsort(test1,10);//折半插入排序
foreach(intaintest1)
Console.Write(a.ToString().PadRight(4));
Console.WriteLine();

int[]test2={21,13,321,231,43,7,65,18,48,6};
shellsort(test2,10);//希尔排序
foreach(intaintest2)
Console.Write(a.ToString().PadRight(4));
Console.WriteLine();

int[]test3={21,13,321,231,43,7,65,18,48,6};
paopaosort(test3,10);//冒泡排序
foreach(intaintest3)
Console.Write(a.ToString().PadRight(4));
Console.WriteLine();

int[]test4={21,13,321,231,43,7,65,18,48,6};
fastsort(test4,0,9);//快速排序
foreach(intaintest4)
Console.Write(a.ToString().PadRight(4));
Console.WriteLine();

int[]test5={21,13,321,231,43,7,65,18,48,6};
selectsort(test5,10);//选择排序
foreach(intaintest5)
Console.Write(a.ToString().PadRight(4));
Console.WriteLine();

Console.Read();
}
staticpublicvoidheapsort(int[]array,intbegin,intend)//堆排序
{
inttemp,i,j,length;
for(i=(end-begin)/2;i>=begin;i--)//建初堆
{
j=i;
while(j<=(end-begin)/2)
{
if((2*j+2)<=end)
{
if(array[2*j+1]>array[2*j+2]&&array[2*j+1]>array[j])
{
temp=array[2*j+1];
array[2*j+1]=array[j];
array[j]=temp;
j=2*j+1;
}
elseif(array[2*j+1]<array[2*j+2]&&array[2*j+2]>array[j])
{
temp=array[j];
array[j]=array[2*j+2];
array[2*j+2]=temp;
j=2*j+2;
}
else
break;
}
else
{
if(array[2*j+1]>array[j])
{
temp=array[2*j+1];
array[2*j+1]=array[j];
array[j]=temp;
j=2*j+1;
}
break;
}
}
}
for(length=end;length>begin;length--)//首尾交换
{
temp=array[length];
array[length]=array[0];
array[0]=temp;
j=0;
while(j<(length-begin-1)/2)//调整堆
{
if((2*j+2)<=end)
{
if(array[2*j+1]>array[2*j+2]&&array[2*j+1]>array[j])
{
temp=array[2*j+1];
array[2*j+1]=array[j];
array[j]=temp;
j=2*j+1;
}
elseif(array[2*j+1]<array[2*j+2]&&array[2*j+2]>array[j])
{
temp=array[j];
array[j]=array[2*j+2];
array[2*j+2]=temp;
j=2*j+2;
}
else
break;
}
}
}
}

staticpublicvoidinsertsort(int[]array,intlength)//直接插入排序
{
inti,j,temp;
for(i=1;i<length;i++)
{
temp=array[i];
j=i-1;
while(temp<array[j])
{
array[j+1]=array[j];
j=j-1;
if(j==-1)
{
break;
}
}
array[j+1]=temp;
}
}

staticpublicvoidnewinsertsort(int[]array,intlength)//折半插入排序
{
intlow,high,i,j,temp;
for(i=1;i<length;i++)
{
temp=array[i];
low=0;high=i-1;
j=(high-low)/2;
while(low<=high)
{
if(low==high)
{
if(array[0]>temp)
j=0;
else
j=1;
break;
}
elseif(low==high-1)
{
if(array[j+1]<temp)
j+=2;
elseif(array[j]<temp)
j++;
break;
}
elseif(array[j]<temp)
{
low=j;
j+=(high-low)/2;
}
elseif(array[j]>temp)
{
high=j;
j=low+(high-low)/2;
}
else
break;
}
for(intn=i-1;n>=j;n--)
array[n+1]=array[n];
array[j]=temp;
}
}

staticpublicvoidshellsort(int[]array,intlength)//希尔排序（基于直接插入排序）
{
inti,j,k,delta=length/2,temp;
while(delta!=0)//delte为分组递增值
{
for(i=0;i<delta;i++)
{
for(j=i+delta;j<length;j+=delta)
{
temp=array[j];
k=j-delta;
while(temp<array[k])//对每组进行直接插入排序
{
array[k+delta]=array[k];
k=k-delta;
if(k==i-delta)
{
break;
}
}
array[k+delta]=temp;
}
j-=delta;
if(array[j]<array[i])//2组之间首位进行交换排序
{
temp=array[j];
array[j]=array[j];
array[j]=temp;
}
}
delta/=2;
}
}

staticpublicvoidpaopaosort(int[]array,intlength)//冒泡排序
{
inti,j,temp;
j=length;
while(j!=0)
{
for(i=0;i<j-1;i++)
{
if(array[i]>array[i+1])
{
temp=array[i];
array[i]=array[i+1];
array[i+1]=temp;
}
}
j--;
}
}

staticpublicvoidfastsort(int[]array,intbegin,intend)//快速排序
{
if(begin<0||end<0||begin>end)
return;
intleft=begin,right=end,temp;//经典的快排
temp=array[left];
while(right!=left)
{
while(temp<array[right]&&right>left)
right--;
if(right>left)
{
array[left]=array[right];
left++;
}
while(temp>array[left]&&right>left)
left++;
if(right>left)
{
array[right]=array[left];
right--;
}
}
array[right]=temp;
fastsort(array,right+1,end);
fastsort(array,begin,right-1);
}
staticpublicvoidselectsort(int[]array,intlength)//选择排序
{
inti=0,j,min,temp_array,temp;
while(i<length-1)
{
min=array[i];
temp=i;
for(j=i+1;j<length;j++)
{
if(array[j]<min)
{
min=array[j];
temp=j;
}
}
temp_array=array[i];
array[i]=array[temp];
array[temp]=temp_array;
i++;
}
}
staticpublicvoidradixsort(int[]array,intbegin,intlast,intpow)//基数排序
{
Queue<int>[]queue=newQueue<int>[10];//利用泛型队列来存储筛选分组
queue[0]=newQueue<int>();
queue[1]=newQueue<int>();
queue[2]=newQueue<int>();
queue[3]=newQueue<int>();
queue[4]=newQueue<int>();
queue[5]=newQueue<int>();
queue[6]=newQueue<int>();
queue[7]=newQueue<int>();
queue[8]=newQueue<int>();
queue[9]=newQueue<int>();
int[]nn={0,0,0,0,0,0,0,0,0,0};
intx,p=pow,n,i;
while(p>=0)
{
for(i=begin;i<=last;i++)
{intsum=array[i];
n=pow-p;
while(n!=0)
{
sum=sum/10;
n--;}
sum=sum%10;
switch(sum)
{case0:queue[0].Enqueue(array[i]);nn[0]++;break;
case1:queue[1].Enqueue(array[i]);nn[1]++;break;
case2:queue[2].Enqueue(array[i]);nn[2]++;break;
case3:queue[3].Enqueue(array[i]);nn[3]++;break;
case4:queue[4].Enqueue(array[i]);nn[4]++;break;
case5:queue[5].Enqueue(array[i]);nn[5]++;break;
case6:queue[6].Enqueue(array[i]);nn[6]++;break;
case7:queue[7].Enqueue(array[i]);nn[7]++;break;
case8:queue[8].Enqueue(array[i]);nn[8]++;break;
case9:queue[9].Enqueue(array[i]);nn[9]++;break;
}
}//for
x=n=0;
for(i=0;i<10;i++)
{n=n+x;
x=nn[i];
while(nn[i]!=0)
{
array[n+x-nn[i]]=queue[i].Peek();
queue[i].Dequeue();
nn[i]--;
}}
p--;}//while
}
}
}