2022.03.03

课时31-补充

上次的单向循环链表里面的remove函数其实有错，如果只有一个元素的情况下，删除元素后没有返回“self.__head=None",则该元素还会存在。

    def remove(self,item):
        if self.is_empty():
            return False
        cur=self.__head
        pre=None
        while cur.next!=self.__head:
            if cur.elem==item:
                #先判断此节点是否为头节点
                if cur==self.__head:
                    #头结点的时候，要找尾节点去指向头节点后的地方。
                    rear=self.__head
                    while rear.next!=self.__head:
                        rear=rear.next
                    rear.next=cur.next
                    self.__head=cur.next
                else:
                    #中间节点
                    pre.next=cur.next
                return
            else:
                pre=cur
                cur=cur.next
        #退出循坏，指标指向尾节点
        if cur.elem==item:
            if cur==self.__head:
                self.__head=None
                 #如果不返回该值，则还会保留该头节点
                return
            else:
                pre.next=cur.next

课时32 单向循环列表删除元素复习

首先判断当前链表是否为空。

 

設置两个游标进行辅助。

 

设置遍历条件。

 

当推出循环的时候，游标指向尾节点。

判断改元素是否所找的元素。

 

如果只有一个节点，那么游标一开始就可以跳过循环，直接进行判断。

那么cur指的是当前唯一的节点时，则使头节点为空。不能不写该判断，否则pre为空会报错。

 

当然最后一步else可以写成赋值为“self.__head”

那么在循环体里面如何？ 

游标不为尾节点时。

一进入循环就恰巧找到这个要找的节点，即此刻，cur为头节点。 

那么，要删除该头节点，则需要把尾节点的next区域指向头节点。

则还需要一个循环找到尾节点。

 设置一个新的游标找到尾节点，同时使头节点等于当前游标的next区域，再使尾节点等于头节点。

那么删除的是中间节点呢？

这时不考虑尾节点的next区域必须指向头部，过程与单链表一样。

使pre游标的next区域指向cur游标的next即可。

而整体的循环必须满足使，pre=cur,cur=cur.next的条件，否则，pre为none，报错。

单向循环链表可以有一个表节点，保存整个链表的信息。 

课时33

 

 

 

是否可以使链表跟顺序表一样，只能从尾部添加，并且只能在尾部删除呢？ 

顺序表侧重于如何保存元素，而栈侧重于解析。

队列本身也是线性的容器。

只不过它只能从一端添加，而另外一端去取。

即先进入的元素，会先被取出。

所以，深度遍历时，就可以使用队列。

课时34栈的实现。

栈可以用顺序表（list）实现。

添加元素的方法——压栈（入栈）

peek（）将栈顶元素返回出来，但是该元素依旧在栈内。 

 

class Stack(object):
    """棧"""
    def __init__(self):
        self.__list=[]
        #如果不把list作成私有，则可以绕过这个栈去调整pop之类的.

    def push(self,item):
        """添加一個新元素到棧頂"""
        self.__list.append(item)
        #elf.__list.insert(0,item) 头部存

    def pop(self):
        """彈出棧頂元素"""
        return self.__list.pop()

        #self.__list.pop(0) 头部取
        #但是从尾部存取时间复杂度是o（1），所以从尾部存取。
        #而链表从尾部存取的话时间复杂度是o（n），所以要从头部存取。

    def peek(self):
        """返回栈顶元素"""
        if self.__list:
            return self.__list[-1]
        else:
            return None

    def is_empty(self):
        """判斷棧是否為空"""
        return self.__list==[]
        #遇到return应该先计算return右边算式的值，然后返回。
        #雙等號，代表返回一個邏輯值
        #如果相等，返回真。
        #return not self.__list 如果是空列表，则是假，和not一起返回，代表返回真。

    def size(self):
        """返回棧的元素個數"""
        return len(self.__list)

if __name__=="__main__":
    s=Stack()
    s.push(1)
    s.push(2)
    s.push(3)

    print(s.pop())
    print(s.pop())

執行結果：
3
2

课时35 队列的实现

class Queue(object):
    """隊列"""

    def __init__(self):
        self.__list=[]

    def enqueue(self,item):
        """往隊列中添加一個item元素"""
        #self.__list.append(item)
        self.__list.insert(0,item)

    def dequeue(self):
        """從頭部刪除一個元素"""
        #return self.__list.pop(0)
        return self.__list.pop()
    #根據具體應用，選擇是頭進尾出，還是尾進頭出

    def is_empty(self):
        """判斷一個隊列是否為空"""
        return self.__list==[]
if __name__=="__main__":
    s=Queue()
    print(s.is_empty())
    s.enqueue(1)
    print(s.is_empty())

    s.enqueue(2)
    print(s.dequeue())


执行结果：
True
False
1

 

class Deque(object):
    """雙端隊列"""

    def __init__(self):
        self.__list = []

    def add_front(self, item):
        """往隊列頭部添加一個item元素"""

        self.__list.insert(0, item)

    def add_behind(self,item):
        """往隊列尾部添加一個item元素"""
        self.__list.append(item)

    def pop_front(self):
        """從頭部取一個元素"""
        return self.__list.pop(0)

    def pop_rear(self):
        """從尾部刪除一個元素"""
        return self.__list.pop()
    

    def is_empty(self):
        """判斷一個隊列是否為空"""
        return self.__list == []