python数据结构学习笔记-2016-10-27-02-使用单链表实现包ADT

       6.3 使用单链表实现包ADT

       6.3.1 实现

#-*-coding: utf-8-*-

# 使用单链表实现包ADT

class Bag(object):
    def __init__(self):
        self._head = None # 底层单链表头指针
        self._size = 0 # 追踪单链表长度

    def __len__(self):
        return self._size

    def __contains__(self, target):
        curNode = self._head
        while curNode is not None and curNode.item != target:
            curNode = curNode.next
        return curNode is not None

    # 此处add()方法，就是在单链表补插
    def add(self, item):
        newNode = _BagListNode(item)
        newNode.next = self._head
        self._head = newNode
        self._size += 1

    def remove(self, item):
        # 让临时工作指针指向对应数据
        predNode = None
        curNode = self._head
        while curNode is not None and curNode.item != item:
            predNode = curNode
            curNode = curNode.next

        assert curNode is not None, "The item must be in the bag."
        self._size -= 1
        if curNode is head:
            self._head = curNode.next
        else:
            predNode.next = curNode.next
        return curNode.item

    def __iter__(self):
        return _BagIterator(self._head)

class _BagListNode(object):
    def __init__(self, item):
        self.item = item
        self.next = None

class _BagIterator(object):
    def __init__(self, listHead):
        self._curNode = listHea
    
    def __iter__(self):
        return self

    def next(self):
        if self._curNode is None:
            raise StopIteration
        else:
            item = self._curNode.item
            self._curNode = self._curNode.next
            return item

        6.3.2 两种实现方法的比较

操作	python列表	单链表
b = Bag()	O(1)	O(1)
n = len(b)	O(1)	O(1)
x in b	O(n)	O(n)
b.add(x)	O(n)	O(1)
b.remove(x)	O(n)	O(n)
遍历	O(n)	O(n)

        可以看到，两种实现方法的主要区别在于添加元素时。使用python列表添加元素时，最坏情况是底层数组正好要扩容时，而使用单链表添加元素，只需要在首元结点前添加结点并让头指针指向新节点即可。

        链表适用于含大量动态数据的情况，即添加删除元素非常频繁，而python列表便于通过索引访问元素，其时间复杂度是O(1)，而使用链表去访问元素得效率就相对较低，其时间复杂度是O(n)。