C#冒泡排序，选择排序，插入排序，快速排序

冒泡排序

平均时间复杂度：O(n²)
平均空间复杂度：O(1)

       private static int[] BubbleSort(int[] arr)
        {
            int size = arr.Length;
            for (int i = 1; i < size; i++)
            {
                for (int j = 0; j < size - i; j++)
                {
                    if (arr[j] > arr[j + 1])
                    {
                        int temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                }
            }
            return arr;
        }

选择排序

平均时间复杂度：O(n²)
平均空间复杂度：O(1)

        private static int[] SelectSort(int[] arr)
        {
            int size = arr.Length;
            for (int i = 0; i < size - 1; i++)
            {
                int k = i;
                for (int j = i + 1; j < size; j++)
                {
                    if (arr[j] < arr[k])
                    {
                        k = j;
                    }
                }
                int temp = arr[i];
                arr[i] = arr[k];
                arr[k] = temp;
            }
            return arr;
        }

插入排序

平均时间复杂度：O(n²)
平均空间复杂度：O(1)

        public static int[] InsertSort(int[] arr)
        {
            int len = arr.Length;
            int tmp;
            int i;
            int j;
            for (i = 1; i < len; i++)
            {
                tmp = arr[i];
                for (j = i - 1; j >= 0 && arr[j] > tmp; j--)
                {
                    arr[j + 1] = arr[j];
                }
                arr[j + 1] = tmp;

            }
            return arr;
        }

快速排序

平均时间复杂度：O(nlogn)
平均空间复杂度：O(logn)

        public static void FastSort(int[] s,int l, int r)
        {
            if (l < r)
            {
                int i = l, j = r, x = s[l];
                while (i < j)
                {
                    while (i < j && s[j] >= x) // 从右向左找第一个小于x的数
                        j--;
                    if (i < j)
                        s[i++] = s[j];

                    while (i < j && s[i] < x) // 从左向右找第一个大于等于x的数
                        i++;
                    if (i < j)
                        s[j--] = s[i];
                }
                s[i] = x;
                FastSort(s, l, i - 1); // 递归调用 
                FastSort(s, i + 1, r);
            }
        }