nowcoder basic algorithm chapter 3

Posted 2020-11-20 jiaxin359

使用固定的数组实现栈和列表

实现栈的思想很简单，固定的数组，然后维持一个在栈顶的index，入栈的时候存入元素 index++，出栈的时候只需要将index--，就可以了。

使用固定的数组实现栈的代码如下：

class stack(object):

    def __init__(self, length=10):
        self.index = 0    #index表示栈顶的index+1
        self.length = 10
        self.data = [None] * self.length

    def push(self, num):
        if self.index  == self.length:
            print(‘pop faile‘)
        else:
            self.data[self.index] = num
            print(‘push‘, self.data[self.index])
            self.index += 1

    def pop(self):
        if self.index == 0:
            print(‘pop faile‘)
        else:
            self.index -= 1
            print(‘pop‘, self.data[self.index])
    def __repr__(self):
        res = ‘‘
        for i in range(self.index-1, -1, -1):
            res += ‘ ‘
            res += str(self.data[i])
        return res

 

实现队列的时候，我们维持两个index,一个start,一个end，并且维持一个size表示当前数组中存放数的多少，用end和size比较来进行入队列的操作，用start和size比较来进行出队列的操作。

使用固定的数组实现队列的代码如下：

class queue(object):
   
    def __init__(self, length=3):
        self.start = 0
        self.end = 0
        self.size = 0         # size是当前数组维持的长度，
        self.length = length  # length是数组的总体长度，使用size，不需要判断start的关系
        self.data = [None] * self.length

    def pop(self):
        if self.size == 0:
            print(‘pop failed‘)
        else:
            print(‘pop‘, self.data[self.start])
            self.start = 0 if self.start +1 == self.length else self.start+1
            self.size -= 1

    def push(self, num):
        if self.size == self.length:
            print(‘push failed‘)
        else:
            self.data[self.end] = num
            print(‘push‘, self.data[self.end])
            self.size += 1
            self.end = 0 if self.end+1 == self.length else self.end+1

 

实现一个特殊的栈， 在实现栈的基本功能的基础上， 再实现返回栈中最小元素的操作。

【要求】
1． pop、 push、 getMin操作的时间复杂度都是O(1)。
2． 设计的栈类型可以使用现成的栈结构。

实现思路是这样的，维持两个栈，第一个栈正常进行，第二个栈随着第一个栈进行，但是压入的元素如果比栈顶小，那么压入这个数，否则将栈顶的数再压入一次。这样维持min栈大小和原来存数据栈的大小相同。

一个稍微改进的方法是这样的：第一个栈正常进行，对于第二个栈来说：新的元素小于等于栈顶元素，则进栈。出栈的时候，若一个数等于栈顶元素，则出栈。

class min_stack(object):

    def __init__(self):
        self.stack_data = []
        self.stack_min = []

    def push(self, num):
        if not self.stack_min:
            self.stack_min.append(num)
        elif num <= self.get_min():
            self.stack_min.append(num)
        self.stack_data.append(num)

    def pop(self):
        if self.stack_data:
            pop_value = self.stack_data.pop()
            if pop_value == self.get_min():
                self.stack_min.pop()
            return pop_value
        else:
            raise RuntimeError(‘stack is empty‘)

    def get_min(self):
        if self.stack_min:
            return self.stack_min[-1]
        else:
            raise RuntimeError(‘stack is empty‘)

 

队列和栈的互相实现

用两个栈来实现一个队列：

class queue(object):
    """使用两个栈来实现一个队列

    看起来像下面1,2,3,4,5,6的顺序一样组成的结构
    | 6|       | 1|
    | 5|       | 2|
    | 4|       | 3|
    ----       ----
    stack_a    stack_b
    """

    def __init__(self):
        self.stack_b = []
        self.stack_a = []

    def push(self, node):
        self.stack_a.append(node)    # 入栈的时候只需要向a中入栈就可以了

    def pop(self):
        if self.stack_b:             # 如果b栈中有元素，则出栈
            return self.stack_b.pop()
        elif self.stack_a:           # 如果b栈为空，a栈有元素，则将元素从a导入到b中
            while self.stack_a:
                self.stack_b.append(self.stack_a.pop())
            return self.stack_b.pop()
        else:                        # 如果a和b都为空，则返回None
            return None

 

用两个队列实现一个栈

class stack(object):
    """两个队列实现一个栈

    看起来像a和b连接在一起
        -----        -------
    --> queue_a  --> queue_b
        -----        -------
    """

    def __init__(self):
        self.queue_a = []
        self.queue_b = []

    def push(self, node):
        self.queue_a.append(node)      # 进栈的时候总是进入队列a，

    def pop(self):
        if self.queue_a:               # 如果a不为空，那么栈顶总是在队列a的末尾
            for i in range(len(self.queue_a) - 1):
                self.queue_b.append(self.queue_a.pop(0))
            return self.queue_a.pop(0)

        elif self.queue_b:            # A为空，B不为空，栈顶在队列b的末尾
            for i in range(len(self.queue_b) - 1):
                self.queue_a.append(self.queue_b.pop(0))
            return self.queue_b.pop(0)
        else:                        # A为空，B为空
            return None