常用的排序算法

c# 排序算法

1-冒泡排序：

冒泡排序在数量大的时候效率不高，适合一般数据量较少的情况下使用

 public static int[] Sort(int[] arr)
        {
            if(arr.Length==0)
            {
                return arr;
            }
            else
            {
                for (int i = 0; i < arr.Length; i++)//比较的趟数
                {
                    for (int j = 0; j < arr.Length-1-i; j++)//每趟比较的次数
                    {
                        if(arr[j]>arr[j+1])
                        {
                            int temp = arr[j + 1];
                            arr[j + 1] = arr[j];
                            arr[j] = temp;
                        }
                    }
                }
                return arr;
            }
        }

2-插入排序：

思想：
1 将整个数组分为有序和无序两个部分，有序在左边，无序在右边。
2 开始时有序部分只有数组元素的第一个(array[0])，其余的都是无序部分。
3 每次去除无序部分的第一个元素，把他加入到有序部分。假设插入到合适位置 index，则原来index 位置的元素以及它后面的元素都向右(后)移动一个 位置，则有序部分就增加一个元素。
4 一直到无序部分没有元素为止。

 public static void Sort2(int[] arr)
        {
            if (arr.Length == 0)
            {
                return;
            }
            else
            {
                for (int i = 1; i < arr.Length; i++)//遍历无序部分元素，arr[i] 是最左边的无序元素，每次循环把arr[i]插入到合适位置
                {
                    for (int j = 0; j < i; j++)//遍历有序部分元素
                    {
                        if(arr[j]>arr[i])//如果有序部分元素大于无序部分元素，把 arr[i]放到 arr[j] 位置
                        {
                            int temp = arr[i];//记录无序部分元素
                            for (int k = i; k > j; k--)//移动有序部分元素
                            { 
                                arr[k] = arr[k - 1];
                            }
                            arr[j] = temp;//把 arr[i]放到 arr[j] 位置
                            break;
                        }
                    }
                }
            }
        }

 public static int[] Sort(int[] arr)
        {
            if(arr.Length==0)
            {
                return arr;
            }
            else
            {
                int currwntNum;//需要对比的数
                for (int i = 0; i < arr.Length-1; i++)
                {
                    currwntNum = arr[i + 1]; //需要对比的数等于当前数前一位
                    int perIndex = i;//当前下标
                    while(perIndex>=0&&currwntNum<arr[perIndex]) //如果当前坐标大于等于0，并且需要对比的数小于当前坐标的数
                    {
                        arr[perIndex + 1] = arr[perIndex]; //数组中当前坐标前一位=需要对比的数（大的向后移动）
                        perIndex--;//坐标后退，（退出while循环的条件）
                    }
                    arr[perIndex + 1] = currwntNum; //需要对比的数等于数组中当前坐标前一位(插入)
                }
                return arr;
            }
        }

4-希尔排序：

 public static int[] Sort(int[] arr)
        {
            int len = arr.Length;
            int temp, gap = len / 2;
            while(gap>0)
            {
                for (int i = gap; i < len; i++)
                {
                    temp = arr[i];
                    int perIndex = i - gap;
                    while(perIndex>=0&&arr[perIndex]>temp)
                    {
                        arr[perIndex + gap] = arr[perIndex];
                        perIndex -= gap;
                    }
                    arr[perIndex + gap] = temp;
                }
                gap /= 2;
            }
            return arr;
        }

5-快速排序：

		 /// <summary>
        /// 对数组dataArray中索引从left到right之间的数做排序
        /// </summary>
        /// <param name="dataArray">要排序的数组</param>
        /// <param name="left">要排序数据的开始索引</param>
        /// <param name="right">要排序数据的结束索引</param>
        static void QuickSort(int[] dataArray, int left, int right)
        {
            if (left < right)
            {

                int x = dataArray[left];//基准数， 把比它小或者等于它的 放在它的左边，然后把比它大的放在它的右边
                int i = left;
                int j = right;//用来做循环的标志位

                while (true &&i<j )//当i==j的时候，说明我们找到了一个中间位置，这个中间位置就是基准数应该所在的位置 
                {

                    //从后往前比较(从右向左比较) 找一个比x小（或者=）的数字，放在我们的坑里 坑位于i的位置
                    while (true && i < j) {
                        if (dataArray[j] <= x) //找到了一个比基准数 小于或者等于的数子，应该把它放在x的左边
                    {
                            dataArray[i] = dataArray[j];
                            break;
                        } else {
                            j--;//向左移动 到下一个数字，然后做比较
                        }
                    }

                    //从前往后（从左向右）找一个比x大的数字，放在我们的坑里面 现在的坑位于j的位置
                    while (true && i < j) {
                        if (dataArray[i] > x) {
                            dataArray[j] = dataArray[i];
                            break;
                        } else {
                            i++;
                        }
                    }

                }

                //跳出循环 现在i==j i是中间位置
                dataArray[i] = x;// left -i- right

                QuickSort(dataArray,left,i-1);
                QuickSort(dataArray,i+1,right);
            }
        }

6-简单选择排序：

每次找出当前的最小值。

 public static int[] Sort(int[] arr)
        {
            if(arr.Length==0)
            {
                return arr;
            }
            else
            {
                for (int i = 0; i < arr.Length; i++)
                {
                    int minIndex = i;//最小元素索引
                    for (int j = i; j < arr.Length; j++)
                    {
                        if(arr[j]<arr[minIndex]) //找到最小数
                        {
                            minIndex = j; //保存最小数的索引
                        }
                    }
                    //交换元素
                    int temp = arr[minIndex];
                    arr[minIndex] = arr[i];
                    arr[i] = temp;
                }
                return arr;
            }
        }

优化版：

 static void SelectSort(int[] dataArray)
        {
            for (int i = 0; i < dataArray.Length-1; i++)
            {
                int min = dataArray[i];//记录最小值。 假设第 i 个最小,一般从数组下标为 0 的元素开始
                int minIndex = i;//记录最小值所在的索引
                for (int j = i+1; j < dataArray.Length; j++)//从 i+1 元素开始依次比较
                {
                    if (dataArray[j] < min)//如果比 min 小
                    {
                        min = dataArray[j];//交换两个变量的值
                        minIndex = j; //交换下标
                    }
                }//循环结束后 min存储最小值，minIndex存储最小值下标
                if (minIndex != i)//如果最小值下标等于 i ,交换两个元素位置
                {
                    int temp = dataArray[i];
                    dataArray[i] = dataArray[minIndex];
                    dataArray[minIndex] = temp;
                }
            }
        }