基础排序算法 c#

算法知识欠缺，学习几种基础排序算法，1. 选择排序  2.冒泡排序 3.插入排序

以升序为例，程序中凡是 两个值的比较前者大于后者，则调换位置

1. 选择排序 最容易想到的排序算法，但却不知道这种叫做选择排序法

 1         /// <summary>
 2         /// 选择排序
 3         /// </summary>
 4         /// <param name="sourceValues"></param>
 5         /// <returns></returns>
 6         public static int[] SelectionSortMin2Max(int[] sourceValues)
 7         {
 8             int[] ret = sourceValues;
 9
10             if (sourceValues == null)
11                 return ret;
12
13             //第1个依次跟第2，3，4...个比较，比较得到的较小值放在第1个 结果第1个是最小值
14             //第2个依次跟第3，4...个比较，比较得到的较小值放在第2个    结果第2个是次小值 ...
15             int temp;
16             for (int i = 0; i < ret.Length - 1; i++)
17             {
18                 for (int j = i + 1; j < ret.Length; j++)
19                 {
20                     if (ret[j] < ret[i])
21                     {
22                         temp = ret[i];
23                         ret[i] = ret[j];
24                         ret[j] = temp;
25                     }
26                 }
27             }
28
29             return ret;
30         }

2. 冒泡排序算法 相邻两个值比较（1和2，2和3...N-1和N）  结果第N是最大值

　　　　　　　  相邻两个值比较（1和2，2和3...N-2和N-1）结果第N-1是次大值...

 1 /// <summary>
 2         /// 冒泡排序
 3         /// </summary>
 4         /// <param name="sourceValues"></param>
 5         /// <returns></returns>
 6         public static int[] BubbleSortMin2Max(int[] sourceValues)
 7         {
 8             int[] ret = sourceValues;
 9
10             if (sourceValues == null)
11                 return ret;
12
13             // 相邻比较
14             //内层完整循环第一次(第1与第2比较，第2与第3比较...第N-1和第N个比较)，冒泡结果ret[ret.length-1]为最大值
15             //内层完整循环第二次(第1与第2比较，第2与第3比较...第N-2和第N-1个比较)，冒泡结果ret[ret.length-2]为次大值
16             // ...
17             int temp;
18             for (int i = 0; i < ret.Length-1; i++)
19             {
20                 for(int j = 0; j < ret.Length - i - 1; j++)
21                 {
22                     if (sourceValues[j] > sourceValues[j + 1])
23                     {
24                         temp = sourceValues[j];
25                         sourceValues[j] = sourceValues[j + 1];
26                         sourceValues[j + 1] = temp;
27                     }
28                 }
29             }
30
31             return ret;
32         }

3. 插入排序

 1         /// <summary>
 2         /// 插入排序法
 3         /// </summary>
 4         /// <param name="sourceValue"></param>
 5         /// <returns></returns>
 6         public static int[] insertionSort(int[] sourceValue)
 7         {
 8             int[] ret = sourceValue;
 9             if (sourceValue == null)
10                 return ret;
11
12             //思路：假设前面N个值的顺序是对的，第N+1个值要加进来，则第N+1个值往前冒泡(对比调换位置)直到找到合适的位置
13             //      第1个值往前冒泡后，则第0，1个值是按顺序的
14             //      第2个值往前冒泡后，则第0，1，2个值是按顺序的
15             // ...  第N个值往前冒泡后，则第0，1...N个值是按顺序的
16             int temp;
17             for (int i = 1; i < ret.Length; i++)
18             {
19                 for (int j = i; j >= 1; j--)
20                 {
21                     if (ret[j] >= ret[j - 1])
22                     {
23                         break;
24                     }
25                     temp = ret[j];
26                     ret[j] = ret[j - 1];
27                     ret[j - 1] = temp;
28                 }
29             }
30             return ret;
31         }