常见算法

补充概念：时间复杂度、空间复杂度

时间复杂度一般分称最优时间复杂度和最差时间复杂度。我们一般主要参考最差时间复杂度。计算最差时间复杂度的步骤是：

• 计算最耗时的操作的计算量，比如冒泡排序，有两层循环，最外层循环次数为n，内层循环次数为n-1，每次循环的计算是3，所以，总的计算次数是3*（1+2+）当数组个数为2时，要计算3*1次，当数组为3时，要计算3*2次，以此类推下去，当数组为n时，要计算3*（）
• 找到

1.数组倒置：

计算数组的首位索引start和最后一位索引end，进行循环=》交换start和end两个位置的数据=》start++，end--=》如果start>=end，循环结束，实现代码：

2.冒泡排序，实现代码如下：

 

3.链表翻转。一个单向链表，将其方向反转，然后返回新的链表的首节点。实现代码如下：

        static void Main()
        {
            Node header = new Node() { ID = 0 };
            Node current = header;
            for (int i = 1; i < 10; i++)
            {
                current.Next = new Node() { ID = i };
                current = current.Next;
            }
            var result = Reverse(header);
            var v = result;
            while (v != null)
            {
                Console.WriteLine(v.ID);
                v = v.Next;
            }
        }
        private static Node Reverse(Node header)
        {
            if (header == null)
                throw new Exception();
            var last=header;
            var current = header.Next;
            header.Next = null;
            while (current != null)
            {
                var temp = current.Next;
                current.Next = last;
                last = current;
                current = temp;
            }
            return last;
        }

4.爬楼梯：一个小孩要上n阶楼梯，一次可以走1/2...m，那么有多少种走法。

比如小孩一次可以上1/2/3，那么他最后一步有三种情况，只剩下一个阶梯，只剩下两个阶梯，只剩下三个阶梯。共有的可能性是：

f(n)=f(n-1)+f(n-2)+f(n-3)。这个和斐波拉契数列很像。如果小孩每次可以走1/2步，那么共有可能性为：

f(n)=f(n-1)+f(n-2)。

剩下的就是递归实现了。

5.最长不重复子串：

        static void Main()
        {
            string str = "sfafsdggkkjdhafkhdfglretwiortiojdsnds";
            get(str);
        }
        private static void get(string str)
        {
            int length = str.Length;
            int result = 0;
            int left = 0;
            int right = 0;
            int start = 0;
            List<char> set = new List<char>();
            while (left < length && right < length)
            {
                if (!set.Contains(str[right]))
                {
                    set.Add(str[right]);
                    right++;
                    if (result < right - left)
                    {
                        result = right - left;
                        start = left;
                    }
                }
                else
                {
                    set.RemoveAt(0);
                    left++;
                }
            }
            Console.WriteLine(result);
            Console.WriteLine(str.Substring(start,result));
        }

6.获取所有排列：

        static void Main()
        {
            List<int> strs = new List<int>() { 1,2,3,4,5};
            var v= getOrders(strs);
            Console.WriteLine(v.Count);
            foreach (var s in v)
            {
                Console.WriteLine(string.Join(',', s));
            }
        }
        private static List<List<T>> getOrders<T>(List<T> list)
        {
            if (list.Count == 0)
            {
                throw new Exception();
            }
            if (list.Count == 1)
            {
                return new List<List<T>>() { new List<T>() { list[0]} };
            }
            List<List<T>> result = new List<List<T>>();
            for (int i = 0; i < list.Count; i++)
            {
                var tem = new List<T>(list);
                var v = list[i];
                tem.RemoveAt(i);
                var childList = getOrders(tem);
                for (int j = 0; j < childList.Count; j++)
                {
                    childList[j].Add(v);
                    result.Add(childList[j]);
                }
            }
            return result;
        }