整理分类C#中常用的排序算法

整理分类C#中常用的排序算法

参考整理的几个算法，后续补充

/*
 * FileName:     SortAlgorithm
 * CreateTime:   2020-06-22 10:43:40
 * Version：     版本
 * Description:
 * 
*/
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// 排序方法
/// 参考：https://zzzjtd.com/4720.html
/// 冒泡和选择排序的区别 参考：https://blog.csdn.net/Ma_xiao_shuai/article/details/101151586
/// </summary>
public class SortAlgorithm : MonoBehaviour
{
    public int[] nums;
    // Start is called before the first frame update
    void Start()
    {
        //nums = SelectionSorter(nums);     //-----选择排序-----
        //nums = EbullitionSorter(nums);    //-----冒泡排序-----
        //nums = QuickSort(nums, 0, 4);     //-----快速排序-----
        //nums = InsertionSorter(nums);     //-----插入排序-----
        nums = ShellSorter(nums);           //-----希尔排序-----
    }

    // Update is called once per frame
    void Update()
    {

    }

    /// <summary>
    /// 选择排序
    /// </summary>
    /// <param name="arr"></param>
    /// <returns></returns>
    public int[] SelectionSorter(int[] arr)
    {
        for (int i = 0; i < arr.Length - 1; ++i)
        {
            for (int j = i + 1; j < arr.Length; ++j)
            {
                if (arr[j] < arr[i])
                {
                    int t = arr[j];
                    arr[j] = arr[i];
                    arr[i] = t;
                }

            }

        }
        return arr;
    }

    /// <summary>
    /// 冒泡排序
    /// </summary>
    /// <param name="arr"></param>
    /// <returns></returns>
    public int[] EbullitionSorter(int[] arr)
    {
        int i, temp;
        for (int j = 1; j < arr.Length; j++)
        {
            for (i = 0; i < arr.Length - j; i++)
            {
                if (arr[i] > arr[i + 1])
                {
                    temp = arr[i];
                    arr[i] = arr[i + 1];//交流数据
                    arr[i + 1] = temp;
                }
            }
        }
        return arr;
        #region 冒泡原型
        //public int[] Sort(int[] arr)
        //{
        //    int i, j, temp;
        //    bool done = false;
        //    j = 1;
        //    while ((j < arr.Length) && (!done))//判别长度
        //    {
        //        done = true;
        //        for (i = 0; i < arr.Length - j; i++)
        //        {
        //            if (arr[i] > arr[i + 1])
        //            {
        //                done = false;
        //                temp = arr[i];
        //                arr[i] = arr[i + 1];//交流数据
        //                arr[i + 1] = temp;
        //            }
        //        }
        //        j++;
        //    }
        //    return arr;
        //}
        #endregion
    }

    #region 快速排序 参考https://blog.csdn.net/wangxufa/article/details/84728833
    /// <summary>
    /// 快速排序
    /// </summary>
    /// <param name="numbers"></param>
    /// <param name="start"></param>
    /// <param name="end"></param>
    /// <returns></returns>
    public int[] QuickSort(int[] numbers, int start, int end)
    {
        if (numbers == null || numbers.Length <= 0)
        {
            return numbers;
        }

        if (start < 0 || end < 0 || start >= end)
        {
            return numbers;
        }
        int pivort = start;
        int mid = QuickSortPartition(numbers, start, end, pivort);// mid 已经定位
        QuickSort(numbers, start, mid - 1);
        QuickSort(numbers, mid + 1, end);
        return numbers;
    }

    static int QuickSortPartition(int[] numbers, int start, int end, int pivort)
    {
        int pivortValue = numbers[pivort];

        // 置换在数组中位置
        QuickSortSwap(numbers, end, pivort);

        int storeIndex = start;
        // 执行分割操作
        for (int i = start; i <= end - 1; i++)
        {
            if (numbers[i] < pivortValue)
            {
                QuickSortSwap(numbers, i, storeIndex);
                storeIndex++;
            }
        }

        QuickSortSwap(numbers, storeIndex, end);

        return storeIndex;
    }

    static void QuickSortSwap(int[] array, int indexX, int indexY)
    {
        int temp = array[indexX];
        array[indexX] = array[indexY];
        array[indexY] = temp;
    }
    #endregion

    /// <summary>
    /// 插入排序
    /// </summary>
    /// <param name="arr"></param>
    /// <returns></returns>
    public int[] InsertionSorter(int[] arr)
    {
        for (int i = 1; i < arr.Length; i++)
        {
            int t = arr[i];
            int j = i;
            while ((j > 0) && (arr[j - 1] > t))
            {
                arr[j] = arr[j - 1];//交流次第
                --j;
            }
            arr[j] = t;
        }
        return arr;
    }

    /// <summary>
    /// 希尔排序
    /// </summary>
    /// <param name="arr"></param>
    public int[] ShellSorter(int[] arr)
    {
        int inc;
        for (inc = 1; inc <= arr.Length / 9; inc = 3 * inc + 1)
        {

        }
        Debug.Log(inc);
        for (; inc > 0; inc /= 3)
        {
            for (int i = inc + 1; i <= arr.Length; i += inc)
            {
                int t = arr[i - 1];
                int j = i;
                while ((j > inc) && (arr[j - inc - 1] > t))
                {
                    arr[j - 1] = arr[j - inc - 1];//交流数据
                    j -= inc;
                }
                arr[j - 1] = t;
            }
        }
        return arr;
    }
}