c#算法时间复杂度 面试必看

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

public class Arithmetic : MonoBehaviour
{
    private int[] arr = new int[] { 5, 7, 9, 3, 1, 0, 6, 4, 2, 8 };
    private 快速 _Get = new 快速();
    void Start()
    {
        //_Get.快速排序方法1(arr, 0, arr.Length - 1);
        插入排序(arr);
    }
    /// <summary>
    /// 时间复杂度为o(n2次方)，空间复杂度为o(1),他是稳定的
    /// </summary>
    /// <param name="arr"></param>
    private void 冒泡排序(int[] arr)
    {
        int test = 0;
        for (int i = 0; i < arr.Length-1; i++)
        {
            for (int j = 0; j < arr.Length-1-i; j++)
            {
                if(arr[j]>arr[j+1])
                {
                    test = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = test;
                }
            }
        }
        for (int i = 0; i < arr.Length; i++)
        {
            Debug.Log(arr[i]);
        }
    }


    /// <summary>
    /// 时间复杂度为o(n2次方)，空间复杂度为o(1),他是稳定的
    /// </summary>
    /// <param name="arr"></param>
    private void 选择排序(int[] arr)
    {
        int test = 0;
        for (int i = 0; i < arr.Length; i++)
        {
            int a = arr[i];
            int b = i;
            for (int j = i+1; j < arr.Length; j++)
            {
                if(a>arr[j])
                {
                    a = arr[j];
                    b = j;
                }
            }
            test = arr[i];
            arr[i] = arr[b];
            arr[b] = test;
        }
        
        for (int i = 0; i < arr.Length; i++)
        {
            Debug.Log(arr[i]);
        }
    }
   
    
    /// <summary>
    /// 
    /// </summary>
    /// <param name="arrs">数组</param>
    /// <param name="a">起始索引 </param>
    /// <param name="b">最大索引 </param>
    /// <param name="key">寻找值</param>
    /// <returns></returns>
    public int 二分查找(int[]arrs,int a,int b,int key)
    {
        int v = (a + b) / 2;
        if (a > b)
        {
            return -1;
        }
        else
        {
            if (arrs[v] == key)
            {
                return v;
            }
            else if (arrs[v] > key)
            {
                return 二分查找(arrs, a, v - 1, key);
            }
            else
            {
                return 二分查找(arrs,  v + 1, b,key);
            }
        }
    }
    
    
    /// <summary>
    /// 时间复杂度为o(n2次方)，空间复杂度为o(1),他是稳定的
    /// </summary>
    /// <param name="arr"></param>
    private void 插入排序(int[] arr)
    {
        for (int i = 1; i < arr.Length; i++)
        {
            bool a = false;
            int b = arr[i];
            for (int j = i-1; j >=0 ; j--)
            {
                if(arr[j]>b)
                {
                    arr[j + 1] = arr[j];
                }
                else
                {
                    arr[j + 1] = b;
                    a = true;
                    break;
                }
            }
            if(!a)
            {
                arr[0] = b;
            }
        }
               
        for (int i = 0; i < arr.Length; i++)
        {
            Debug.Log(arr[i]);
        }
    }

    
    /// <summary>
    /// 时间复杂度为O(n*log.n)，空间复杂度为O(1),他是不稳定的
    /// </summary>
    /// <param name="arr"></param>
    public static void 希尔排序(int[] arr)
    {
        int gap = arr.Length / 2;
        while (1 <= gap)
        {
            // 把距离为 gap 的元素编为一个组，扫描所有组
            //gap=5,  i=5,6,7,8,9
            //gap=2,  i=2,3,4,5,6,7,8,9
            for (int i = gap; i < arr.Length; i++)
            {
                int j = 0;
                int temp = arr[i];
                // 对距离为 gap 的元素组进行排序
                //j = 0,1,2,3,4   j = j - gap -5,-4,-3,-2,-1
                //j = 0,1,2,3,4,5,6,7   j = j - gap -2,-1,0,1,2,3,4,5
                for (j = i - gap; j >= 0; j = j - gap)
                {
                    if(temp < arr[j]){
                        arr[j + gap] = arr[j];
                    }
                }
                arr[j + gap] = temp;
            }
            foreach (int n in arr)
            {
                Debug.Log(n);
            }
            gap = gap / 2; // 减小增量
        }
    }
}
public class 快速
{
    /// <summary>
    /// 时间复杂度为o(n2次方)，空间复杂度为o（log.n）~o(n),他是不稳定的
    /// </summary>
    /// <param name="arr">要排序的数组</param>
    /// <param name="low">下标开始的位置，向右查找</param>
    /// <param name="higt">下标开始的位置，向左查找</param>
    public void 快速排序方法1(int[] arr,int low,int higt)
    {
        if (low >= higt) return;//退出循环
        int index = 快速排序方法2(arr, low, higt);//完成一次单元排序
        快速排序方法1(arr, low, index - 1);//递归调用，对左边部分的数组进行单元排序
        快速排序方法1(arr, index + 1, higt);//递归调用，对右边部分的数组进行单元排序
    }
    public int 快速排序方法2(int[] arr, int low, int high)
    {
        int key = arr[low];//基准数
        while(low<high)
        {
            while (low<high&&arr[high]>key)//从high往前找小于或等于的值
            {
                high--;
            }
            arr[low] = arr[high];//比key小开等的放左边
            while(low<high&&arr[low]<=key)//从low往后找大于key的值
            {
                low++;
            }
            arr[high] = arr[low];//比key大的放右边
        }
        //结束循环时，此时low等于high，左边都小于或等于key，右边都大于key，将key放在游标当前的位置
        arr[low] = key;
        return high;
    }
}