常用的排序算法

冒泡，选择，插入，快速，希尔

	int[] list = {7,5,6,3,9,4,1};
    void Start()
    {
        //BubbleSort();
        //SelectSort();
        //InsertSort();
        //QuickSort(0, list.Length - 1);
        HillSort();
        foreach (var item in list)
        {
            Debug.Log(item);
        }
    }

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

    }
    /// <summary>
    /// 冒泡排序(从小到大)
    /// </summary>
    public void BubbleSort()
    {
        for (int i = 0; i < list.Length; i++)
        {

            for (int j = 0; j < list.Length - 1 - i; j++)
            {
                if (list[j] > list[j + 1])
                {
                    int temp=list[j];
                    list[j] = list[j + 1];
                    list[j + 1] = temp;
                }
            }
        }
    }
    /// <summary>
    /// 选择排序(从小到大)
    /// 1. 从左至右遍历，找到最小(大)的元素，然后与第一个元素交换。
    /// 2. 从剩余未排序元素中继续寻找最小（大）元素，然后与第二个元素进行交换。
    /// 3. 以此类推，直到所有元素均排序完毕。
    /// </summary>
    public void SelectSort()
    {
        for (int i = 0; i < list.Length; i++)
        {
            int min=i;
            for (int j = i + 1; j < list.Length; j++)
            {
                if (list[min] > list[j])
                {
                    min = j;
                }
            }
            int temp=list[i];
            list[i] = list[min];
            list[min] = temp;

        }
    }
    /// <summary>
    /// 插入排序(从小到大)
    /// 1.从第一个元素开始，该元素可以认为已经被排序
    /// 2.取出下一个元素，在已经排序的元素序列中从后向前扫描
    /// 3.如果该元素小于前面的元素（已排序），则依次与前面元素进行比较如果小于则交换，直到找到大于该元素的就则停止；
    /// 4.如果该元素大于前面的元素（已排序），则重复步骤2
    /// </summary>
    public void InsertSort()
    {
        for (int i = 1; i < list.Length; i++)
        {
            for (int j = i; j > 0; j--)
            {
                if (list[j] < list[j - 1])
                {
                    int temp=list[j-1];
                    list[j - 1] = list[j];
                    list[j] = temp;
                }
                else
                {
                    break;
                }
            }
        }
    }

    /// <summary>
    /// 快速排序
    /// 1．i =L; j = R; 将基准数x挖出形成第一个坑a[i]
    /// 2．j--由后向前找比基准数小的数，找到后挖出此数填入前一个坑a[i] 中
    /// 3．i++由前向后找比基准数大的数，找到后也挖出此数填到前一个坑a[j] 中
    /// 4．再重复执行2，3二步，直到i==j，将基准数填入a[i] 中
    /// </summary>
    public void QuickSort(int left, int right)
    {
        if (left < right)
        {
            int i=left;
            int j=right;
            int x=list[i];
            while (i < j)
            {
                while (i < j && list[j] >= x)
                {
                    j--;
                }
                if (i < j)
                {
                    list[i] = list[j];
                    i++;
                }
                while (i < j && list[i] < x)
                {
                    i++;
                }
                if (i < j)
                {
                    list[j] = list[i];
                    j--;
                }
            }
            list[i] = x;
            QuickSort(left, i - 1);
            QuickSort(i + 1, right);
        }
    }
    /// <summary>
    /// 希尔排序
    /// </summary>
    public void HillSort()
    {
        int length = list.Length;
        for (int h = length / 2; h > 0; h = h / 2)
        {
            for (int i = h; i < length; i++)
            {
                int temp = list[i];
                if (temp< list[i - h])
                {
                    for (int j = 0; j < i; j += h)
                    {
                        if (temp<list[j])
                        {
                            temp = list[j];
                            list[j] = list[i];
                            list[i] = temp;
                        }
                    }
                }
            }
        }
    }