数据结构中的栈和队列介绍 简单的算法

栈

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

    def is_empty(self):
        """
        如果栈为空，返回True，否则，返回False
        :return:
        """
        return self.items == []

    def push(self, item):
        """
        向栈的顶部添加一个元素
        :param item:
        :return:
        """
        self.items.append(item)

    def pop(self):
        """
        从顶部移除一个元素
        :return:
        """
        return self.items.pop()

    def peek(self):
        """
        返回顶部的元素，不会移除
        :return:
        """
        last = len(self.items)-1
        return self.items[last]

    def size(self):
        """
        栈中元素数量的整型数
        :return:
        """
        return len(self.items)


# 新创建的栈是空的，is_empty方法返回True
stack =Stack()
# True
print(stack.is_empty())

# 向栈中添加元素，is_empty方法返回False
stack.push(1)
# False
print(stack.is_empty())

# 调用pop方法，删除栈中的一个元素，is_empty方法的返回值为True
item = stack.pop()
print(item)
print(stack.is_empty())

# 查看栈的内容，打印大小
for i in range(5):
    stack.push(i)

print(stack.peek()) # 4
print(stack.size()) # 5

将元素从栈中移除，称为出栈；将元素放回栈中；称为入栈。按照代码返回的结果，你会发现。栈是先进后出（LIFO）型数据结构，即最后一个放入的元素会被第一个取出。呢么就可以实现反转操作，将eyujun，逆转为nujuye：

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

    def is_empty(self):
        """
        如果栈为空，返回True，否则，返回False
        :return:
        """
        return self.items == []

    def push(self, item):
        """
        向栈的顶部添加一个元素
        :param item:
        :return:
        """
        self.items.append(item)

    def pop(self):
        """
        从顶部移除一个元素
        :return:
        """
        return self.items.pop()

    def peek(self):
        """
        返回顶部的元素，不会移除
        :return:
        """
        last = len(self.items)-1
        return self.items[last]

    def size(self):
        """
        栈中元素数量的整型数
        :return:
        """
        return len(self.items)


stack =Stack()

for i in 'eyujun':
    stack.push(i)


reverse = ''
for a in range(len(stack.items)):
    reverse += stack.pop()

print(reverse)

队列

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

    def is_empty(self):
        """
        如果队列为空，返回True，否则，返回False
        :return:
        """
        return self.items == []

    def enqueue(self, item):
        """
        向队列添加一个元素
        :param item:
        :return:
        """
        self.items.insert(0, item)

    def dequeue(self):
        """
        从队列移除一个元素
        :return:
        """
        return self.items.pop()

    def peek(self):
        """
        返回队列的元素，不会移除
        :return:
        """
        last = len(self.items)-1
        return self.items[last]

    def size(self):
        """
        栈中元素数量的整型数
        :return:
        """
        return len(self.items)


# 新创建的队列是空的，is_empty方法返回True
stack =Queue()
# True
print(stack.is_empty())

# 向队列中添加元素，is_empty方法返回False
stack.enqueue(1)
# False
print(stack.is_empty())

# 调用pop方法，删除队列中的一个元素，is_empty方法的返回值为True
item = stack.dequeue()
print(item)
print(stack.is_empty())

# 查看队列的内容，打印大小
for i in range(5):
    stack.enqueue(i)

print(stack.peek()) # 0
print(stack.size()) # 5

算法

编写一个程序，打印从1到100之间的数字。碰到3的倍数时，不打印数字，而是打印”Fizz”；碰到5的倍数时，则打印”Buzz”；如果是3和5共同的倍数，则打印”FizzBuzz”。

def first_algorithm():
    for i in range(1, 101):
        if i % 3 == 0 and i % 5 == 0:
            print('FizzBuzz')
        elif i % 3 == 0:
            print('Fizz')
        elif i % 5 == 0:
            print('Buzz')
        else:
            print(i)
            
            
first_algorithm()

def two_algorithm(num_list, val):
    found = False
    for i in num_list:
        if i == val:
            found = True
            break
    return found


numbers = range(1, 11)
data = two_algorithm(numbers, 2)
print(data)

def three_algorithm(word):
    word = word.lower()
    return word[::-1] == word


print(three_algorithm('mom'))
print(three_algorithm('eyujun'))

def four_algorithm(word1, word2):
    w1 = word1.lower()
    w2 = word2.lower()
    print(sorted(w1))
    print(sorted(w2))
    return sorted(w1) == sorted(w2)


print(four_algorithm('tree', 'true'))
print(four_algorithm('iceman', 'cinema'))

def five_algorithm(string):
    count_dict = {}
    for i in string:
        if i in count_dict:
            count_dict[i] += 1
        else:
            count_dict[i] =1
    print(count_dict)


five_algorithm('eyujun')