常用的20种经典算法及其应用

1、冒泡排序

技术要点：这个过程很简单，就是首先将第一条记录的关键字和第二个关键字进行比较，要是为逆序，则将数据交换，然后就是第二个和第三个，以此类推。直至第N-1个记录和N个记录的关键字进行过比较为止。

  static void Main(string[] args)
        {
            //冒泡排序
            BubbleSorter b = new BubbleSorter();
            int[] list = {2,55,44,21,35,62,22,41,14,28,95,100 };
            b.Sort(list);
            foreach (var item in list)
            {
                Console.WriteLine(item);
            }
            Console.ReadLine();
            
        }

建立的BubbleSorter类

   public class BubbleSorter
    {
       public void Sort(int[] list)
       {
           int i, j, temp;
           bool done = false;
           j = 1;
           while ((j<list.Length)&&(!done))
           {
               done = true;
               for (i = 0; i < list.Length-j; i++)
               {
                   if (list[i]>list[i+1])
                   {
                       done = false;
                       temp=list[i];
                       list[i]=list[i+1];
                       list[i + 1] = temp;
                   }   
               }
               j++;

           }
          
       }
    }

效果如下：

2、选择排序

技术要点：这个选择排序的主要操作就是关键字之间的比较，很显然是从N个数据中进行简单的排序，就是从1至N-1，进行N-1趟选择操作。

 static void Main(string[] args)
        {
            //选择排序
            SelectionSorter s = new SelectionSorter();
            int[] list = { 2, 55, 44, 21, 35, 62, 22, 41, 14, 28, 95, 100 };
            s.Sort(list);
            foreach (var item in list)
            {
                Console.WriteLine(item);
            }
            Console.ReadLine();
        }

建立的SelectionSorter类

   public class SelectionSorter
    {
       private int min;
       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;
           }
       }
    }

效果如下：

3、插入排序

技术要点：实现插入排序，主要是先找到一个有序序列，然后将下一个关键字插入上述的有序序列，再从剩下的关键字中选取下一个插入对象，反复执行直到整个序列有序为止。

class Program
    {
        static void Main(string[] args)
        {
            InsertionSorter i = new InsertionSorter();
            int[] list = { 54,12,11,41,25,36,5,74,54,100};
            i.Sort(list);
            foreach (var item in list)
            {
                Console.WriteLine(item);
            }
            Console.ReadKey();
        }
    }

 

建立的InsertionSorter类

   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;
           }
       }
    }

效果如下：

4、希尔排序

技术要点：先将整个待排序记录序列分割成若干个子序列分别进行直接插入排序，待整个序列中的记录‘基本有序’时再对全体记录进行一次直接插入排序。特点是：子序列的构成不是简单的‘逐段分割’，而是将相隔某个‘增量’的记录组成一个子序列。

 class Program
    {//希尔排序算法
        static void Main(string[] args)
        {
            ShellSorter s = new ShellSorter();
            int[] list = { 12,45,84,21,5,36,26,56,95,41,20};
            s.Sort(list);
            foreach (var item in list)
            {
                Console.WriteLine(item);
            }
            Console.ReadKey();
        }
    }

建立的ShellSorter类

    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;
                }
            }

        }
    }

效果如下：