各种排序总结

一、冒泡排序
我的理解就是，以从小到大排序为例，就是不停 的将最小的排到前面冒出来，或者把最大的，第二大的，一个一个的冒泡到最后。
1.1、常规冒泡

 int[] array1 = new int[] { 2, 4, 3, 7, 8, 5 };          
    /// <summary>
    /// 冒泡排序,将小的数不停冒泡到前排。
    /// </summary>
    public void BubbleSort1()
    {
        for (int i = 0; i < array1.Length; i++)
        {
            for (int j = i + 1; j < array1.Length; j++)
            {
                if (array1[j] < array1[i])
                {                  
                   Swip(array1, i, j);
                }
            }
        }
        PrintInfo();
    }
  

  public void BubbleSort2()
    {
        for (int i = array1.Length - 1; i > 0; i--)
        {
            for (int j = i - 1; j >= 0; j--)
            {
                if (array1[j] > array1[i])
                {
                    Swip(array1, i, j);
                }
            }
        }
        PrintInfo();
    }

另外一种冒泡

public void BubbleSort2()
    {
        for (int i = array1.Length - 1; i > 0; i--)
        {
            for (int j = 0; j < i; j++)
            {
                if (array1[j] > array1[j + 1])
                {
                    Swip(array1, j, j + 1);
                }
            }
        }

        PrintInfo();
    }

 public void BubbleSort3()
    {
        for (int i = 0; i < array1.Length; i++)
        {
            for (int j = array1.Length - 1; j > i; j--)
            {
                if (array1[j] < array1[j - 1])
                {
                    Swip(array1, j, j - 1);
                }
            }
        }

        PrintInfo();
    }

1.2、改进冒泡

 /// <summary>
    /// 加标志位的排序
    /// </summary>
    public void BubbleSortFlag1()
    {
        bool flag;
        for (int i = array1.Length - 1; i > 0; i--)
        {
            flag = true;
            for (int j = 0; j < i; j++)
            {
                if (array1[j] > array1[j + 1])
                {
                    Swip(array1, j, j + 1);
                    flag = false;
                }
            }
            if (flag)
            {
                Debug.Log("break" + i);
                break;
            }
        }

        PrintInfo();
    }

    public void BubbleSortFlag2()
    {
        bool flag;
        for (int i = 0; i < array1.Length; i++)
        {
            flag = true;
            for (int j = array1.Length - 1; j > i; j--)
            {
                if (array1[j] < array1[j - 1])
                {
                    Swip(array1, j, j - 1);
                    flag = false;
                }
            }

            if (flag)
            {
                break;
            }
        }
        PrintInfo();
    }

二、选择排序
原理就是选择出最大的值放在末尾，或者是找到最小的放在开头。时间复杂度是（o(n2)）

 /// <summary>
    /// 选择排序
    /// </summary>
    int min;
    public void SelectSort()
    {
        for (int i = 0; i < array1.Length; i++)
        {
            min = i;
            temp = array1[i];
            for (int j = i + 1; j < array1.Length; j++)
            {
                if (array1[j] < array1[i])
                {
                    min = j;
                    temp = array1[j];
                }
            }
            if (min != i)
            {
                Swip(array1, min, i);
            }
        }
        PrintInfo();
    }

三、插入排序
插入排序是一种对于有序数列高效的排序。非常聪明的排序。只是对于随机数列，效率一般，交换的频率高。

 public void InsertSort()
    {
        int temp;
        for (int i = 0; i < array1.Length; i++)
        {
            temp = array1[i];//7

            for (int j = i - 1; j >= 0; j--)
            {

                if (array1[j] > temp)
                {
                    array1[j + 1] = array1[j];
                    if (j == 0)
                    {
                        array1[0] = temp;
                        break;
                    }

                }
                else
                {
                    array1[j + 1] = temp;
                    break;
                }
            }
        }
    }

