【2017.12.3】4.Median of Two Sorted Arrays（两个排序数组的中值）难

为了“减肥”这两个字，我感觉自己真的付出了很多，但为了期待中的目标（渺茫而又渺小） ，我还会继续坚持下去！

复杂度 Complexity

时间复杂度 Time Complexity

按数量级递增排列，常见的时间复杂度有：常数阶O(1),对数阶O(log2n),线性阶O(n), 线性对数阶O(nlog2n),平方阶O(n2)，立方阶O(n3),…， k次方阶O(nk),指数阶O(2n)。随着问题规模n的不断增大，上述时间复杂度不断增大，算法的执行效率越低。

【1】如果算法的执行时间不随着问题规模n的增加而增长，即使算法中有上千条语句，其执行时间也不过是一个较大的常数。此类算法的时间复杂度是O(1)。

x=91; y=100;while(y>0) if(x>100) {x=x-10;y--;} else x++;

解答： T(n)=O(1)，
这个程序看起来有点吓人，总共循环运行了1100次，但是我们看到 n 没有?
没。这段程序的运行是和n无关的，就算它再循环一万年，我们也不管他，只是一个常数阶的函数

【2】当有若干个循环语句时，算法的时间复杂度是由嵌套层数最多的循环语句中最内层语句的频度f(n)决定的。

x=1; //(1)for(i=1;i<=n;i++)         for(j=1;j<=i;j++)           for(k=1;k<=j;k++)               x++; 　//(5)            

该程序段中频度最大的语句是(5)，内循环的执行次数虽然与问题规模n没有直接关系，但是却与外层循环的变量取值有关，而最外层循环的次数直接与n有关，因此可以从内层循环向外层分析语句(5)的执行次数： 则该程序段的时间复杂度为T(n)=O(n^3/6+低次项)=O(n^3)

【3】算法的时间复杂度不仅仅依赖于问题的规模，还与输入实例的初始状态有关。

//在数值A[0..n-1]中查找给定值K的算法大致如下：   i=n-1;            while(i>=0&&(A[i]!=k))             i--;        return i;   //(3)     

此算法中的语句(3)的频度不仅与问题规模n有关，还与输入实例中A的各元素取值及K的取值有关:
①若A中没有与K相等的元素，则语句(3)的频度f(n)=n；
②若A的最后一个元素等于K,则语句(3)的频度f(n)是常数0。

时间复杂度评价性能
有两个算法A1和A2求解同一问题，时间复杂度分别是T1(n)=100n^2，T2(n)=5n^3。
随着问题规模n的增大，两个算法的时间开销之比5n^3/100n^2=n/20亦随着增大。即当问题规模较大时，算法A1比算法A2要有效地多。

它们的渐近时间复杂度O(n2)和O(n3)从宏观上评价了这两个算法在时间方面的质量。在算法分析时，往往对算法的时间复杂度和渐近时间复杂度不予区分，而经常是将渐近时间复杂度****T(n)=O(f(n))简称为时间复杂度，其中的f(n)一般是算法中频度最大的语句频度。

空间复杂度 Space Comlexity

一个程序的空间复杂度是指运行完一个程序所需内存的大小。利用程序的空间复杂度，可以对程序的运行所需要的内存多少有个预先估计。

一个算法的空间复杂度只考虑在运行过程中为局部变量分配的存储空间的大小，它包括为参数表中形参变量分配的存储空间和为在函数体中定义的局部变量分配的存储空间两个部分。
若一个算法为递归算法，其空间复杂度为递归所使用的堆栈空间的大小，它等于一次调用所分配的临时存储空间的大小乘以被调用的次数(即为递归调用的次数加1，这个1表示开始进行的一次非递归调用)。
算法的空间复杂度一般也以数量级的形式给出。
- 如当一个算法的空间复杂度为一个常量，即不随被处理数据量n的大小而改变时，可表示为O(1)；
- 当一个算法的空间复杂度与以2为底的n的对数成正比时，可表示为O(log2n)；
- 当一个算法的空间复杂度与n成线性比例关系时，可表示为O(n).
- 若形参为数组，则只需要为它分配一个存储由实参传送来的一个地址指针的空间，即一个机器字长空间；
- 若形参为引用方式，则也只需要为其分配存储一个地址的空间，用它来存储对应实参变量的地址，以便由系统自动引用实参变量。

odd and even

odd 偶数
even 奇数

———————-——————- 我是分割线———-——————————————————-

4.Median of Two Sorted Arrays（两个排序数组的中值）

题目：

There are two sorted arrays nums1 and nums2 of size m and n respectively.

Find the median of the two sorted arrays. The overall run time complexity（整体运行时间复杂度） should be O(log (m+n)).
这个问题的难度来自时间复杂度的要求，所以所有这些提供“简单”的解决方案的人使用排序都没有意义。
Example 1:

nums1 = [1, 3]
nums2 = [2]

The median is 2.0

Example 2:

nums1 = [1, 2]
nums2 = [3, 4]

The median is (2 + 3)/2 = 2.5

Solution:

Approach #1 Recursive Approach （递归方式)[Accepted]

To solve this problem, we need to understand What is the use of median”（中位数的用途是什么）. In statistics（在统计中）, the median is used for:

Dividing a set into two equal length subsets, that one subset is always greater than the other.
划分两个等长的串，使其中一个永远大于另一个

If we understand the use of median for dividing, we are very close to the answer.

First let’s cut A into two parts at a random position i:

Since A has m elements, so there are m+1 kinds of cutting ( i = 0 ∼ m).

And we know:

With the same way, cut B into two parts at a random position j :

Put left_A and left_B into one set, and put right_A and right_B into another set. Let’s name them left_part and right_part:

If we can ensure:

then we divide all elements in {A,B} into two parts with equal length, and one part is always greater than the other. Then

中位数=

To ensure these two conditions, we just need to ensure:

ps.1 关键点1 For simplicity, I presume A[i−1],B[j−1],A[i],B[j] are always valid even if i=0, i=m, j=0, or j=n. I will talk about how to deal with these edge values（边值） at last.

ps.2 关键点2 Why n≥m? Because I have to make sure j is non-negative（非负） since 0≤i≤m and j = (m+n+1)/2−i. If n < m, then j may be negative, that will lead to wrong result.

So, all we need to do is:
Searching ii in [0, m], to find an object i such that:

B[j−1]≤A[i] and A[i−1]≤B[j], where j = (m+n+1)/2 −i

When the object i is found, the median is:

Now let’s consider the edges values i=0,i=m,j=0,j=n where A[i−1],B[j−1],A[i],B[j] may not exist. Actually this situation is easier than you think.

What we need to do is ensuring that max(left_part)≤min(right_part). So, if i and j are not edges values (means**A[i−1],B[j−1],A[i],B[j]* all exist), then we must check both**B[j−1]≤A[i]* and A[i−1]≤B[j].
But if some of A[i−1],B[j−1],A[i],B[j] don’t exist, then we don’t need to check one (or both) of these two conditions. For example, if i=0, then A[i−1] doesn’t exist, then we don’t need to check A[i−1]≤B[j]. So, what we need to do is:

关键在这里！关键在这里！关键在这里！

So in situation 2. and 3. , we don’t need to check whether j>0 and whether j < n .

code:

———-————————————- 我是分割线———-————————————————-

友情连接：

时间复杂度和空间复杂度详解

leecode-解答