Révision des connaissances de base C# - 21. Tri par fusion

Si vous comprenez la logique récursive
        et n'exécutez pas la fonction de tri au début , vous
        devez d'abord trouver le tableau de plus petite capacité avant
        de revenir à l'appel récursif de Sort pour le tri.

Principe de base de
        la fusion = récursion + fusion
        de tableaux en éléments gauche et
        droit, en les comparant lorsqu'un
        côté est épuisé et en les plaçant du côté opposé,
        et en ajoutant constamment de nouveaux tableaux

        Répétez sans vous arrêter
        jusqu'à ce que les points soient divisés, puis triés et triés
        . Une fois le tri terminé, montez
        et fusionnez en marchant
        jusqu'à atteindre le sommet de la tête pour obtenir le résultat.

Méthode d'écriture de routine
        : deux fonctions,
        une règle de tri de base
        et un tableau de bissection récursif

Notez que la fonction de classement         est appelée return à l'intérieur
        de la fonction de tableau bissecteur

 private void Start()
    {
        int[] arr = new int[] { 8, 7, 1, 5, 4, 2, 6, 3, 9 };
        arr = Merge(arr);
        for (int i = 0; i < arr.Length; i++)
        {
            print(arr[i]);
        }
    }
    //第一步
    //基本排序规则
    //左右元素相比较
    //满足条件放进去
    //一侧用完直接放
    public int[] Sort(int[] left, int[] right)
    {
        //新数组存放排序后的元素
        int[] arry = new int[left.Length + right.Length];
        //分隔后左右数组的索引标识
        int leftindex = 0;
        int rightindex = 0;
        for (int i = 0; i < arry.Length; i++)
        {
            //左侧已经放完了，直接放右边的
            if (leftindex >= left.Length)
            {
                arry[i] = right[rightindex];
                //已经放入一个右侧元素进入新数组
                //标识指向下一个
                rightindex++;
            }
            //右侧已经放完，直接放左边的
            else if(rightindex >= right.Length)
            {
                arry[i] = left[leftindex];
                //已经放入一个左侧元素进入新数组
                //标识指向下一个
                leftindex++;
            }
            else if (left[leftindex] < right[rightindex])
            {
                arry[i] = left[leftindex];
                //已经放入一个左侧元素进入新数组
                //标识指向下一个
                leftindex++;
            }
            else
            {
                arry[i] = right[rightindex];
                //已经放入一个右侧元素进入新数组
                //标识指向下一个
                rightindex++;
            }
        }
        return arry;
    }

    //第二步：
    //递归评分数组
    //结束条件为长度小于2
    public int[] Merge(int[] arry)
    {
        //递归结束条件
        if (arry.Length < 2)
            return arry;
        //1.数组分两段
        int mid = arry.Length / 2;
        //2.初始化左右数组
        int[] left =new int[mid];
        int[] right =new int[arry.Length - mid];
        for (int i = 0; i < arry.Length; i++)
        {
            if (i < mid)
            {
                left[i] = arry[i];
            }
            else
            {
                right[i-mid] = arry[i];
            }
        }
        //3.递归分组再排序
        return Sort(Merge(left),Merge(right));
    }