数据结构作业1

布尔表达式计算

#顺序栈实现
class Astack: 
    def __init__(self,size):
        self.element = [

        ]
        self.size = size
        self.top = -1
    def clear(self):        
        self.top = -1       
    def push(self,object):
        if self.top == self.size:
            print("栈已满")
        else:
            self.top += 1
            self.element.append(object)
    def pop(self):
        if self.top == -1:
            print("栈为空")
        else:
            self.top -= 1
            return self.element.pop()
    def topValue(self):
        if self.top != -1:
            return self.element[-1]
        else:
            return None
    def isEmpty(self):      
        return self.top == 0
    def length(self):       
        return (self.top+1)

def is_boolean(m):
    if m == "T" or m =="F":
        return True
    else:
        return False

#中缀表达式转后缀表达式
def middle_to_back(boolean):
    RPN = []
    stack1 = Astack(100)
    for i in boolean:
        if i == "T":
            RPN.append(True)
        elif i == "F":
            RPN.append(False)
        else:
            if stack1.length() == 0 or (i in "(!"):
                stack1.push(i)
            elif i == ")":
                if "(" in stack1.element:
                    t = stack1.pop()
                    while t != "(":   
                        RPN.append(t)
                        t = stack1.pop()
                else:
                    print("原表达式缺少(")  #判别括号问题
            elif i == "&":
                while stack1.topValue() == "!":
                    t = stack1.pop()
                    RPN.append(t)
                stack1.push(i)
            elif i == "^":
                while stack1.topValue() =="!" or stack1.topValue() =="&":
                    t = stack1.pop()
                    RPN.append(t)
                stack1.push(i)
            elif i == "|":
                while stack1.topValue() == "!" or stack1.topValue() =="&" or stack1.topValue() =="^":
                    t = stack1.pop()
                    RPN.append(t)
                stack1.push(i)
    while stack1.top != -1:
        if "(" in stack1.element:
            print("原表达式缺少)")
        RPN.append(stack1.pop())
    return RPN


#计算后缀表达式
def calculate(RPN):
    stack_for_calculate = Astack(100)
    for i in RPN:
        if i == True or i == False:
            stack_for_calculate.push(i)
        else:
            if stack_for_calculate.length() < 2:
                return "表达式非法，请检查是否出现多个运算符之间无布尔值"
            else:
                right = stack_for_calculate.pop()
                left = stack_for_calculate.pop()
                if i == "&":
                    stack_for_calculate.push(right&left)
                elif i == "|":
                    stack_for_calculate.push(right|left)
                elif i == "^":
                    stack_for_calculate.push(right^left)
    if stack_for_calculate.length != 1:
        return "表达式非法，请检查是否出现多个布尔值之间无运算符连接"
    else:
        return stack_for_calculate.topValue()


#数据输入并预处理
boolean = input("请输入一个布尔表达式")
bool1 = boolean.replace(" ", "")
bool2 = bool1.replace("!T", "F")
bool = bool2.replace("!F", "T")


#调用运算函数
result = calculate(middle_to_back(bool))
print(result)

队列基数排序

#循环存储队列
class Queue:
    def __init__(self,size):
        self.front = self.rear = -1
        self.element= ["None"]* (size+1)
        self.size = size + 1
    def clear(self):
        self.front = self.rear = -1
    def isFull(self):
        return self.front == (self.rear + 1) % self.size
    def isEmpty(self):
        return self.front == self.rear
    def enqueue(self,element):
        if self.isFull():
            return "栈已满"
        else:
            self.rear = (self.rear + 1) % self.size
            self.element[self.rear] = element
    def dequeue(self):
        if self.isEmpty():
            return "栈为空"
        else:
            self.front = (self.front + 1) % self.size
            return self.element[self.front]
    def len(self):
        return (self.rear - self.front + self.size) % self.size
    def firstValue(self):
        if self.isEmpty():
            return "栈为空"
        else:
            return self.element[(self.front+1) % self.size]
    def real_element(self):
        return self.element[:-1]

def radixSortInt(mylist):
    qlist=[]
    max_size = len(mylist)
    main=Queue(max_size)#实例化一个队列，这里直接使用类的名字即等价表示调用类中初始化函数中的方法
    for i in mylist:
        main.enqueue(i)#将Mylist中的元素全部转移到main队列中
    for i in range(0,10):
        qlist.append(Queue(max_size))#生成10个队列并且存入列表中
    for i in range(0,len(str(max(mylist)))):#位数上限
        for j in main.real_element():
        #j为待排序的数，按照其每次循环对应的基数大小将该数放入相应的队列
            qlist[int(j/(10**i)%10)].enqueue(j)
        main.clear()
        for k in range(0,10):#从各个队列中依次放入新排好的数进入main队列
            for m in range(0,qlist[k].len()):
                main.enqueue(qlist[k].dequeue())
    return main.real_element()


#对于字符串类型的数据转化成ascii码,化为第一种排序做
def radixSortStr1(mylist):
    #将字符串储存为ascii码并存储进字典中,将字符串排序转化为数字排序
    dic = {}
    main = []
    for i in mylist:
        ascii = 0
        count = 0
        for j in reversed(i):
            ascii += (ord(j)-96)*(100**count)
            count += 1
        dic[ascii] = i
    for i in radixSortInt(dic.keys()):
        main.append(dic[i])
    return main

# 第二种字符串排序方式，桶排序之基数排序
def radixSortStr2(mylist,length):
    qlist=[]
    max_size = len(mylist)
    main=Queue(max_size)
    for i in mylist:
        main.enqueue(i)#将Mylist中的元素全部转移到main队列中
    for i in range(0,26):
        qlist.append(Queue(max_size))
    for n in range(length,0,-1):
        for i in main.element:
            ascii=ord(i[n-1])-97   #将所有小写字母转化为ASCII码并减去96
            qlist[ascii].enqueue(i)
        main.clear()
        for k in range(0,26):
            for m in range(0,qlist[k].len()):
                main.enqueue(qlist[k].dequeue())
    return main.real_element()


list1 = [8,223,23,7,9,45,2019,9]
list2 = ["abc","bde","fad","abd","bef","fdd","abe"]
print(radixSortInt(list1))
print(radixSortStr1(list2))
print(radixSortStr2(list2,3))