复杂度分析总结

 /// <summary>
    /// 常见的时间复杂度 时间渐进复杂度：表示算法的执行时间与数据规模的关系 分析及常见类型   
    /// </summary>
    class TimeDiff
    {
        /// <summary>
        /// 1.只关注循环次数最多的一层 时间复杂度为O(n)
        /// </summary>
        void test1(int n)
        {
            int sub = 0;

            int i = 1;

            for (; i <= n; i++)
            {
                sub = sub + i;
            }
        }
        /// <summary>
        /// 2.加法法则：
        /// 总复杂度等于量级最大的那段代码的复杂度
        /// 时间复杂度O(n+1000+n^2)----->>>O(n^2)
        /// </summary>
        int tset2(int n)
        {
            int sub1 = 0;
            int p = 1;

            for (; p <= n; ++p)
            {
                sub1 = sub1 + p;
            }

            int sub2 = 0;

            for (int q = 0; q < 1000; q++)
            {
                sub2 = sub2 + q;
            }

            int i = 1;
            int j = 1;
            int sub3 = 0;
            for (; i < n; ++i)
            {
                for (; j < n; ++j)
                {
                    sub3 = sub3 + i * j;
                }
            }

            return sub1 + sub2 + sub3;
        }
        /// <summary>
        /// 3.乘法法则
        /// 嵌套层代码的复杂度等于嵌套内外代码复杂度的积
        /// 时间复杂度为:O(m*n)
        /// </summary>
        void test3(int m)
        {
            int sub = 0;

            for (int i = 0; i <= m; ++m)
            {
                sub = sub + ret(m);
            }
        }

        int ret(int n)
        {
            int sub = 0;
            for (int i = 1; i <= n; ++i)
            {
                sub = sub + i;
            }
            return sub;
        }
        /// <summary>
        /// 4.常数级时间复杂度 O(1)
        /// </summary>
        void test4()
        {
            int sub = 1;
            int sub1 = 2;
            sub += sub1;
        }
        /// <summary>
        /// 5.对数时间复杂度 
        /// O(Logn)
        /// </summary>
        void test5(int n)
        {
            int i = 1;
            while (i <= n)
            {
                i = i * 2;//2^n
            }
        }
        /// <summary>
        /// 6.时间复杂度为 O(m+n)或者O(m*n)
        /// </summary>
        /// <param name="n"></param>
        void test6(int n)
        {
            //O(m+n)
            int sub = 1;
            int sub1 = 1;
            for (int i = 1; i <= n; ++i)
            {
                sub = sub + i;
            }

            for (int j = 1; j <= n; ++j)
            {
                sub1 = sub1 + sub;
            }
        }
    }
    /// <summary>
    /// 最好时间复杂度，最坏时间复杂度，平均时间复杂度，均摊时间复杂度
    /// 
    /// </summary>
    class DiffctTime
    {
        /// <summary>
        /// array为数组，n为数组的长度，x为随机输入的数据
        /// 
        /// 分析：从代码可以看出，我们要查询数据是否属于数组中的元素，并不需要把数组中的元素全部遍历一次。中途找到，就直接结束循环，显然时间复杂度不能初略的处理为n
        /// 在最好的情况下，我们查询的数据只执行一次循环也就是时间复杂度为O(1),\
        /// 在最坏的情况下，我们在数组中没有找到我们要到的数据元素，需要遍历数组的全部数据，时间复杂度为O(n)
        /// 平均时间复杂:查到数据元素的可能性为n-1中，所以平均时间复杂度为O((1+2+3+..+n-1)/2(n+1))=(n)
        /// </summary>
        /// <param name="array"></param>
        /// <param name="n"></param>
        /// <param name="x"></param>
        int test1(int[] array,int n,int x)
        {

            int i = 0;
            int pos = -1;

            for (; i < n; ++i)
            {
                if (array[i] == x)
                {
                    pos = i;
                    break;
                }
            }
            return pos;
        }
        /// <summary>
        /// 下面代码片段主要实现的逻辑是向数组中插入一个数据
        /// 当count!=array.Length的时候，为最好情况，直接插入，时间复杂为O(1)
        /// 当count==array.Length的时候，数组中没有空闲，需要执行循环遍历求和并把数组清空，所以最坏的时间复杂度为O(n)
        /// 平均时间复杂度:因为数组大小是n,插入情况分数组是否有空间，所以插入的情况有n+1种情况,所以平均时间复杂度O(1*(1/(n+1))+...+((n+1)*((1/(n+1)))))=O(1)
        /// 函数中find()函数与insert()函数的区别：1.find（）函数在极端情况下时间复杂度才为O(1)，insert()函数在大多数情况下复杂度为O(1),极小情况为O(n)
        /// 2.insert()方法不管时间复杂度是O(1)还是O(n),都是非常有规律的，n插入完成之后，紧接着是n-1,循环执行
        /// 摊还时间复杂度:出现这俩种情况的算法，使用摊还时间复杂度，不使用平均时间复杂度
        /// 一般情况下，均摊时间复杂度，为最好时间复杂度
        /// 均摊时间复杂度就是一种特殊的平均时间复杂度
        /// </summary>
        /// <param name="value"></param>
        /// <param name="n"></param>
        void Insert(int value,int n)
        {
            int[] array = new int[n];

            int count = 0;
            int sub = 0;
            if (count == array.Length)
            {
                for (int i = 0; i < array.Length; ++i)
                {
                    sub = sub + array[i];
                }
                array[0] = sub;
                count = 1;
            }

            array[++count] = value;
        }

    }
    /// <summary>
    /// 空间复杂度 空间渐进复杂度：表示算法的存储空间与数据规模的增长关系 分析
    /// </summary>
    class GCDiff
    {
        /// <summary>
        /// 空间复杂度 T(n)
        /// </summary>
        /// <param name="n"></param>
        void test(int n)
        {
            int[] a = new int[n];

            for (int i = 0; i < n; ++i)
            {
                a[i] = i;
            }

            for (int j = n - 1; j >= 0; --j)
            {
                Console.WriteLine(a[j]);
            }
        }
    }