C#——排序算法

冒泡排序

public static void BubbleSort(int[] nums){
        if(nums.Length<=0)return;
        int len = nums.Length;
        for(int i=0;i<len-1;i++){
            for(int j=i+1;j<len;j++){
                if(nums[j]<nums[i]){
                    Swap(nums,i,j);
                }
            }
        }
    }

选择排序

public static void SelectSort(int[] nums){
        int len = nums.Length;
        if(len<=1)return;
        int minIndex = 0;
        for(int i=0;i<len-1;i++){
            minIndex = i;
            for(int j=i+1;j<len;j++){
                if(nums[j]<nums[minIndex]){
                    minIndex = j;
                }
            }
            if(minIndex!=i){
                Swap(nums,i,minIndex);
            }
        }
    }

简单插入排序

public static void InsertSort(int[] nums){
        int len = nums.Length;
        if(len<=1)return;
        
        for(int i=1;i<len;i++){
            int j=i;
            int target = nums[i];
            while(j>0&&target<nums[j-1]){
                nums[j] = nums[j-1];
                j--;
            }
            nums[j] = target;
        }
    }

快速排序

public static void QuickSort(int[] nums,int left,int right){
        if(left>=right)return;
        int i = Partition(nums,left,right);
        QuickSort(nums,left,i-1);
        QuickSort(nums,i+1,right);
    }

快速排序的一次划分

public static int Partition(int[] nums,int left,int right){
        int target = nums[left];
        while(left<right){
            while(left<right&&nums[right]>=target){
                right--;
            }
            nums[left] = nums[right];
            while(left<right&&nums[left]<=target){
                left++;
            }
            nums[right] = nums[left];
        }
        nums[left] = target;
        return left;
    }

堆排序

public static void HeapSort(int[] nums){
        int len = nums.Length;
        //建堆
        for(int i=len/2-1;i>=0;i--){
            HeapAdjust(nums,i,len);
        }
        //移动元素
        for(int i=len-1;i>0;i--){
            Swap(nums,0,i);
            HeapAdjust(nums,0,i);
        }   
    }   

调整以parentIndex为结点，长度为length的数组为大根堆

public static void HeapAdjust(int[] nums,int parentIndex,int length){
        int target = nums[parentIndex];
        int childrenIndex = 2 * parentIndex + 1;
        while(childrenIndex < length){
            if(childrenIndex + 1 < length && nums[childrenIndex+1]>nums[childrenIndex]){
                childrenIndex++;
            }
            if(target>nums[childrenIndex]){
                break;
            }
            nums[parentIndex] = nums[childrenIndex];
            parentIndex = childrenIndex;
            childrenIndex = 2 * childrenIndex + 1;
        }
        nums[parentIndex] = target;
    }

归并排序

public static void MergeSort(int[] nums,int left,int right){
        if(left>=right)return;
        int mid = (left+right)/2;
        MergeSort(nums,left,mid);
        MergeSort(nums,mid+1,right);
        Merge(nums,left,mid,right);
    }

合并数组

public static void Merge(int[] nums,int left,int mid,int right){
        int[] ans = new int[right-left+1];
        int i=left;
        int j=mid+1;
        int k = 0;
        while(i<=mid&&j<=right){
            if(nums[i]<nums[j]){
                ans[k++] = nums[i++];
            }
            else{
                ans[k++] = nums[j++];
            }
        }
        while(i<=mid){
            ans[k++] = nums[i++];
        }
        while(j<=right){
            ans[k++] = nums[j++];
        }
        for(int index = 0;index<k;index++){
            nums[left + index] = ans[index];
        }
    }

希尔排序

public static void ShellSort(int[] nums){
        int len = nums.Length;
        if(len<=1)return;
        while(len>=1){
            ShellSub(nums,len/=2);            
        }
    }

以增量为d进行希尔排序

public static void ShellSub(int[] nums,int d){
        int len = nums.Length;
        for(int i=d;i<len;i++){
            int j = i-d;
            int target = nums[i];
            while(j>=0&&nums[j]>target){
                nums[j+d] = nums[j];
                j-=d;
            }
            if(j!=i-d){
                nums[j+d] = target;
            }          
        }
    }

计数排序

public static void CountSort(int[] nums){
        int len = nums.Length;
        if(len<=1)return;
        int max = GetMax(nums);                
        int[] count = new int[max+1];
        for(int i=0;i<len;i++){
            count[nums[i]]++;
        }
        for(int i=1;i<max+1;i++){
            count[i] += count[i-1];
        }
        int[] ans = new int[len];
        for(int i=len-1;i>=0;i--){
            ans[count[nums[i]]-1] = nums[i];
            count[nums[i]]--;
        }
        for(int i=0;i<len;i++){
            nums[i] = ans[i];
        }
    }

基数排序

public static void RadixSort(string[] strs){
        //获取最大长度,即需要几次排序
        int maxLen = 0;
        for(int i=0;i<strs.Length;i++){
            maxLen = maxLen > strs[i].Length ? maxLen : strs[i].Length;
        }
        int len = strs.Length;//有几个待排序的字符串
        string[] sortedArray = new string[len];//存放每次
        for(int k = maxLen-1;k>=0;k--){
            int[] count = new int[128];//ASCII
            for(int i=0;i<len;i++){
                int ch = GetCharIndex(strs[i],k);
                count[ch]++;
            }
            for(int i=1;i<count.Length;i++){
                count[i] = count[i] + count[i-1];
            }
            for(int i=len-1;i>=0;i--){              
                int ch = GetCharIndex(strs[i],k);
                sortedArray[count[ch]-1] = strs[i];
                count[ch]--;
            }
            for(int i=0;i<len;i++){
                strs[i] = sortedArray[i];
            }
        }  
    }

返回str的第k个字符

public static int GetCharIndex(string s,int k){
        if(k>s.Length-1){
            return 0;
        }
        return s[k];
    } 

桶排序

public static void BucketSort(double[] nums){
        double min = nums[0];
        double max = nums[0];
        int len = nums.Length;
        for(int i = 1;i<len;i++){
            min = min<nums[i]?min:nums[i];
            max = max>nums[i]?max:nums[i];
        }
        double d = max - min;
        List<List<double>> bucket = new List<List<double>>();
        int bucketNum = len;
        for(int i=0;i<bucketNum;i++){
            bucket.Add(new List<double>());
        }
        for(int i=0;i<len;i++){
            int index = (int)((nums[i] - min) * (bucketNum-1)/d);
            bucket[index].Add(nums[i]);
        }
        for(int i=0;i<bucketNum;i++){
            //对桶插入排序
            //InsertSortList(bucket[i]);
            bucket[i].Sort();
        }
        int k=0;
        for(int i=0;i<bucketNum;i++){
            List<double> list = bucket[i];
            foreach(var item in list){
                nums[k++] = item;
            }
        }
    }

辅助函数

交换数组两个元素

public static void Swap(int[] nums,int i,int j){
        int temp = nums[j];
        nums[j] = nums[i];
        nums[i] = temp;
    }

获得数组最大值

public static int GetMax(int[] nums){
        int ans = nums[0];
        for(int i=1;i<nums.Length;i++){
            if(nums[i]>ans){
                ans = nums[i];
            }
        }
        return ans;
    }