C#排序算法学习笔记

注：都是最简单的方法实现的排序，主要是学习其中的基本原理

1.冒泡排序

static void Main(string[] args)
        {
            int[] arr = new int[] { 9, 50, 5, 66 };
            for (int i = 0; i < arr.Length-1; i++)
            {
                for (int j = 0; j < arr.Length-i-1; j++)
                {
                    if (arr[j] > arr[j + 1])
                    {
                        int temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                }
            }
            for (int i = 0; i < arr.Length; i++)
            {
                Console.WriteLine(arr[i]);
            }
            Console.ReadLine();
        }

2.插入排序

static void Main(string[] args)
        {
            int[] arr = { 9, 8, 7, 4, 6, 99, 5, 1, 3, 0 };

            InsertSort(arr);
            foreach (var item in arr)
            {
                Console.WriteLine(item + " ");
            }

            Console.ReadLine();
        }

        static void InsertSort(int[] arr)
        {
            //for循环先拿出数组中的第二条数据
            //因为要与前边的数据进行对比所以取第二条开始比较
            for (int i = 1; i < arr.Length; i++)
            {
                //拿第一层for循环拿到的数据
                //对他前边的所有数据进行比较
                for (int j = i; j > 0; j--)
                {
                    //如果前边的数据比它大，则交换两条数据的位置
                    if (arr[j] < arr[j - 1])
                    {
                        (arr[j], arr[j - 1]) = (arr[j - 1], arr[j]);
                    }
                    else//如果前边的数据比他小或者是和他相等，则不需要移动交换数据，跳出for循环
                        //让他与前边的其他元素进行比较
                    {
                        break;
                    }
                }
            }
        }

3.快速排序

 static void Main(string[] args)
        {
            int[] arr = { 9, 8, 7, 4, 6, 99, 5, 1, 3, 0 };
            QuickSort(arr, 0, arr.Length - 1);
            foreach (var item in arr)
                Console.WriteLine(item + " ");
            Console.ReadLine();

        }
        static int GetPrivot(int[] arr, int left, int right)
        {
            //选择左边第一个值作为Privot,也可拿右边，也可随意选取数组中的某一条数据作为Privot
            int privot = arr[left];
            //使用while进行数据的比较>移动>完成划分
            //while循环满足left=right时即左右下标相遇，数组划分完成
            while (left < right)
            {
                //如果右标识大于Privot，则不需要移动，将右边标识下标自减，让其与下一个数值进行对比
                //如果对比数值比privot小时，则需要将该值移动到privot的左边，即可以用交换数据的位置来完成数据的移动
                while (left < right && arr[right] >= privot) right--;
                //此处与Swap()功能相同，即数据的交换
                (arr[right], arr[left]) = (arr[left], arr[right]);
                //完成右边数据的比较之后，则需要进行左边的数据移动
                while (left < right && arr[left] <= privot) left++;
                (arr[left], arr[right]) = (arr[right], arr[left]);

            }
            //整个循环结束之后，返回left的下标，即privot的下标
            return left;
        }

        static void QuickSort(int[] arr, int left, int right)
        {
            //此处开始数组的排序，首先需要获取到Privot，同时将原数组划分为两个区域
            //即privot左边都要小于Privot的值，右边反之
            if (left < right)
            {
                int privot = GetPrivot(arr, left, right);
                //划分完成之后，递归，将左右两边按照Getprivot的方法进行区域的划分
                //递归到没有元素进行移动时，即完成排序
                QuickSort(arr, privot + 1, right);
                QuickSort(arr, left, privot - 1);
            }
        }

4.选择排序

 static void Main(string[] args)
        {

            int[] arr = { 5, 8, 6, 0, 9, 2, 4, 3, 5, 1 };
            SelectSort(arr);
            foreach (var item in arr)
                Console.WriteLine(item);
            Console.ReadLine();
        }
        static void SelectSort(int[] arr)
        {
            for (int i = 0; i < arr.Length - 1; i++)
            {
                //首先需要获取到最小值
                int minIndex = i;
                //从第二个值开始遍历
                for (int j = i + 1; j < arr.Length; j++)
                {
                    //拿下一个值跟最小值作比较，记录最小值索引
                    if (arr[j] < arr[minIndex])
                        minIndex = j;
                }
                //一轮比较之后，最小值的索引已经得到，然后进行数据的交换
                (arr[i], arr[minIndex]) = (arr[minIndex], arr[i]);
            }
        }

5.希尔排序

 static void ShellSort(int[] arr)
        {
            //第一次取其一半作为递减增量，后续取上一次递减增量的一半
            for (int d = arr.Length / 2; d > 0; d /= 2)
            {
                //使用插入排序，对使用递减增量划分之后的序列进行排序
                for (int i = d; i < arr.Length; i++)
                {
                    if (arr[i] < arr[i - d])
                    {
                        //声明零时变量用来存储当前用于和其他数值比较的数值
                        int temp = arr[i], j;
                        //循环于之前的相距递减增量间隔的数值进行对比，大于之前不交换数据
                        for (j = i - d; j >= 0 && temp < arr[j]; j -= d)
                            arr[j + d] = arr[j];
                        arr[j + d] = temp;
                    }

                }

            }
        }

6.归并排序

static void Main(string[] args)
        {
            int[] arr = { 4, 5, 3, 2, 1, 7, 6, 9, 8, 10 };
            MergeSort(arr, 0, arr.Length - 1);

            foreach (var item in arr)
            {
                Console.WriteLine(item);
            }

            Console.ReadLine();
        }
        static void MergeSort(int[] arr, int f, int e)
        {
            if (f < e)
            {
                int middle = (e + f) / 2;
                MergeSort(arr, f, middle);
                MergeSort(arr, middle + 1, e);
                MergeMethod(arr, f, middle, e);
            }
        }

        static void MergeMethod(int[] arr, int f, int m, int e)
        {
            //先申请空间，存储临时归并过的数据
            int[] tempArr = new int[e - f + 1];
            //从前后两个子序列的第一个元素开始比较
            //需要同时满足，前后两个序列的自增索引始终要小于子序列的末尾索引
            int fIndex = f, eIndex = m + 1, k = 0;
            while (eIndex <= e && fIndex <= m)
            {
                //既然满足了循环的条件，则从两个子序列的第一个元素开始相互比较
                if (arr[fIndex] > arr[eIndex])
                {
                    //将小的一个放到临时数组的前边，大的放后边
                    tempArr[k++] = arr[eIndex++];
                }
                else
                {
                    //否则反之
                    tempArr[k++] = arr[fIndex++];
                }
            }
            //当归并比较循环结束后，若还有没有比较的元素直接赋值到零时数组的末尾
            //使用两个while循环分别检查前后两个序列，是哪一个还有剩余的元素
            while (fIndex < m + 1)
            {
                tempArr[k++] = arr[fIndex++];
            }
            while (eIndex < e + 1)
            {
                tempArr[k++] = arr[eIndex++];
            }
            //将剩余的元素复制到临时数组之后，在将零时数组的值移动到原数组中
            for (k = 0, fIndex = f; fIndex < e + 1; k++, fIndex++)
            {
                arr[fIndex] = tempArr[k];
            }

        }

~~~~~~持续更新