C#算法大全

今天有人想让我搞一期C#算法大全。算法就算法，安排上！

希尔排序

希尔排序(Shell’s Sort)是插入排序的一种又称“缩小增量排序”（Diminishing Increment Sort），是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因 D.L.Shell 于 1959 年提出而得名。我们用代码把他实现一下

using System;
public class ShellSorter
{
   
public void Sort(int [] list)
{
   
int inc;
for(inc=1;inc<=list.Length/9;inc=3*inc+1);
for(;inc>0;inc/=3)
{
   
for(int i=inc+1;i<=list.Length;i+=inc)
{
   
int t=list[i-1];
int j=i;
while((j>inc)&&(list[j-inc-1]>t))
{
   
list[j-1]=list[j-inc-1];
j-=inc;
}
list[j-1]=t;
}
}
}
}
public class MainClass
{
   
public static void Main()
{
   
int[] iArrary=new int[]{
   1,5,3,6,10,55,9,2,87,12,34,75,33,47};
ShellSorter sh=new ShellSorter();
sh.Sort(iArrary);
for(int m=0;m<=13;m++)
Console.WriteLine("{0}",iArrary[m]);
}
}

插入排序

直接插入排序即是：顺序地把待排序的各个记录按其关键字插入到已排序后的适当位置处。算法相对简单易懂，就是使用直接插入算法，进行升序排序。

using System;
public class InsertionSorter
{
   
public void Sort(int [] list)
{
   
for(int i=1;i<list.Length;++i)
{
   
int t=list[i];
int j=i;
while((j>0)&&(list[j-1]>t))
{
   
list[j]=list[j-1];
--j;
}
list[j]=t;
}

}
}
public class MainClass
{
   
public static void Main()
{
   
int[] iArrary=new int[]{
   1,5,3,6,10,55,9,2,87,12,34,75,33,47};
InsertionSorter ii=new InsertionSorter();
ii.Sort(iArrary);
for(int m=0;m<=13;m++)
Console.WriteLine("{0}",iArrary[m]);
}
}

已经编译运行通过。过于简单了，不多赘述了。

选择排序

using System;
public class SelectionSorter
{
   
// public enum comp {COMP_LESS,COMP_EQUAL,COMP_GRTR};
private int min;
// private int m=0;
public void Sort(int [] list)
{
   
for(int i=0;i<list.Length-1;++i)
{
   
min=i;
for(int j=i+1;j<list.Length;++j)
{
   
if(list[j]<list[min])
min=j;
}
int t=list[min];
list[min]=list[i];
list[i]=t;
// Console.WriteLine("{0}",list[i]);
}

}
}
public class MainClass
{
   
public static void Main()
{
   
int[] iArrary=new int[]{
   1,5,3,6,10,55,9,2,87,12,34,75,33,47};
SelectionSorter ss=new SelectionSorter();
ss.Sort(iArrary);
for(int m=0;m<=13;m++)
Console.WriteLine("{0}",iArrary[m]);

}
}

常见排序算法介绍

1、稳定排序和非稳定排序

简单地说就是所有相等的数经过某种排序方法后，仍能保持它们在排序之前的相对次序，我们就
说这种排序方法是稳定的。反之，就是非稳定的。
比如：一组数排序前是a1,a2,a3,a4,a5，其中a2=a4，经过某种排序后为a1,a2,a4,a3,a5，
则我们说这种排序是稳定的，因为a2排序前在a4的前面，排序后它还是在a4的前面。假如变成a1,a4,a2,a3,a5就不是稳定的了。

2、内排序和外排序

在排序过程中，所有需要排序的数都在内存，并在内存中调整它们的存储顺序，称为内排序；
在排序过程中，只有部分数被调入内存，并借助内存调整数在外存中的存放顺序排序方法称为外排序。

3、算法的时间复杂度和空间复杂度

所谓算法的时间复杂度，是指执行算法所需要的计算工作量。
算法思想简单描述：
在要排序的一组数中，选出最小的一个数与第一个位置的数交换；
然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环
到倒数第二个数和最后一个数比较为止。

选择排序是不稳定的。算法复杂度O(n2)–[n的平方]

*/
void select_sort(int *x, int n)
{
   
int i, j, min, t;

for (i=0; i<n-1; i++) /*要选择的次数：0~n-2共n-1次*/
{
   
min = i; /*假设当前下标为i的数最小，比较后再调整*/
for (j=i+1; j<n; j++)/*循环找出最小的数的下标是哪个*/
{
   
if (*(x+j) < *(x+min))
{
   
min = j; /*如果后面的数比前面的小，则记下它的下标*/
}
}

if (min != i) /*如果min在循环中改变了，就需要交换数据*/
{
   
t = *(x+i);
*(x+i) = *(x+min);
*(x+min) = t;
}
}
}


/*

直接插入排序

算法思想简单描述：

在要排序的一组数中，假设前面(n-1) [n>=2] 个数已经是排
好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数
也是排好顺序的。如此反复循环，直到全部排好顺序。

直接插入排序是稳定的。算法时间复杂度O(n2)–[n的平方]

*/
void insert_sort(int *x, int