网易互娱面试总结（上）

~~~~总结基础知识~~~

1.生成随机数组

       方案一： import random  === random.shuffle

       方案二：随机输出一个数，然后和前面的一个数进行交换

2.快速排序

      基本思想：

         1）找一个基准点，（一般直接中间的点），然后设置两个变量

        2）

#-*-coding=utf-8-*-
def quickSorted(arr,start,end):
    if start < end:
        i,j = start,end
        pivotKey = arr[i]
        while i < j:
            #如果后面的数比基准数要大，则前移一位，直到有比基准数小的数
            while i < j and arr[j] >= pivotKey:
                j -= 1
            arr[i] = arr[j]
            #同样前面的数比基准数小则后移一位，直到有比基准数大的数
            while i < j and arr[i] <= pivotKey:
                i += 1
            arr[j] = arr[i]
        #完成一轮比较后，序列被分成两部分，并且i = j，需要将这个数设置为pivotKey
        arr[i] = pivotKey
        #递归排序前后两部分
        quickSorted(arr,start,i-1)
        quickSorted(arr,j+1,end)
    return arr

if __name__ == '__main__':
    rawArr = [8,4,5,7,1,3,6,2]
    print ( quickSorted(rawArr,0,len(rawArr)-1))
    #print (arr)

 

3.归并排序

       归并排序是分治法的一个典型应用，归并排序是将两个已排序的表合成一个表。

      基本思想： 把待排序序列看成是N 个长度为 1 的有序序列，将相邻的有序表成对归并，得到n/2 个长度为 2 的有序表；将这些有序序列再次归并，得到N/4 个长度为 4 的有序表，反复循环此操作，最后得到一个长度为N的有序表。

     归并主要在做两件事：

     1）“分解”-----将序列每次这般划分

     2）“合并” ----将划分后的有序列两两合并后排序

分而治之：（example：[8,4,5,7,1,3,6,2]）

          

治阶段：把两个基本有序性的子序列进行合并

                                 

python代码实现：(递归的归并排序)

#-*-coding=utf-8-*-
#合并有序集
def mergeList(arrA,arrB):
    mergeArr =[]
    indexA = 0
    indexB = 0
    while indexA < len(arrA) and indexB < len(arrB):
        if arrA[indexA] < arrB[indexB]:
            mergeArr.append(arrA[indexA])
            indexA += 1
        else:
            mergeArr.append(arrB[indexB])
            indexB += 1
    mergeArr += arrA[indexA:]
    mergeArr += arrB[indexB:]
    return mergeArr

def mergeSorted(allArr):
    if len(allArr) <= 1:
        return allArr
    num = int(len(allArr) / 2)                #二分分解
    aheadArr = mergeSorted(allArr[:num])      #递归调用归并
    behindArr = mergeSorted(allArr[num:])
    return mergeList(aheadArr,behindArr)      #合并

if __name__ == '__main__':
    rawArr = [8,4,5,7,1,3,6,2]
    newArr = mergeSorted(rawArr)
    print (newArr)

归并排序的时间复杂度：O(n*log2n)

空间复杂度：O(n+log2n)    // 归并排序在归并过程中需要与原始记录序列同样数量的存储空间存放归并结果，以及递归时深度为log2n的栈空间，因此空间复杂度为：n + log2n

总的来说，归并排序是一种比较占用内存，但效率高且稳定的算法。

明天继续更~~~

加油呀~~~~^_^~~~~