栈、队列、递归

栈

用数组实现一个顺序栈

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

     def isEmpty(self):
         return self.items == []

     def push(self, item):
         self.items.append(item)

     def pop(self):
         return self.items.pop()

     def peek(self):
         return self.items[len(self.items)-1]

     def size(self):
         return len(self.items)

用链表实现一个链式栈

class Node:
    def __init__(self, data):
       self.data = data
       self.next = None
 
class Stack:
    def __init__(self):
        self.head = None
 
    def push(self, data):
        if self.head is None:
            self.head = Node(data)
        else:
            new_node = Node(data)
            new_node.next = self.head
            self.head = new_node
 
    def pop(self):
        if self.head is None:
            return None
        else:
            popped = self.head.data
            self.head = self.head.next
            return popped
s = Stack()
s.push(1)
s.push(2)
s.pop() ## 2

编程模拟实现一个浏览器的前进、后退功能

队列

用数组实现一个顺序队列

class Queue:
    def __init__(self):
        self.items = []

    def isEmpty(self):
        return self.items == []

    def enqueue(self, item):
        self.items.insert(0,item)

    def dequeue(self):
        return self.items.pop()

    def size(self):
        return len(self.items)

用链表实现一个链式队列

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None


class Queue:
    def __init__(self):
        self.front = self.rear = None

    def isEmpty(self):
        return self.front == None

    def EnQueue(self, item):
        temp = Node(item)

        if self.rear == None:
            self.front = self.rear = temp
            return
        self.rear.next = temp
        self.rear = temp

    def DeQueue(self):

        if self.isEmpty():
            return
        temp = self.front
        self.front = temp.next

        if (self.front == None):
            self.rear = None
        return str(temp.data)

实现一个循环队列

class Queue:
    def __init__(self):
        front = None
        rear = None


def enQueue(q, value):
    temp = Node()
    temp.data = value
    if (q.front == None):
        q.front = temp
    else:
        q.rear.link = temp

    q.rear = temp
    q.rear.link = q.front


def deQueue(q):
    if (q.front == None):
        print("Queue is empty")
        return -1

    value = None
    if (q.front == q.rear):
        value = q.front.data
        q.front = None
        q.rear = None
    else:
        temp = q.front
        value = temp.data
        q.front = q.front.link
        q.rear.link = q.front

    return value

递归

编程实现斐波那契数列求值 f(n)=f(n-1)+f(n-2)

def fibonacci(n):
    if n == 1 or n == 2:
        # print(1)
        return 1
    elif n < 1:
        return -1
    else:
        return fibonacci(n-1) + fibonacci(n-2)
        

l_9 = [fibonacci(n) for n in range(1, 10)]
print(l_9) # [1, 1, 2, 3, 5, 8, 13, 21, 34]

编程实现求阶乘 n!

编程实现一组数据集合的全排列