linux sort 算法_百度算法题面筋-python版

面试题一个是二分查找, 另一个是用栈实现队列

附带一个快速排序吧, 考的和二分查找一样的频繁.

面试失败, 写一下总结, 再接再厉.

由于一点算法都没刷, 所以当时写的有一堆BUG...

回去重新总结了一下.

主要没过的原因还是没怎么用过数据库, 并且只会C和Python, 不会CPP和JAVA, 网络和Linux服务器也不会....问到这里我就明白已经凉了... =- =

本来是冲着调参侠去碰碰运气的, 结果百度有个开发岗的邀请, 就去瞎猫碰碰死耗子...

面试过程还比较流畅, 算法虽然回顾有挺多BUG, 不过面试官还是勉强算我这方面过了...可惜后面的问题完全搭不上话了 凉的也很流畅。

(ps: 一个比较印象深刻的点就是python中is和==的区别，当时很久没想起来就谈了谈isinstance=- = 很少用is忘了。

查了一下，is是判断储存地址是否相同，==只判断值。但is的返回结果好像和解释器有关，比较复杂。）

总结就是百度的开发岗比较注重基本的数据结构和算法，其它的话需要学习网络、服务器、数据库，最好还懂CPP或者JAVA。

以前拿过百度的实习offer没去, 去的部委实习然后一直打酱油, 也是比较后悔. =- =

废话少说, 直接上代码.

二分查找

def binary_search(lst, x, left=None, right=None):
    # 异常处理
    assert isinstance(lst, list), 'input:lst must be a list!'
    assert isinstance(x, (int, float)), 'input:x must be a digit!'

    if(not lst):
        return -1

    if(left == right == None):
        left, right = 0, len(lst)

    if(left >= right):
        print('----- Warning: ValueError! ----------')
        print('left, right:', left, right)
        raise ValueError

    # core function
    ret = binary_search_core(lst, x, left, right)

    return ret

def binary_search_core(lst, x, left, right):
    mid = (left + right) // 2
    print('mid:', mid, 'left, right:', (left, right))

    if ( len(lst[left:right]) == 1):
        if(lst[left] == x):
            return left
        else:
            return -1

    if(lst[mid] == x):
        return mid

    if(lst[mid] > x):
        return binary_search_core(lst, x, left, mid)
    if(lst[mid] < x):
        return binary_search_core(lst, x, mid, right)


if __name__ == '__main__':
    lst = [-1, 1, 3, 4, 5, 8, 10, 20]
    x = 20  # find the value

    # 边界测试用例
    # lst = [1, 2, 3, 4, 5, 8, 10, 20]
    # x = 11  # Not found

    # lst = []
    # lst = None
    # x = 'test'

    print('----- len_lst:', len(lst))
    ret = binary_search(lst, x)

    if(lst and ret != -1):
        print('Find the value!')
        print('ret, lst[ret]: ', ret, lst[ret])
    else:
        print('Not find the value!')
        print('ret:', ret)

用栈实现队列

栈的特点:先入后出
队列的特点: 先入先出
以前在网上看到过思路, 就是俩个栈实现一个队列, 所以算运气好.
但要用伪代码实现... 当时还是琢磨了一阵...
回去后写个完整版代码.

class Stack(object):
    def __init__(self):
        self.datas = []

    def push(self, data):
        self.datas.append(data)

    def push_list(self, lst):
        if( isinstance(lst, (int, float)) ):
            lst = [lst]
        if(isinstance(lst, tuple)):
            lst = list(lst)
        assert isinstance(lst, list), 'type(lst) must be list!'

        for l in lst:   self.push(l)

    def pop(self):
        if(self.length == 0):
            return None
        return self.datas.pop()

    def is_empty(self):
        if(self.length != 0):
            return False
        else:
            return True

    @property
    def length(self):
        return len(self.datas)

    def info(self):
        print('len: ', self.length)
        print(self.datas)
        for data in self.datas[::-1]:
            print(data)

    def move_to(self, s2):
        assert isinstance(s2, Stack), 'type(s2) must be Stack!'

        while(not self.is_empty()):
            s2.push(self.pop())

        return 1

    1

class Queue(object):
    def __init__(self):
        self.s1 = Stack()
        self.s2 = Stack()

    def is_empty(self):
        return self.s1.is_empty()

    def push(self, data):
        self.s1.push(data)

    def push_list(self, lst):
        self.s1.push_list(lst)

    def pop(self):
        self.s1.move_to(self.s2)
        ret = self.s2.pop()
        self.s2.move_to(self.s1)

        return ret

    @property
    def length(self):
        return len(self.s1.length)

    def info(self):
        # self.s1.info()
        print('len: ', self.s1.length)
        print(self.s1.datas)

if __name__ == '__main__':
    lst = [1, 2, 3]
    # for _ in range(len(lst)):   print(lst.pop())
    # lst = None
    # lst = []
    # lst = [1]

    queue = Queue()

    for l in lst:   queue.push(l)
    # queue.push_list(lst)
    # queue.info()

    for _ in range(len(lst)):   print(queue.pop())

快速排序

参考 :
<剑指offer> 2.4.2 查找和排序 (具体思路和C语言版)
<菜鸟教程> (Python版)

from random import randrange

def quick_sort(lst, start=None, end=None):
    if(lst == None):
        return None

    if (start == end == None):
        start, end = 0, len(lst) - 1

    if(start < end):
        mid_i = partition(lst, start, end)
        quick_sort(lst, start, mid_i-1)
        quick_sort(lst, mid_i+1, end)

def partition(lst, start=None, end=None, random_select=False):
    if (start == end == None):
        start, end = 0, len(lst) - 1

    if(random_select):
        # select a random digit to be middle-number to partition 
        i = randrange(start, end)
        swap(lst, i, end)
    
    i = start
    mid = lst[end]

    for j in range(start, end):
        if(lst[j] < mid):
            swap(lst, i, j)
            i += 1

    swap(lst, i, end)
    mid_i = i

    return mid_i

def swap(lst, a, b):
    if(a == b):
        return

    lst[a], lst[b] = lst[b], lst[a]

if __name__ == '__main__':
    lst = [5, 6, 1, 2, 3, 3, 3, 3, -1]
    # lst = None
    # lst = []
    # lst = [1]

    # ret = partition(lst)
    # print('ret, lst[ret]: ', ret, lst[ret])
    quick_sort(lst)
    print(lst)

加油 好运