写的一些排序算法

 //选择排序
        public class SelectSort {
            public static int[] selectSort (int[] a) {
                int n = a.Length;
                for(int i=0;i<n-1;i++)
                {
                    int min = i;
                    for (int j = i + 1; j < n; j++)
                    {
                        if (a[min] > a[j])
                        { min = j; }

                    }int temp = a[i];
                    a[i] = a[min];
                    a[min] = temp;
                }return a;
            }
                              }
        //性质：1、时间复杂度：O(n2) 2、空间复杂度：O(1) 3、非稳定排序 4、原地排序

        //插入排序
        public class InsertSort
        {
            public static int[] insertSort (int[] arr) {
                if (arr == null || arr.Length < 2)
                    return  arr;
                for (int i = 1; i < arr.Length; i++)
                {
                    int temp = arr[i];int k = i - 1;
                    while (k >= 0 && temp > arr[k])
                        k--;
                    for (int j = i; j > k + 1; j--)
                    {
                        arr[j] = arr[j - 1];
                    }
                    arr[k + 1] = temp;

                }
                return arr;

           }
       
        }
        //  性质：1、时间复杂度：O(n2) 2、空间复杂度：O(1) 3、稳定排序 4、原地排序

        //冒泡排序
        public class BubbleSort {
            public static int[] bubbleSort(int[] arr)
            {
                if (arr.Length < 2 || arr == null)
                { return arr; }
                int n = arr.Length;
                for (int i = 0; i < n; i++)
                {
                    Boolean flag = true;
                    for(int j=1;j<n-i-1;j++)
                    {
                        if (arr[j] > arr[j + 1])
                        {
                            flag = false;
                            int temp = arr[j];
                            arr[j] = arr[j + 1];
                            arr[j + 1] = temp;
                           

                                }

                    }
                    if (flag == true)
                     break; 

                }
                return arr;

            }
        }
        //性质：1、时间复杂度：O(n2) 2、空间复杂度：O(1) 3、稳定排序 4、原地排序

        //希尔排序
        public class ShellSort {
            public static int[] shellSort(int[] arr)
            {
                if (arr == null && arr.Length < 2)
                return arr;
                int n = arr.Length;
                for (int h = n / 2; h > 0; h /= 2)//分组
                {
                    for (int i = h; i < n; i++)
                    {
                        insertI(arr, h, i);
                    }
                }
                return arr;

            }
        }
        //在每个分组中插入排序，排序不是一个分组一个分组来的，是轮流插入排序，这是方法
       private static void insertI(int[] arr, int h, int i)
        {
            int temp = arr[i]; int k;
            
            for ( k = i - h; k >= 0 && arr[k] > temp; k -= h)
            {
                arr[k + h] = arr[k];
            }
            arr[k + h] = temp;
        }
        // 1、时间复杂度：O(nlogn) 2、空间复杂度：O(1) 3、非稳定排序 4、原地排序

        //归并排序
        private static void mergeSort(int[] arr, int[] temp, int left, int right)
        {    //递归函数，当left=right时候，就是递归到每一个数组都只有一个元素了，就会停止递归了

            if (left < right)
            {
                int center = left + (right - left) / 2;
                mergeSort(arr, temp, left, center);
                mergeSort(arr, temp, center + 1, right);
                merge(arr, temp, left, center,right);
            }
               
        }
        private static void merge(int[] arr, int[] temp, int left, int center, int right)
        {
            int i = left;int j = center + 1;
            for (int k = left; k<=right; k++)
            {
                if (i > center) { temp[k] = arr[j++]; }
                else if (j > center) { temp[k] = arr[i++]; }
                else if (arr[i] < arr[j]) { temp[k] = arr[i++]; }
                else { temp[k] = arr[j++]; }

            }
            for (int k = left; k <= right; k++)
            { arr[k] = temp[k]; }

        }

        //计数排序（计数排序的优点，无论是快速排序，希尔排序，冒泡排序，选择排序，都是依靠元素间的比较进行比较，计数排序是根据数组下标确定元素的正确位置）
        //适用于一定范围的整数排序。在取值范围不是很大的情况下，它的性能甚至快过那些0（nlogn）的排序
        public static int[] countSort(int[] arr)
        {   if (arr == null || arr.Length < 2) return arr;
            int max = arr[0];int min = arr[0];
            for (int i = 0; i < arr.Length; i++)
            {
                if (max > arr[i])
                { max = arr[i]; }
                if (min < arr[i])
                { min = arr[i]; }
            }
            int leng = max - min + 1;
            int[] temp = new int[leng];
            for (int j = 0; j < arr.Length; j++)
            {
                temp[arr[j]-min]++;
            }
            int k = 0;
            for (int a = 0; a < leng; a++)
            {
                for (int b = temp[a]; b > 0; b--)
                {
                    arr[k++] = b+min;    //记得加上min
                }
            }
            return arr;

        }

        //能确立顺序的计数排序（之前的只是简单的输出元素，并没有真正的排序，无法判别相同元素的顺序）
        public static int[] countSort1(int[] arr)
        {
            int max = arr[0]; int min = arr[0];
            int lena = arr.Length;
            for (int i = 0; i < lena; i++)
            {
                if (max > arr[i])
                {
                    max = arr[i];
                }
                if (min < arr[i])
                {
                    min = arr[i];
                }
            }

            int d = max - min;
            int[] countarr = new int[d + 1];
            for (int i = 0; i < lena; i++)
            {
                countarr[arr[i]-min]++;
            }

            int sum = 0;
            for (int i = 0; i < countarr.Length; i++)
            {
                sum += countarr[i];  //为什么这里不是arr[i]-min；是因为arr[i]没有排序，所以对应的不会是从0开始，countarr[]是排序好了的数组
                countarr[i] = sum;
            }

            int[] copyarr = new int[lena];
            for (int i = lena - 1; i >= 0; i--)   //倒序遍历；不用正序是因为sum的原因，正序countarr对应的sum对不上
            {
                copyarr[countarr[arr[i] - min]-1] = arr[i];   //把arr的每个值排列放进copyarr中，copyarr就是确立顺序的数组了
                countarr[arr[i] - min]--;
            }
            return copyarr;
        }
     

1、时间复杂度：O(n+k) 2、空间复杂度：O(k) 3、稳定排序 4、非原地排序

计数排序的限制条件：

1.当数列最大最小值差距过大时，并不适用计数排序。就如1跟10000000，这样差太大了用计数排序浪费内存空间。

2.当数列元素不是整数，并不适用计数排序。  如1.1，1.2这些，因为创立不了数组所以也排不了序

        //二分查找代码
        private static int binarySearch(int[] arr, int key)
        {
            int low = 0;
            int high = arr.Length-1;
            int mid;
            while (low <= high)
            {
                mid = low + (high - low) / 2;
                int temp = arr[mid];
                if (key < temp)
                { high = mid - 1; }
                else if (key > temp)
                { low = mid + 1; }
                else { return mid; }
            }
               return -1;

       }

 

   我是慢雨，感谢你的浏览！！