常用的六种排序代码，基于C#

一、冒泡排序

	//冒泡
    private void MaoPao(SortNum[] newArray)
    {
        int count = 0;
        SortNum[] clone = newArray;
        for(int i = 0; i < clone.Length; i++)
        {
            for(int j = 1; j < clone.Length; j++)
            {
                count++;
                if (j == 0)
                {
                    continue;
                }

                if(clone[j].num < clone[j - 1].num)
                {
                    Swap(newArray, clone[j], clone[j - 1]);
                }
            }
        }

        Print("oldArray== ", array);
        Print("newArray== ", clone);
        Debug.Log($"循环了{count}次");
    }

二、选择排序

    //选择
    private void XuanZe(int[] newArray)
    {
        int count = 0;
        for (int i = 0; i < newArray.Length; i++)
        {
            int min = newArray[i];
            for (int j = i; j < newArray.Length; j++)
            {
                count++;
                if (j == 0)
                {
                    continue;
                }

                if(newArray[j] < min)
                {
                    min = newArray[j];
                }
            }

            if(min < newArray[i])
            {
                SwapInt(ref newArray[i], ref min);
            }
        }

        //Print("oldArray== ", array);
        //Print("newArray== ", newArray);
        Debug.Log($"循环了{count}次");
    }

三、插入排序

    //插入
    private void ChaRu(SortNum[] newArray)
    {
        int count = 0;
        for(int i = 0; i < newArray.Length; i++)
        {
            for(int j = i; j > 0; j--)
            {
                count++;
                if (newArray[j].num < newArray[j - 1].num)
                {
                    Swap(newArray, newArray[j], newArray[j - 1]);
                }
                else
                {
                    break;
                }
            }
        }

        Print("旧数组：", array);
        Print("插入排序：", newArray);
        Debug.Log($"循环了{count}次");
    }

四、希尔排序

    //希尔
    private void XiEr(SortNum[] newArray)
    {
        int count = 0;

        for(int step = newArray.Length / 2; step >= 1; step /= 2)
        {
            for(int i = step; i < newArray.Length; i++)
            {
                for(int j = i; j - step >= 0; j -= step)
                {
                    count++;
                    if(newArray[j].num < newArray[j - step].num)
                    {
                        Swap(newArray, newArray[j], newArray[j - step]);
                    }
                    else
                    {
                        break;
                    }
                }
            }
        }

        Print("旧数组：", array);
        Print("希尔排序：", newArray);
        Debug.Log($"循环了{count}次");
    }

五、归并排序

    //归并
    private void GuiBing(int[] old, int[] newArray)
    {
        int count = 0;
        int[] newArr = ChaiFen(newArray);
        
        int[] ChaiFen(int[] arr)
        {
            if(arr.Length > 1)
            {
                int[] left = new int[arr.Length - arr.Length / 2];
                int[] right = new int[arr.Length / 2];

                for (int i = 0; i < left.Length; i++)
                {
                    left[i] = arr[i];
                }

                for (int i = 0; i < right.Length; i++)
                {
                    right[i] = arr[i + left.Length];
                }

                left = ChaiFen(left);
                right = ChaiFen(right);

                int[] arr2 = new int[left.Length + right.Length];
                int lIndex = 0, rIndex = 0;

                for (int i = 0; i < arr2.Length; i++)
                {
                    count++;
                    if (rIndex == right.Length)
                    {
                        arr2[i] = left[lIndex];
                        lIndex++;
                        continue;
                    }
                    else if (lIndex == left.Length)
                    {
                        arr2[i] = right[rIndex];
                        rIndex++;
                        continue;
                    }

                    if (right[rIndex] < left[lIndex])
                    {
                        arr2[i] = right[rIndex];
                        rIndex++;
                    }
                    else
                    {
                        arr2[i] = left[lIndex];
                        lIndex++;
                    }
                }

                return arr2;
            }
            else
            {
                return arr;
            }
        }

        PrintInt("旧数组：", old);
        PrintInt("归并排序：", newArr);
        Debug.Log($"循环了{count}次");
    }

六、快速排序

    //快速
    private void KuaiSu(int[] old, int[] newArray)
    {
        int count = 0;
        int[] newAr = sort(newArray);


        int[] sort(int[] arr)
        {
            if(arr.Length <= 1)
            {
                return arr;
            }

            if(arr.Length == 2)
            {
                if(arr[0] > arr[1])
                {
                    SwapInt(ref arr[0], ref arr[1]);
                }
                return arr;
            }

            int baseNum = arr[0];
            int i = 0;
            int j = arr.Length - 1;
            while(i < j)
            {
                while (arr[j] >= baseNum)
                {
                    count++;
                    j--;
                    if (i >= j)
                    {
                        break;
                    }
                }

                if (i >= j)
                {
                    break;
                }

                if (arr[j] < baseNum)
                {
                    arr[i] = arr[j];
                    i++;
                }

                if (i >= j)
                {
                    break;
                }

                while (arr[i] <= baseNum)
                {
                    count++;
                    i++;
                    if (i >= j)
                    {
                        break;
                    }
                }

                if (arr[i] > baseNum)
                {
                    arr[j] = arr[i];
                    j--;
                }
            }

            int[] left = new int[i];
            int[] right = new int[arr.Length - i - 1];

            for(int k = 0; k < left.Length; k++)
            {
                left[k] = arr[k];
            }

            for (int k = 0; k < right.Length; k++)
            {
                right[k] = arr[k + i + 1];
            }

            arr[i] = baseNum;
            left = sort(left);
            right = sort(right);

            int[] newArr = new int[left.Length + right.Length + 1];
            for(int k = 0; k < newArr.Length; k++)
            {
                if(k < left.Length)
                {
                    newArr[k] = left[k];
                }
                else if(k == left.Length)
                {
                    newArr[k] = baseNum;
                }
                else
                {
                    newArr[k] = right[k - left.Length - 1];
                }
            }

            return newArr;
        }

        PrintInt("旧数组：", old);
        PrintInt("快速排序：", newAr);
        Debug.Log($"循环了{count}次");
    }