几种简单的排序算法

直接上代码吧！比简单只是太长时间不怎么写排序算法了，想着没事写写，温故而知新

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// 简单排序算法
/// </summary>
public class BubbleSort : MonoBehaviour {
    int[] number0 = new int[10] {5,10,4,8,6,7,44,56,45,11 };

    private void Start()
    {
        int[] b = sort(number0);
        for (int i = 0; i < b.Length; i++)
        {
            Debug.Log(b[i]);
        }
    }

    /// <summary>
    /// 冒泡排序
    /// </summary>
    /// <param name="n"></param>
    /// <returns></returns>
    public int[] sort(int[] n)
    {
        int[] returnnumber = n;
        for (int i = 0; i < n.Length-1; i++)
        {
            for (int j = 0; j < n.Length-1-i; j++)
            {
                if (returnnumber[j]>returnnumber[j+1])
                {
                   int a= returnnumber[j];
                   returnnumber[j] = returnnumber[j+1];
                   returnnumber[j+1] = a;
                }
            }
        }
        return returnnumber;
    }


    /// <summary>
    /// 选择排序 （从数组中找到最小元素和当前比较的元素互换）
    /// </summary>
    /// <returns></returns>
    public int[] SelectionSort(int[] n)
    {
        int[] number=n;
        for (int i = 0; i < number.Length-1; i++)
        {
            int minPos = i;
            for (int j = i; j < number.Length; j++)
            {
                if (number[j]<number[minPos])
                {
                    minPos = j;//找出当前最小元素的位置
                }
            }
            if (number[minPos]!=number[i])//如果最小元素与当前位置的元素不相等则交换位置
            {
                int temp = number[minPos];
                number[minPos] = number[i];
                number[i] = temp;
            }
        }
        return number;
    }

    //由选择排序衍生数来的排序算法   双向选择排序（每次循环，同时选出最大值放在末尾，最小值放在前方）
    /// <summary>
    ///  双向选择排序（每次循环，同时选出最大值放在末尾，最小值放在前方）
    /// </summary>
    /// <param name="n"></param>
    /// <returns></returns>
    public int[] BothwaySelectionSort(int[] n)
    {
        int[] number = n;
        for (int i = 0; i < number.Length/2-1; i++)
        {
            int minpos = i, maxpos = number.Length - i - 1;
            for (int j = i; j < number.Length-i; j++)
            {
                if (number[j]<number[minpos])
                {
                    minpos = j;
                }

                if (number[maxpos]<number[j])
                {
                    maxpos = j;
                }
            }
            if (i!=minpos)
            {
                swap(number,i,minpos);
            }

            if (maxpos!=number.Length-i-1)
            {
                if (maxpos==i)若当前最大值在循环起始位置，则最大值一定在(1)处被交换到了minPos的位置
                {
                    maxpos = minpos;
                }
                swap(number,maxpos,number.Length-i-1);
            }
        }
        return number;
    }

    /// <summary>
    /// 两数互相交换函数
    /// </summary>
    /// <param name="arr"></param>
    /// <param name="a"></param>
    /// <param name="b"></param>
    public static void swap(int[] arr, int a, int b)
    {

        int temp = arr[a];

        arr[a] = arr[b];

        arr[b] = temp;

    }


    /// <summary>
    /// 插入排序算法  （从第二个开始对比插入）
    /// </summary>
    /// <param name="n"></param>
    /// <returns></returns>
    public int[] Insertion(int[] n)
    {
        int pos, temp;
        int[] number = n;
        for (int i = 1; i < number.Length; i++)
        {
            pos = i;
            while (pos!=0&&number[pos]<number[pos-1])
            {
                temp = number[pos];
                number[pos] = number[pos - 1];
                number[pos - 1] = temp;
                pos--;
            }
        }
        return number;
    }


    /// <summary>
    /// 鸡尾酒排序
    /// 鸡尾酒是冒泡排序的升级版，该排序从左往右找出最大值后，再从右往左
    ///找出最小值，类似鸡尾酒搅拌左右循环。在某些情况下，优于冒泡排序，
    ///以序列(2,3,4,5,1)为例，鸡尾酒排序只需要访问两次（升序降序各一次 ）
    ///次序列就可以完成排序，但如果使用冒泡排序则需要四次。
    /// </summary>
    /// <param name="n"></param>
    public static void CockTailsort(int[] n)
        {

        //依次将最大的数放置到数组末尾，将第二大的数放到倒数第二位...
        int[] number = n;
            bool changed;

            for (int i = 0; i < number.Length / 2; i++)
            {

                changed = false;

                //从前往后,比较相邻两个数,把大的放在后边.之前已放置成功的可以不再参与比较

                for (int j = i; j < number.Length - 1 - i; j++)
                {



                    if (number[j] > number[j + 1])
                    {

                        swap(number, j, j + 1);

                        changed = true;

                    }

                }

                if (!changed)
                {

                    break;

                }

                for (int j = number.Length - 1 - i; j > i; j--)
                {



                    if (number[j] < number[j - 1])
                    {

                        swap(number, j, j - 1);

                        changed = true;

                    }

                }

                if (!changed)
                {

                    break;

                }

            }

        }


 }