排序方法总结

一、选择排序法

1、默认第一个数已经排序，且默认第一个数为最小的数，定义min用来存放最小的数在数组中的位置。

2、用min指向的数（即第一个数）和第二个数比较，如果第一个数比第二个数小，min指向不变（为0）；

                                                                                             如果第一个数比第二个数大，min指向第二个数（为1）；

3、用min指向的数和第三个数比较，如果min指向的数比第三个数小，min指向不变（还为0）；

                                                                 如果min指向的数比第三个数大，min指向第三个数（为2）；

4、依次用min指向的数和下一个比较，直到数组的数全部比较完，此时min指向的数为最小的数。

5、把min指向的数放在数组的第一个位置，即和数组第一个数交换数值。

6、此时min指向数组第二个数，再按上面的方法依次和后面的数比较，直到求出第二个min，和数组第二个数交换，直到所有的数排序

实例：

            int[] arr = new int[] { 25, 35, 10, 22, 47, 27, 33,16 };//定义数组
            for (int i = 0; i < arr.Length; i++)//i=0，min=i,从第一个数开始往后依次比较
            {
                int min = i;//把min指向未排序的第一个数
                for (int j = i + 1; j < arr.Length; j++)//用j控制依次要和min比较的数的位置
                {
                    if (arr[j] < arr[min])//如果下一个数比min指向的数小，把min指向j的位置
                    {
                        min = j;
                    }
                }
                //第一次全部比较完成得到min后，把min和数组第一个数交换数值
                int number = arr[i];
                arr[i] = arr[min];
                arr[min] = number;
            }
            //遍历输出数组
            foreach (int i in arr)
            {
                System.Console.WriteLine(i);
            }
二、冒泡排序法

冒泡排序效率相较于其它几种来说效率有点低，但也是一种基础算法，而冒泡排序又有两种算法。

第一种：

1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3.针对所有的元素重复以上的步骤，除了最后一个。
4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

注释：第一次比较第一、二对，第二次比较第二、三对，直到比较完整个数组

缺点，这种算法效率低，需要重复进行比较。

例子：

             int[] arrayint = new int[] { 25, 35, 10, 22, 47, 27, 33, 16 };//定义数组
            //冒泡法排序例子1
            for (int i = 0; i < arrayint.Length - 1; i++)//i=0，min=i,从第一个数开始往后依次比较
             {
                 for (int j = 0; j < arrayint.Length - 1; j++)
                 {                                          
                      int number = 0;
                      if (arrayint[j] > arrayint[j+1])
                      {
                      number = arrayint[j];
                      arrayint[j] = arrayint[j+1];
                      arrayint[j+1] = number;
                      }
                 }
             }

第二种：

1、用第一个数字和第二个数字比较，如果第一个数大于第二个数，交换两个数值。

2、用第一个数字和第三个数字比较，如果第一个数大于第三个数，交换两个数值。

3、重复以上步骤，直到第一个数和数组中所有的数比较完。

4、用第二个数字和第三个数字比较，如果第二个数字大于第三个数字，交换两个数值。

。。。。。。

5、重复以上步骤直到全部比较完毕

这种算法比上面的冒泡算法效率高。

例子：

            int[] arrayint = new int[] { 25, 35, 10, 22, 47, 27, 33, 16 };//定义数组

            for (int i = 0; i < arrayint.Length ; i++)
            {
                int number = 0;
                for (int j =i+ 1; j < arrayint.Length ; j++)
                {
                    if (arrayint[i] > arrayint[j])
                    {
                        number = arrayint[i];
                        arrayint[i] = arrayint[j];
                        arrayint[j] = number;
                    }
                }
            }

            //随机数组
            int[] arrayint = new int[10];
            Random ro = new Random();
            for (int i = 0; i < arrayint.Length; i++)
            {
                int numberRandom = 0;
                bool judge = true;
                while (judge)
                {
                    judge = false;
                    numberRandom = ro.Next(0, 99);
                    foreach (int number in arrayint)
                    {
                        if (number == numberRandom)
                            judge = true;
                    }
                    
                }
                arrayint[i] = numberRandom;
                System.Console.WriteLine(arrayint[i]);
            }

            //选择排序法
            int min;//用于存放最小的数的下标
            int numbermin = 0;
            for (int i = 0; i < arrayint.Length; i++)//用于遍历整个数组
            {
                //int j = i+1;//下一个数和上一个数比较
                min = i;
                for (int j = i + 1; j < arrayint.Length; j++)
                {

                    if (arrayint[j] < arrayint[min])
                    {
                        min = j;
                    }
                }
                numbermin = arrayint[min];
                arrayint[min] = arrayint[i];
                arrayint[i] = numbermin;
            }

            //插入排序法第一种
            /*for (int i = 0; i < arrayint.Length; i++)
            {
                for (int j = i; j > 0; j--)
                {
                    int number = 0;
                    if (arrayint[j - 1] > arrayint[j])
                    {
                        number = arrayint[j - 1];
                        arrayint[j - 1] = arrayint[j];
                        arrayint[j] = number;
                    }
                }
            }*/
            //插入排序法第二种
            /*for (int i = 0; i < arrayint.Length; i++)
            {
                int j = i;
                int number = arrayint[i];
                while ((j > 0) && arrayint[j - 1] > number)
                {
                    arrayint[j] = arrayint[j - 1];
                    j--;
                }
                arrayint[j] = number;
            }
            */
            //冒泡排序法第一种,效率比较低
            /* for (int i = 0; i < arrayint.Length ; i++)
             {
                 int number = 0;
                 for (int j =i+ 1; j < arrayint.Length ; j++)
                 {
                     if (arrayint[i] > arrayint[j])
                     {
                         number = arrayint[i];
                         arrayint[i] = arrayint[j];
                         arrayint[j] = number;
                     }
                 }
             }*/

            //int[] arr = new int[] { 25, 35, 10, 22, 47, 27, 33, 16 };//定义数组
            //冒泡法排序第二种
            /* for (int i = 0; i < arrayint.Length - 1; i++)//i=0，min=i,从第一个数开始往后依次比较
             {
                 for (int j = 0; j < arrayint.Length - 1; j++)
                 {                                          
                      int number = 0;
                      if (arrayint[j] > arrayint[j+1])
                      {
                      number = arrayint[j];
                      arrayint[j] = arrayint[j+1];
                      arrayint[j+1] = number;
                      }
                 }
             }*/
            //遍历输出数组
            foreach (int i in arrayint)
            {
                System.Console.WriteLine("排序的结果为："+i);
            }