排序算法集合

冒泡排序

public static int[] MaoPao(int[] param)
        {
            int t = 0;
            //从头遍历数组
            for (int i = 0; i < param.Length; i++)
            {
                //从尾部遍历数组，为了防止尾部小数问题
                for (int j = param.Length - 1; j > i; j--)
                {
                    if (param[i] > param[j])
                    {
                        t = param[i];
                        param[i] = param[j];
                        param[j] = t;
                    }

                }
            }

            return param;
        }

快速排序

public static int[] Quick(int[] param, int left, int right)
        {
            //递归的执行条件，不断的分割数组，分割后的数组看成左右两个
            if (left < right)
            {
                //分割后数组的起始位置
                int baseNum = Partition(param, left, right);
                //利用递归继续分割左侧的数组
                Quick(param, left, baseNum - 1);
                //利用递归继续分割右侧的数组
                Quick(param, baseNum + 1, right);
            }

            return param;
        }

        //分割数组，相当于分治算法，快速排序的核心
        private static int Partition(int[] param, int left, int right)
        {
            while (true)
            {
                //当左右指针走到相同位置时终止操作，并返回当前指针的位置，来作为下一次分割数组的起始位置
                if(left == right)
                    return left;

                //定义基准数，每个数都与基准数比较，将大于基准数的数与小于基准数的数分开
                int pivot = param[left];
                if (pivot > param[left + 1])
                {
                    param[left] = param[left + 1];
                    param[left + 1] = pivot;
                    left++;
                }
                else
                {
                    int temp = param[right];
                    param[right] = param[left + 1];
                    param[left + 1] = temp;
                    right--;
                }
            }
        }

插入排序

public static int[] Insert(int[] param)
        {
            //遍历数组，因为第一个数看成已经排好的数，所以从第二个数开始遍历
            for (int i = 1; i < param.Length; i++)
            {
                int t = param[i];
                int j = i - 1;
                //从i-1的位置开始往前遍历数组，并与位于位置j的数比较，将大于i位置的数放到j+1的位置
                while (j >= 0 && t < param[j])
                {
                    param[j + 1] = param[j];
                    j--;
                }
                //将位于i位置的数，放到空余位置，这时j+1位置没有数
                param[j + 1] = t;
            }
            return param;
        }

选择排序

public static int[] Select(int[] param)
        {
            for (int i = 0; i < param.Length; i++)
            {
                //定义最小数，所有数与该数比较，如果有比该数小的数，重新为该数赋值
                int min = param[i];
                //最小数所在位置的索引
                int index = i;
                int t;
                
                //从前向后逐步查找最小数
                for (int j = i+1; j < param.Length; j++)
                {
                    if (param[j] < min)
                    {
                        min = param[j];
                        index = j;
                    }
                }
                //将找到的最小数放到数组的前面
                t = param[i];
                param[i] = min;
                param[index] = t;

            }

            return param;
        }

归并排序

public static int[] Merge(int[] param)
        {
            //i是数据被分割之后的子数组的长度，从1开始，这层循环也可以使用递归实现
            for (int i = 1; i < param.Length; i = i * 2)
            {
                //比较两个分割后的相邻的子数组
                for (int j = 0; j < param.Length; j = j + i * 2)
                {
                    //第一个数组的起始位置
                    int start1 = j;
                    //第二个数组的起始位置
                    int start2 = j + i;

                    //定义新数组来临时存放比较后的结果
                    int[] arr = new int[j + i * 2];
                    //新数组的索引
                    int index = 0;
                    while (start1 <= j + i && start2 <= j + i * 2)
                    {
                        if (param[start1] > param[start2])
                        {
                            arr[index] = param[start2];
                            start1++;
                            index++;
                        }
                        else
                        {
                            arr[index] = param[start1];
                            start2++;
                            index++;
                        }
                    }

                    //左侧有未处理的数据
                    while (start1 <= j + i)
                    {
                        arr[index] = param[start1];
                        start1++;
                        index++;
                    }

                    //右侧有未处理的数据
                    while (start2 <= j + i * 2)
                    {
                        arr[index] = param[start2];
                        start2++;
                        index++;
                    }

                    //将新数组的数据放回到原数组中
                    for (int k = start1, l = 0; k < arr.Length; k++, l++)
                    {
                        param[k] = arr[l];
                    }
                }
            }
            return param;
        }