python - 单链表1

Q：为什么要写链表？只用list不行么？

A：链表(linked list)这一数据结构具体有哪些实际应用？ - 知乎

目前我能看懂的部分：

1. 插入和删除的效率高，不用遍历。
2. 只要你读源码，你就会发现 hash、链表、红黑树 真是无处不在--（知乎chappie的回答）

学习：Python 数据结构之链表 - 知乎

链表是一种非连续、非顺序的数据结构。由两部分组成：数据+指针。指针指向下一个节点。

缺点：不能随机读取；空间开销大。不可迭代！

优点：插入和删除快；存储管理灵活。

单链表

head -> item|next ->item|next -> ... -> item|NULL

代码参考：《python数据结构与算法分析》

# 定义节点
class Node():
    def __init__(self,initData):
        self.data=initData
        self.next=None
    
    def getData(self):
        return self.data
    
    def getNext(self):
        return self.next
    
    def setData(self,newData):
        self.data=newData
        # set是个操作，不用 return self.data
    
    def setNext(self,newNext):
        self.next=newNext

class unorderedList():
    def __init__(self):
        self.head=None
    
    # 判断是否为空，即head是否指向None
    def isEmpty(self):
        return self.head==None
    
    # 找个最方便插入的地方插入，即链表头部。
    # 插入一个节点，把新节点temp和已有的链表的头部(head指向的节点)连接起来，再更改head的位置。
    def add(self,item):
        temp=Node(item)
        temp.setNext(self.head)
        self.head=temp
    
    # length\search\remove 都需要遍历

    def length(self):
        current=self.head
        count=0
        while current!=None:
            count+=1
            current=current.getNext()
        return count
    
    def search(self,item):
        found=False # 没找到就返回False
        current=self.head
        while current!=None and not found:
            if current.getData()==item:
                return True
            current=current.getNext()
        return found
    
    # 退出遍历的时候，current已经指向了要删掉的节点，而我们需要设置前一个节点的next，所以我们再加一个指针。用两个指针“蠕动”。
    def remove(self,item):
        found=False
        current=self.head
        previous=None
        while not found:
            if current.getData()==item:
                found=True
            else:
                previous=current
                current=current.getNext()
        if previous==None:
            self.head=current.getNext()
        else:
            previous.setNext(current.getNext())
    
    def append(self,item):
        current=self.head
        item=Node(item)
        if current==None:
            self.head=item
        else:
            while current.getNext()!=None:
                current=current.getNext()
            item.setNext(None)
            current.setNext(item)

    def insert(self,loc,item):
        len=self.length()
        if loc<=0:
            self.add(item)
        elif loc>len-1:
            self.append(item)
        else:
            item=Node(item)
            current=self.head
            for i in range(loc-1): # head 的next是链表的[0]
                current=current.getNext()
            item.setNext(current.getNext())
            current.setNext(item)
        
    def items(self):
        current=self.head
        while current !=None:
            yield current.data
            current=current.getNext()
        
if __name__=="__main__":
    myList=unorderedList()
    print(myList) # <__main__.unorderedList object at 0x00F9F7F0>

    for i in range(5):
        myList.add(i)
    print(list(myList.items()))  # [4, 3, 2, 1, 0]

    len=myList.length()
    print(len) # 5

    print(myList.search(3)) # True

    myList.remove(4)
    print(list(myList.items())) # [3,2,1,0]

    myList.append(10)
    print(list(myList.items())) # [3, 2, 1, 0, 10]

    myList.insert(-1,9)
    myList.insert(3,99)
    myList.insert(100,50)
    print(list(myList.items())) # [9, 3, 2, 99, 1, 0, 10, 50]

学会了写单链表、使用yield遍历链表。开心！

但是感觉写得复杂了。再看看别人的代码，学习学习！