用二分法优化的插入排序

 public void InsertSortWithBinary()
    {
        int temp;
        int tempIndex;
        for (int i = 0; i < array1.Length; i++)
        {
            temp = array1[i];
            tempIndex = BinarySearch(array1, 0, i, i);
            for (int j = i - 1; j >= tempIndex; j--)
            {
                array1[j + 1] = array1[j];
            }
            array1[tempIndex] = temp;
        }
        PrintInfo();
    }
    public int BinarySearch(int[] arr, int low, int high, int index)
    {
        if (low >= arr.Length - 1) return arr.Length - 1;
        if (high <= 0) return 0;
        int mid = (low + high) / 2;
        if (mid == index) return mid;

        if (arr[index] > arr[mid])
        {
            if (arr[index] < arr[mid + 1])
            {
                return mid + 1;
            }
            return BinarySearch(arr, mid + 1, high, index);
        }
        else
        {
            if (mid - 1 < 0) return 0;
            if (arr[index] > arr[mid - 1])
            {
                return mid;
            }
            return BinarySearch(arr, low, mid - 1, index);
        }
    }

其他方法

  int t;
    public void Swip(int[] a, int i, int j)
    {
        t = a[i];
        a[i] = a[j];
        a[j] = t;
    }

    private void PrintInfo()
    {
        for (int k = 0; k < array1.Length; k++)
        {
            Debug.Log("" + array1[k]);
        }
    }

快速算法

private void Test()
    {
        int[] arr = { 15, 22, 35, 9, 16, 33, 15, 23, 68, 1, 33, 25, 14 }; //待排序数组                                                                       
        QuickSort(arr, 0, arr.Length - 1);  //调用快速排序函数。传值(要排序数组，基准值位置，数组长度)

    }
    private static void QuickSort(int[] arr, int begin, int end)
    {
        if (begin >= end) return;   //两个指针重合就返回，结束调用
        int pivotIndex = QuickSort_Once(arr, begin, end);  //会得到一个基准值下标

        QuickSort(arr, begin, pivotIndex - 1);  //对基准的左端进行排序  递归
        QuickSort(arr, pivotIndex + 1, end);   //对基准的右端进行排序  递归
    }
    private static int QuickSort_Once(int[] arr, int begin, int end)
    {
        int pivot = arr[begin];   //将首元素作为基准
        int i = begin;
        int j = end;
        //15, 22, 35, 9, 16, 33, 15, 23, 68, 1, 33, 25, 14
        //15 j=12 i=1
        //14, 22, 35, 9, 16, 33, 15, 23, 68, 1, 33, 25, 22
        //15 j=9,i=2,
        //14, 1, 35, 9, 16, 33, 15, 23, 68, 35, 33, 25, 22
        //15 j=3
        //14, 1, 9, 15, 16, 33, 15, 23, 68, 35, 33, 25, 22
     

        while (i < j)
        {
            while (arr[j] >= pivot && i < j)  //从右到左，寻找第一个小于基准pivot的元素
            {
                j--; //指针向前移
            }
            arr[i] = arr[j];  //执行到此，j已指向从右端起第一个小于基准pivot的元素，执行替换


            while (arr[i] <= pivot && i < j) //从左到右，寻找首个大于基准pivot的元素
            {
                i++; //指针向后移
            }
            arr[j] = arr[i];  //执行到此,i已指向从左端起首个大于基准pivot的元素，执行替换
            Debug.Log($"i={i},j={j},pivot={pivot}");
            StringBuilder str_1 = new StringBuilder();
            foreach (var item in arr)
            {
                str_1.Append(item + ",");
            }
            Debug.Log(str_1);
        }

        Debug.Log("------------------------------------------------------");
        StringBuilder str = new StringBuilder();
        foreach (var item in arr)
        {
            str.Append(item + ",");         
        }
        Debug.Log(str);

        //退出while循环,执行至此，必定是 i= j的情况（最后两个指针会碰头）
        //i(或j)所指向的既是基准位置，定位该趟的基准并将该基准位置返回
        arr[i] = pivot;
        return i;
    }