算法之数组实现栈和队列

栈

1. 限制：仅允许对栈的一端操作，并且元素先进先出
2. 功能：进栈（push）、出栈（pop）、返回栈顶（peek）
3. 实现思路
   初始化：创建一个大小为initSize的数组arr（initSize必须大于0，否则抛出异常），栈内元素个数为size = 0
   进栈：判断size与arr大小（添加元素为obj）
   a. size < len(arr)，size += 1，arr[size] = obj
   b. size == len(arr)， 抛出异常
   出栈：判断size大小
   a. size > 0 ，size -= 1， 返回arr[size]（元素个数为size，由于元素位置是从0号位开始，所以size的大小刚好是栈顶位置）
   b. size == 0，抛出异常
   返回栈顶：判断size大小
   a. size > 0，返回arr[size - 1]
   b. size == 0， 返回null
4. 代码实现

class Stack():

    def __init__(self, len):
        self.len = len
        self.arr = [0,]*len
        self.size = 0


    def push(self, obj):
        if(self.size == self.len):
            print('栈已满')
            return
        self.arr[self.size] = obj
        self.size += 1

    def pop(self):
        if(self.size == 0):
            print('栈已空')
            return
        self.size -= 1
        return self.arr[self.size]

    def peek(self):
        if(self.size == 0):
            print('栈已空')
            return
        return self.arr[self.size - 1]

---

队列

1. 限制：只能在队尾添加元素，在队头弹出元素，元素先进先出
2. 功能：进队（push）出队（pop）
3. 实现思路
   初始化：创建一个长度为len的数组arr，队头位置为head = 0，队尾位置为rear = 0，元素个数为size
   进队：判断size大小（添加元素为obj）
   a. size < len，arr[rear] = obj， rear = (rear + 1) % len ， size += 1
   b. size == len， 抛出异常
   出队：判断size大小
   a. size > 0， head = (head + 1) % len，size -= 1，返回arr[head - 1]
   b. size == 0，抛出异常
4. 代码实现

class Queue():

    def __init__(self, len):
        self.len = len
        self.arr = [0]*len
        self.head = 0
        self.rear = 0
        self.size = 0

    def push(self, obj):
        if(self.size == self.len):
            print('队列已满')
            return
        self.arr[self.rear] = obj
        self.size += 1
        self.rear += 1
        if(self.rear == self.len):
            self.rear = 0

    def pop(self):
        if(self.size == 0):
            print('队列已空')
            return
        self.size -= 1
        self.head += 1
        if(self.head == self.len):
            self.head = 0
        return self.arr[self.head - 1]

---

栈实现队列

1. 含义：栈（后进先出）实现先进先出
2. 功能：进队（push）出队（pop）
3. 实现思路
   初始化：创建两个长度为len的数组push_arr以及pop_arr，其中，元素进队push到push_arr中，出队从pop_arr中popl，push_arr元素个数为push_size=0，pop_arr元素个数为pop_size=0
   进队：判断push_size + pop_size大小（添加元素为obj）
   a. push_size + pop_size < len，push_arr[push_size] = obj，push_size +=1
   b. push_size + pop_size == len， 抛出异常
   出队：分别判断判断push_size、pop_size大小
   a. pop_size > 0，pop_size -= 1， 返回arr[size]
   b. pop_size < 0，push_size > 0， 将push_arr所有元素逐一弹出，放进pop_arr中，然后再进行出队操作
   c. pop_size < 0，push_size < 0，抛出异常
   备注：为什么要等pop_arr栈空后才将push_arr栈中元素弹进pop_arr栈，并且要一次性弹进？防止后进队元素在pop_arr栈顶位置，导致出栈顺序出错。
4. 代码实现

# 以下为将push_arr所有元素逐一弹出，放进pop_arr
def transfer():
    while(self.push_size > 0):
        self.push_size -= 1
        self.pop_arr[self.pop_size] = self.push_arr[self.push_size]
        self.pop_size += 1

---

队列实现栈

1. 含义：队列（先进先出）实现后进先出功能
2. 功能：进队（push）出队（pop）返回栈顶（peek）
3. 实现思路
   初始化：创建一个长度为len的数组arr，队列头部为head = 0，尾部为rear = 0，元素个数为size = 0，出栈位置pop_place
   进栈：判断size的大小(添加元素为obj)
   a. size < len，arr[rear ] = obj，size += 1 如果rear + 1 < len，则rear += 1，否则rear = 0
   b. size == 0，抛出异常
   出栈：判断size大小
   a. size > 0，pop_place = rear - 1(记录队尾元即弹出元素位置)，当head < pop_place时，队列元素逐一出队，并且再次进队，当head == pop_place时，head = head + 1 if head + 1 < len else 0， 返回arr[head - 1]
   b. size ==0，抛出异常
   返回栈顶：判断size大小
   a. size > 0，返回arr[rear]
   b. size ==0，抛出异常
4. 代码实现

def pop(self):
    if(self.size == 0):
        print('栈已空')
        return
    self.pop_place = self.rear - 1
    while(self.head != self.pop_place):
        self.head = self.head + 1 if self.head + 1 < self.len else 0
        self.arr[self.rear] = self.arr[self.head - 1]
        self.rear = self.rear + 1 if self.rear + 1 < self.len else 0
    self.head = self.head + 1 if self.head + 1 < self.len else 0
    return self.arr[self.head - 1]