常用的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;
                }
            }

        }
    }

效果如下：