常用排序算法

上述冒泡排序是不稳定的，选择排序是稳定的
以上是本人总结 下面是摘自大佬
https://blog.csdn.net/xy_learning/article/details/102661938
排序是日常生活中非常普遍的问题，我们每个人都有自己固定的思维模式，而往往这些固定的思维模式都是效率非常低算法，比如选择排序，插入排序和冒泡排序，使我们很容易想到的排序方法（其实我觉得冒泡可能都不会想到）
所以学习别人的高级算法非常有必要，然而真正理解并不是看的懂就行了，也不是写一次代码跑成功就行了，我们需要熟练了知道它算法具体实现的程序中，每一步是在做什么，然后这个算法的时间复杂度、空间复杂度是多少，是否稳定？回答了这些问题，并且时长拿出来写写，最好能够解决一些编程问题，这样就算掌握了。
我的程序中包括了：冒泡排序、插入排序、选择排序、希尔排序、归并排序、计数排序、堆排序和快速排序，并且记录了每个排序算法每次排序后的结果。

using System.Linq;
using static System.Console;
namespace 排序算法总结
{
class Program
{
//冒泡法排序 稳定
static void BubbleSort(int[] arr)
{
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;
}
}
Print(arr);
}
}

    //插入排序 稳定
    static void InsertSort(int[] arr)
    {
        for (int i = 1; i < arr.Length; i++)
        {
            int temp = arr[i];
            int j;
            for ( j = i-1 ; j >= 0; j--)
            {
                if(arr[j] > temp)
                {
                    arr[j + 1] = arr[j];
                }
                else { break; }
            }
            arr[j + 1] = temp;
            Print(arr);
        }
    }

    //选择排序 不稳定
    static void SelectionSort(int[] arr)
    {
        for (int i = 0; i < arr.Length; i++)
        {
            int minIndex = i;
            int min = arr[i];
            for (int j = i+1; j < arr.Length; j++)
            {
                if(arr[j] < min)
                {
                    min = arr[j];
                    minIndex = j;
                }
            }
            arr[minIndex] = arr[i];
            arr[i] = min;
            Print(arr);
        }
    }

    //希尔排序  不稳定
    static void ShellSort(int[] arr)
    {
        int N = arr.Length;
        for (int gap = N/2; gap > 0; gap /= 2 )
        {
            for (int i = gap; i < N; i++)
            {
                shellsort(arr, gap, i);
            }
        }
    }
    static void shellsort(int[] arr,int gap,int i)
    {
        int temp = arr[i];
        int j;
        for (j = i -gap;  j >= 0; j -= gap)
        {
            if (arr[j] > temp)
            {
                arr[j + gap] = arr[j];
            }
            else
            {
                break;
            }
        }
        arr[j + gap] = temp;
        Print(arr);
    }

    //归并排序 稳定
    //需要O（n）额外空间
    static void MergeSort(int[] arr)
    {
        int[] temp = new int[arr.Length];
        mergesort(arr, 0, arr.Length - 1, temp);
    }
    static void mergesort(int[] arr,int min ,int max,int[] temp)
    {
        if(min < max)
        {
            int mid = (min + max) / 2;
            mergesort(arr, min, mid, temp);
            mergesort(arr, mid + 1, max, temp);
            merge(arr, min, mid, max, temp);
        }
        Print(arr);
    }
    static void merge(int[] arr ,int min ,int mid ,int max,int[] temp)
    {
        int i = min;
        int j = mid + 1;
        int k = 0;
        while(i<= mid && j<= max)
        {
            if(arr[i] < arr[j])
            {
                temp[k++] = arr[i++];
            }
            else
            {
                temp[k++] = arr[j++];
            }
        }
        while (i <= mid)
        {
            temp[k++] = arr[i++];
        }
        while (j <= max)
        {
            temp[k++] = arr[j++];
        }
        for (int m = 0; m < k; m++)
        {
            arr[min + m] = temp[m];
        }
    }

    //计数排序(桶排序，哈希排序)
    //两两比较的排序算法时间复杂度极限为O（nlogn）
    //计数排序为O（n）
    static int[] CountingSort(int[] arr)
    {
        int k;
        bool IsMinLessThan0 = false;
        if (arr.Min() < 0)
        {
            k = arr.Max() - arr.Min() + 1;
            IsMinLessThan0 = true;
        }
        else
        {
            k = arr.Max() + 1;
            IsMinLessThan0 = false;
        }
        int[] output = new int[arr.Length];
        int[] temp = new int[k];

        for (int i = 0; i < arr.Length; i++)
        {
            temp[arr[i]]++;
        }
        for (int i = 1; i < k; i++)
        {
            temp[i] += temp[i - 1];
        }
        for (int i = arr.Length-1; i >0; i--)
        {
            int a = arr[i];
            if (IsMinLessThan0)
            {
                output[temp[a] - 1] = a + arr.Min(); ;
            }
            else
            {
                output[temp[a] - 1] = a;
            }
            temp[a]--;
        }
        return output;
    }

    //快速排序 不稳定
    static void QuickSort(int[] arr)
    {
        quicksort( arr,0,arr.Length-1);
    }
    static void quicksort(int[] arr,int left,int right)
    {
        if (left < right)
        {
            int mid = arr[(left + right) / 2];
            int i = left - 1;
            int j = right + 1;
            while (true)
            {
                while (arr[++i] < mid) ;
                while (arr[--j] > mid) ;
                if (i >= j)
                {
                    break;
                }
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
                Print(arr);
            }
            quicksort(arr, left, i - 1);
            quicksort(arr, j + 1, right);
        }
    }

    //堆排序 不稳定
    static void HeapSort(int[] arr)
    {
        //初始化堆，O（n）
        for (int i = arr.Length/2-1; i >=0; i--)
        {
            AdjustHeap(arr, i, arr.Length - 1);
        }
        //n次交换位置并调整堆，每次调整堆O（logn）
        for (int i = arr.Length-1; i >0; i--)
        {
            var temp = arr[i];
            arr[i] = arr[0];
            arr[0] = temp;
            Print(arr);
            AdjustHeap(arr, 0, i - 1);
        }
        //总的时间复杂度是O（n）+O（nlogn）也就是O（nlogn）
    }
    static void AdjustHeap(int[] arr,int m ,int n)
    {
        var t = arr[m];
        for (int i = 2*m+1; i <= n; i = 2*i+1)
        {
            if( i<n && arr[i+1] > arr[i])
            {
                i++;
            }
            if(t >= arr[i])
            {
                break;
            }
            arr[m] = arr[i];
            m = i;
        }
        arr[m] = t;
    }

    //初始化数组
    static int[] Init()
    {
        int[] arr = { 7,1,5,2,4,9,8};
        return arr;
    }

    //打印数组每次输出的值
    static void Print(int[] arr)
    {
        for (int i = 0; i < arr.Length; i++)
        {
            Write(arr[i] + " ");
        }
        WriteLine();
    }

    static void Main(string[] args)
    {
        int[] arr;
        arr = Init();
        WriteLine("冒泡法排序");
        BubbleSort(arr);
        WriteLine();

        arr = Init();
        WriteLine("选择排序");
        SelectionSort(arr);
        WriteLine();

        arr = Init();
        WriteLine("插入排序");
        InsertSort(arr);
        WriteLine();

        arr = Init();
        WriteLine("希尔排序");
        ShellSort(arr);
        WriteLine();

        arr = Init();
        WriteLine("归并排序");
        MergeSort(arr);
        WriteLine();

        arr = Init();
        WriteLine("堆排序");
        HeapSort(arr);
        WriteLine();

        arr = Init();
        WriteLine("快速排序");
        QuickSort(arr);
        WriteLine();
    }
}

}