python学习笔记

数据结构（二）

单向链表完整版

class Node(object):
    def __init__(self,elem):
        #elem指数据元素
        self.elem=elem
        #指向下一个节点的链接域
        self.next=None

        #计算单向链表的长度
        def length(self):
            count=0
            curNode=self.__head
            while curNode != None:
                count +=1
                curNode = curNode.next
            return count

#构造单向链表类
class singleLinkList:
    #初始化方法
    def __init__(self,node=Node):
        if node != None:
            headNode = Node(node)
            self.__head = headNode
        else:
            self.__head = node
    #头部添加元素
    def add(self,item):
        #将传入的值构造成节点
        node = Node(item)
        #将新节点的链接域next指向头节点
        self.__head = node
    #在单向链表尾部追加元素
    def append(self,item):
        #将传入的值构造成新的节点
        node = Node(item)
        if self.is_empty():
            self.__head = node
        else: #单链表不为空
            curNode = self.__head
            while curNode.next != None:
                curNode = curNode.next
            #修改节点指向 最后一个节点的next指向node
            curNode.next = node
    #在指定位置添加元素

    def insert(self,pos,item):
        if pos <= 0:
            self.add(item)
        elif pos > (self.length() - 1):
            self.append(item)
        else:
            #构造节点
            node = Node(item)
            count = 0
            preNode = self.__head
            while count < (pos-1):  #找前一个节点
                count +=1
                preNode = preNode.next

            #修改指向
            #将前一个节点的next指向插入位置节点
            node.next = preNode.next
            #将插入位置的前一个节点的next指向新的节点
            preNode.next = node
    #删除节点
    def remove(self,item):
        curNode = self.__head
        preNode = None
        while curNode != None:
            if curNode.elem == item:
                if preNode == None:
                    self.__head = curNode.next
                else:
                    #删除
                    preNode.next = curNode.next
                break
            else:
                preNode = curNode
                curNode = curNode.next
    #查找节点是否存在
    def search(self,item):
        curNode = self.__head
        while curNode != None:
            if curNode.elem == item:
                return True
            curNode = curNode.next
        return False

    #判断单向链表是否为空
    def is_empty(self):
        # #判断head指向是None，如果是None则就是空链表
        # if self.__head == None:
        #     return True
        # else:
        #     retrun False
        return self.__head == None
    #计算单向链表的长度
    def length(self):
        count = 0
        curNode = self.__head
        while curNode != None:
            count += 1
            curNode = curNode.next
        return count
    def travel(self):
        curNode = self.__head
        while curNode != None:
            print(curNode.elem,end = '\t')
            curNode = curNode.next
        print("")

if __name__=='__main__':
    #初始化元素值为20的单向链表
    singleLinkList=singleLinkList(20)
    #初始化一个空的单向链表
    #singleLinkList = SingleLinkList()
    print('是否是空链表：',singleLinkList.is_empty())
    print('链表的长度：',singleLinkList.length())
    print("遍历单链表")
    singleLinkList.travel()
    print('查找')
    print(singleLinkList.search(20))
    print(singleLinkList.search(30))
    print('头部插入')
    singleLinkList.add(1)
    singleLinkList.add(2)
    singleLinkList.add(3)
    singleLinkList.travel()
    print('尾部追加')
    singleLinkList.append(10)
    singleLinkList.append(20)
    singleLinkList.append(30)
    singleLinkList.travel()
    print('指定位置插入')
    singleLinkList.insert(2,100)
    singleLinkList.travel()
    print('删除节点')
    singleLinkList.remove(100)
    singleLinkList.travel()

双向链表

class Node:
    def __init__(self, elem):
        self.elem = elem
        self.next = None #后继  下一个节点
        self.prev = None  #前一个节点

class DoubleLinkList:
    # 初始化方法
    def __init__(self, node=Node):
        if node != None:
            headNode = Node(node)
            self.__head = headNode
        else:
            self.__head = node

    # 头部添加元素
    def add(self, item):
        #将传入的值构造成节点
        node = Node(item)
        #判断是否是空链表
        if self.is_empty():
            self.__head = node
        else:
            # 将新节点的链接域next指向头节点
            node.next = self.__head
            # 将__head的头节点的prev指向node
            self.__head.prev = node
            #将链表的头__head指向新节点
            self.__head = node

    # 在单向链表尾部追加元素
    def append(self, item):
        # 将传入的值构造成新的节点
        node = Node(item)
        if self.is_empty():
            self.__head = node
        else:  # 链表不为空
            curNode = self.__head
            while curNode.next != None:
                curNode = curNode.next
            # 修改节点指向 最后一个节点的next指向node
            curNode.next = node
            #将node节点的前驱指向当前节点
            node.prev = curNode

    # 在指定位置添加元素

    def insert(self, pos, item):
        if pos <= 0:
            self.add(item)
        elif pos > (self.length() - 1):
            self.append(item)
        else:
            # 构造节点
            node = Node(item)
            count = 0
            curNode = self.__head
            while count < (pos - 1):  # 找前一个节点
                count += 1
                curNode = curNode.next

            # 修改指向
            #将node节点的前驱指向当前节点
            node.prev = curNode
            #将node节点的后继指向当前节点的下一个节点
            node.next = curNode.next
            #将当前节点的下一个节点的前驱指向node节点
            curNode.next.prev = node
            #将当前节点的后继指向node节点
            curNode.next = node

    # 删除节点
    def remove(self, item):
        curNode = self.__head
        preNode = None
        while curNode != None:
            if curNode.elem == item:
                #判断是否是头节点
                if curNode == self.__head:    #是头节点
                    self.__head = curNode.next
                    #判断当前节点是否只有一个节点，如果只有一个节点，则不需要移动到下一个节点的前端
                    if curNode.next:
                        curNode.next.prev = None
                else:
                    # 删除
                    curNode.prev.next = curNode.next
                    #判断当前节点是否是最后一个 如果是最后一个节点 最后一个节点的下一个节点指向None
                    if curNode.next:
                        curNode.next.prev = curNode.prev
                break
            else:
                preNode = curNode
                curNode = curNode.next

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

    # 判断单向链表是否为空
    def is_empty(self):
        # #判断head指向是None，如果是None则就是空链表
        # if self.__head == None:
        #     return True
        # else:
        #     retrun False
        return self.__head == None

    # 计算单向链表的长度
    def length(self):
        count = 0
        curNode = self.__head
        while curNode != None:
            count += 1
            curNode = curNode.next
        return count

    def travel(self):
        curNode = self.__head
        while curNode != None:
            print(curNode.elem, end='\t')
            curNode = curNode.next
        print("")

if __name__ == '__main__':
    doubleLinkList = DoubleLinkList()
    doubleLinkList.add(11)
    doubleLinkList.add(22)
    doubleLinkList.add(33)
    doubleLinkList.travel()
    print('指定位置插入')
    doubleLinkList.insert(-1,44)
    doubleLinkList.travel()
    doubleLinkList.insert(100,400)
    doubleLinkList.travel()
    doubleLinkList.insert(2,1000)
    doubleLinkList.travel()
    print('删除节点')
    doubleLinkList.remove(44)
    doubleLinkList.travel()
    doubleLinkList.remove(100)
    doubleLinkList.travel()
    print('链表长度：',doubleLinkList.length())
    print('查找节点11',doubleLinkList)