Google python course basic exercise——list2

list2里面含两个练习，方法多彩多样。

D题实现对list内数据去重操作，E题实现对已排序list实现归并排序，并且要求线性时间复杂度。

题目和代码如下：

# D. Given a list of numbers, return a list where
# all adjacent == elements have been reduced to a single element,
# so [1, 2, 2, 3] returns [1, 2, 3]. You may create a new list or
# modify the passed in list.
def remove_adjacent(nums):
    for i in range(len(nums)): #注意边界条件
        for j in range(len(nums)-1,i,-1):#逆序遍历，当进行删除操作时不会影响待比较元素的序号
            if nums[i] == nums[j]:
                nums.remove(nums[j])
    return nums

# E. Given two lists sorted in increasing order, create and return a merged
# list of all the elements in sorted order. You may modify the passed in lists.
# Ideally, the solution should work in "linear" time, making a single
# pass of both lists.
def linear_merge(list1, list2):
    list3=[]
    while list1 and list2:    
        if list1[-1]>list2[-1]:
            list3.append(list1.pop())  #pop()默认弹出list最末尾数据操作，时间O(1)
        else:
            list3.append(list2.pop())
    list3 += (list1+list2)[::-1]
    list3.reverse()  #reverse()built-in类型，时间复杂度为O(N)
    return list3
        
# Simple provided test() function used in main() to print
# what each function returns vs. what it's supposed to return.
def test(got, expected):
    if got == expected:
        prefix = ' OK '
    else:
        prefix = '  X '
    print '%s got: %s expected: %s' % (prefix, repr(got), repr(expected))


# Calls the above functions with interesting inputs.
def main():
    print 'remove_adjacent'
    test(remove_adjacent([1, 2, 2, 2, 3]), [1, 2, 3])
    test(remove_adjacent([2, 2, 3, 3, 3]), [2, 3])
    test(remove_adjacent([]), [])

    print
    print 'linear_merge'
    test(linear_merge(['aa', 'xx', 'zz'], ['bb', 'cc']),
         ['aa', 'bb', 'cc', 'xx', 'zz'])
    test(linear_merge(['aa', 'xx'], ['bb', 'cc', 'zz']),
         ['aa', 'bb', 'cc', 'xx', 'zz'])
    test(linear_merge(['aa', 'aa'], ['aa', 'bb', 'bb']),
         ['aa', 'aa', 'aa', 'bb', 'bb'])

if __name__ == '__main__':
  main()

运行结果：

remove_adjacent
 OK  got: [1, 2, 3] expected: [1, 2, 3]
 OK  got: [2, 3] expected: [2, 3]
 OK  got: [] expected: []

linear_merge
 OK  got: ['aa', 'bb', 'cc', 'xx', 'zz'] expected: ['aa', 'bb', 'cc', 'xx', 'zz']
 OK  got: ['aa', 'bb', 'cc', 'xx', 'zz'] expected: ['aa', 'bb', 'cc', 'xx', 'zz']
 OK  got: ['aa', 'aa', 'aa', 'bb', 'bb'] expected: ['aa', 'aa', 'aa', 'bb', 'bb']

 

ps：

1. 关于D题，我借鉴了冒泡排序的思想，利用两轮循环，外层循环负责正序遍历，里层循环负责逆序遍历，判断是否有重复的，有则删除。里层循环一轮结束后，则会删除一个数字的副本。这里强调一下，里层循环必须是逆序的，否则当进行remove()操作时，会改变继续判断时后面元素在list里的index，得不到想要的结果。举例说明：在第一个test case中，nums[1] ==nums[2] 成立，则删除nums[2]，nums=[1，2，2，3]，搜索nums[3]时得到的是'3',不是第二个'2',显然错误。
2. 关于D题，还有个更简单的方法：

       def remove_adjacent(nums):
         result = []
         for num in nums:
           if len(result) == 0 or num != result[-1]:
             result.append(num)
         return result

   其思想为对原list复制时去重，妙在num!=result[-1]这句。

3. E题最自然的想法是：

   def linear_merge(list1, list2):
     list1.extend(list2) 
     return sorted(list1)

   但是，因为python2.3以后的版本使用的是adaptive mergesort algorithm，其时间复杂度为O(nlogn)，不合题意。

4.  

   因为list1和list2是已排序序列，要对他们重新归并排序成list3，想到list3中最大的必是list1和list2两者中最大的，故可用pop[-1]来解决。这然后再reverse()一下，即可。list.pop()的时间复杂度为O(1),list.reverse()的时间复杂度为O(N)。故整个算法的时间复杂度是线性的。
5. 为什么不直接用pop(0)呢？因为根据资料显示，pop(0)时间复杂度非constant time(为O(N))，综合考虑用上面方法。
6. 答案是丰富多彩的，所以E题还可以这样解：

   def linear_merge(list1,list2 ):
       list3 = []
       i = j = 0
       total = len(list1) + len(list2)
       while len(list3) != total:
           if len(list1) == i:
               list3 += list2[j:]
               break
           elif len(list2) == j:
               list3 += list1[i:]
               break
           elif list1[i] < list2[j]:
               list3.append(list1[i])
               i += 1
           else:
               list3.append(list2[j])
               j += 1
       return list3