学习python 第十一天

ADT：Abstract data type
单链表
双端链表

双向链表:
pre:前驱
deta
next:后继

class NullLinkedError(BaseException):
    def __init__(self):
        super().__init__("null linked error")

class node():
    '''
    author:lll
    time:2019-1-26
    content:创建节点，表示链表中元素，有三个属性，
        pre-前驱结点
        data-
        next-
    '''
    def __init__(self,data,pre=None,next=None):
        self.__pre = pre
        self.__data = data
        self.__next = next
    def get_pre(self):
        return self.__pre
    def set_pre(self, pre):
        self.__pre = pre
    def get_data(self):
        return self.__data
    def set_data(self,data):
        self.__data = data
    def get_next(self):
        return self.__next
    def set_next(self,next):
        self.__next = next

class double_linked():
    def __init__(self,len=0,first=None,last=None):
        self.__len = 0
        self.__first = first
        self.__last = last

    def insert_first(self,data):
        #首先判断是否为空
        n = node(data=data)
        if self.__len == 0:
            self.__first = n
            self.__last = n
        else:
            self.__first.set_pre(n)
            n.set_next(self.__first)
            self.__first = n
        self.__len += 1

    def insert_last(self,data):
        n = node(data=data)
        if self.__len == 0:
            self.__first = n
            self.__last = n
        else:
            self.__last.set_next(n)
            n.set_pre(self.__last)
            self.__last = n
        self.__len += 1

    def insert(self,data0,data):
        n = node(data = data)
        if self.__len == 0:
            raise  NullLinkedError()
        else:
            currentnode = self.__first
            flag = False
            while currentnode != None:
                if currentnode.get_data() == data0:
                    if currentnode.get_next() != None:
                        n.set_next(currentnode.get_next())
                        n.set_pre(currentnode)
                        currentnode.set_next(n)
                        currentnode.get_next().set_pre(n)
                        self.__len += 1
                    else:
                        self.insert_last(data)
                    flag = True
                    
                    break
                else:
                    currentnode = currentnode.get_next()
            if flag:
                print("插入成功")
            else:
                print("插入失败")
#删除头节点，若空抛出异常，否则删除头元素
    def delete_first(self):
        if self.__len == 0:
            raise NullLinkedError()
        else:
            if self.__len == 1:
                self.__first(None)
                self.__last(None)
            else:
                self.__first = self.__first.get_next()
                self.__first.set_pre(None)
            self.__len -= 1
# 删除尾节点，若空抛出异常，否则删除尾元素
    def delete_last(self):
        if self.__len == 0:
            raise NullLinkedError()
        else:
            if self.__len == 1:
                self.__first = None
                self.__last = None
            else:
                self.__last = self.__last.get_pre()
                self.__last.set_next(None)
            self.__len -= 1

    def delete(self,data):
        if self.__len == 0:
            raise NullLinkedError()
        elif self.__len == 1:
            if self.__first.get_data() == data:
                self.__first = None
                self.__last = None
                self.__len -= 1
        else:
            currentnode = self.__first
            while currentnode != None:
                if currentnode.get_data() == data:
                    if currentnode.get_pre() == None:
                        self.delete_first()
                    elif currentnode.get_next() == None:
                        self.delete_last()
                    else:
                        currentnode.get_pre().set_next(currentnode.get_next())
                        currentnode.get_next().set_pre(currentnode.get_pre())
                        self.__len -= 1
                    break
                else:
                    currentnode = currentnode.get_next()

    def updata_first(self,data):
        if self.__len == 0:
            raise NullLinkedError()
        else:
            self.__first.set_data(data)

    def updata_last(self,data):
        if self.__len == 0:
            raise NullLinkedError()
        else:
            self.__last.set_data(data)

    def updata(self,data0,data):
        if self.__len == 0:
            raise NullLinkedError()
        else:
            currentnode = self.__first
            flag = False
            while currentnode != None:
                if currentnode.get_data() == data0:
                    currentnode.set_data(data)
                    flag = True
                    break
                else:
                    currentnode = currentnode.get_next()
            if flag:
                print("修改成功")
            else:
                print("修改失败")

    def show_info(self):
        if self.__len == 0:
            print("空")
        else:
            currentnode = self.__first
            while currentnode != None:
                print(currentnode.get_data())
                currentnode = currentnode.get_next()
    def length(self):
        return self.__len

前缀表达式
中缀表达式
后缀表达式

a + b * c 中缀表达式
abc*+ 后缀表达式
+*dca 前缀表达式

(a+b)c 中缀表达式
ab+c 后缀表达式
*c+ab 前缀表达式

(a+b)*(c-d)/e 中缀表达式
ab+cd-e/ 后缀表达式
/e-cd+ab 前缀表达式

栈：

class NullStackError(BaseException):
    def __init__(self):
        super().__init__("null stack error !!!")
class MyStack():
    def __init__(self,len=0,list=[]):
        self.__len = 0
        self.__list = list

    def push(self,data):

        self.__list.append(data)
        self.__len += 1
    def pop(self):
        temp = None
        if self.__len == 0:
            raise NullStackError()
        else:
            temp = self.__list.pop()
            self.__len -= 1
        return temp
    def peek(self):
        if self.__len == 0:
            raise NullStackError()
        else:
            return self.__list[-1]
    def peekq(self):
        if self.__len == 0:
            raise NullStackError()
        else:
            return self.__list[::]
    def length(self):
        return self.__len