python数据结构——双向链表扩展

目录

1. 抛出问题

2. 代码实现与测试

2.1 代码实现

2.2 代码测试

3. 错误分析

3.1 创建双向链表后的结果

3.2 向链表添加元素后的结果

3.3 第二次判空求长度

 4. 结论

---

1. 抛出问题

        双向链表和单向链表有着共同的函数，如 is_empty()、length()、travel()等，那么双向链表能否继承这些函数？

2. 代码实现与测试

2.1 代码实现

# 节点
class Node(object):
    def __init__(self, item=None): 
        self.elem = item
        self.prev = None
        self.next = None


# 单向链表
class SingleLinkList(object):
    def __init__(self, node=None):
        # node 是结点
        self.__head = node

    def is_empty(self):  # 链表是否为空
        return self.__head is None

    def length(self):  # 链表长度
        cur = self.__head
        count = 0  # 记录长度
        while cur is not None:
            count += 1
            cur = cur.next
        return count

    def travel(self):  # 遍历整个链表
        cur = self.__head
        while cur is not None:
            print(cur.elem, end=" ")
            cur = cur.next
        print(" ")

    def add(self, item):  # 链表头部添加元素
        pass

    def append(self, item):  # 链表尾部添加元素
        pass

    def insert(self, pos, item):  # 指定位置添加元素
        pass

    def remove(self, item):  # 删除节点
        pass

    def search(self, item):  # 查找节点是否存在
        if self.is_empty():
            return False
        else:
            cur = self.__head
            while cur is not None:
                if cur.elem == item:
                    return True
                else:
                    cur = cur.next
            return False


class DoubleLinkList2(SingleLinkList):
    """
        通过继承单向链表的部分函数简化双向链表
    """

    def __init__(self, node=None):
        SingleLinkList.__init__(self, node)
        self.__head = node

    def add(self, item):  # 链表头部添加元素
        # item 是元素
        node = Node(item)
        self.__head.prev = node
        node.next = self.__head
        self.__head = node

    def append(self, item):  # 链表尾部添加元素
        # item 是元素
        node = Node(item)
        if self.is_empty():
            self.__head = node
        else:
            cur = self.__head
            while cur.next is not None:
                cur = cur.next
            node.prev = cur
            cur.next = node

    def insert(self, pos, item):  # 指定位置添加元素
        # pos 的位置从0起
        if pos <= 0:  # 头部插入
            self.add(item)
        elif pos > (self.length() - 1):  # 尾部插入
            self.append(item)
        else:  # 中间插入
            index = 0
            cur = self.__head
            while index < pos:
                index += 1
                cur = cur.next
            # 循环结束，cur在pos
            node = Node(item)
            node.prev = cur.prev
            node.next = cur
            node.prev.next = node  # 等价与 cur.prev.next=node
            node.next.prev = node  # 等价与 cur.prev=node

    def remove(self, item):  # 删除节点
        cur = self.__head
        while cur:
            if cur.elem == item:
                if cur == self.__head:  # 删除为头结点
                    self.__head = cur.next
                    if cur.next:
                        cur.next.prev = None
                else:  # 不在头结点
                    cur.prev.next = cur.next
                    if cur.next:
                        cur.next.prev = cur.prev
                return True
            else:
                cur = cur.next
        return False

2.2 代码测试

if __name__ == "__main__":
    ll = DoubleLinkList2()
    print(ll.is_empty())
    print(ll.length())

    ll.append(1)
    print(ll.is_empty())
    print(ll.length())

    ll.append(2)
    ll.add(8)
    ll.append(3)
    ll.append(4)
    ll.append(5)
    ll.append(6)
    ll.insert(-1, 9)
    ll.travel()  # 9 8 1 2 3 4 5 6
    ll.insert(3, 100)
    ll.travel()  # 9 8 1 100 2 3 4 5 6
    ll.insert(10, 200)
    ll.travel()  # 9 8 1 100 2 3 4 5 6 200
    ll.remove(100)
    ll.travel()  # 9 8 1 2 3 4 5 6 200
    ll.remove(9)
    ll.travel()  # 8 1 2 3 4 5 6 200
    ll.remove(200)
    ll.travel()  # 8 1 2 3 4 5 6



True
0
True
0
 
 
 
 
 
 

注意，0后面都成了空内容，并没有按正确答案输出，显然继承出现了错误。

3. 错误分析

3.1 创建双向链表后的结果

        通过调试模式，发现对象创建后有两个表头，而且是私有属性。

3.2 向链表添加元素后的结果

        在执行append(1)后，结果如下：

 通过调试结果可知，元素 1 已经被添加进双向链表中，此时单向链表的表头为空。

3.3 第二次判空求长度

        经过上一步append(1)后，结果应该是 False 、1 ，但是实际出现了True 、0。这表明访问链表时头指针不对。造成结果仍为空，长度为0。

 4. 结论

         通过上诉分析可知是链表的头出现了问题，导致访问内容不正确。

个人分析，不对之处欢迎指出