python算法9.24——链表

# 一种基本的数据结构，通过指针实现各节点的关联
# 1.在python中实现，使用类node代替C语言中结构体节点
# 2.属性：链表长度length、链表头指针head
# 3.方法：增（追加、插入）、删、改、查，清空、打印
# 参考：https://blog.csdn.net/lvhuiyang/article/details/53572238；#https://www.cnblogs.com/king-ding/p/pythonchaintable.html

class Node:
    def __init__(self, data, pnext=None):
        self.data = data
        self.pnext = pnext

    # 节点可打印，并输出data
    def __repr__(self):
        return str(self.data)




class LinkedList:
    def __init__(self):
        self.size = 0
        self.head = None

    def __repr__(self):
        show = ''
        if self.isEmpty():
            show = 'the linked list is empty!'
        else:
            curNode = self.head
            show = 'Head'
            while curNode:
                strNode = '-->Node '+ str(curNode)
                show += strNode
                curNode = curNode.pnext
            show += '-->None'
        return show

    def isEmpty(self):
        return self.size == 0

    def append(self,item):
        # 首先判断追加的是节点还是节点数据
        if isinstance(item,Node):
            pass
        else:   # 如果添加的是数据，将其转换为节点类型
            item = Node(item)
        # 判断链表是否为空
        if self.isEmpty():
            self.head = item
        else:   # 如果不为空，将原链表末端节点指向新添加节点
            node = self.head
            while node.pnext:
                node = node.pnext
            node.pnext = item
        self.size += 1

    def insert(self,item,index):
        if type(index) is int:
            if index > self.size or index < 0:     # 允许插入的最大位置是末尾，最小位置是第一位置
                raise Exception("Wrong operation! The index is out of range!")
            else:
                if isinstance(item, Node):
                    pass
                else:
                    item = Node(item)
                # 标记插入处节点，先将插入节点指向后节点，再将原节点指向插入节点
                curNode = self.head
                if index == 0:
                    item.pnext = curNode
                    self.head = item
                else:
                    while index-1:
                        curNode = curNode.pnext
                        index -= 1
                    item.pnext = curNode.pnext
                    curNode.pnext = item
                self.size += 1
                return
        else:
            raise Exception("Wrong operation! Wrong index type (int is required)!")

    def delete(self,index):
        if type(index) is int or index < 0:
            if index > self.size:
                raise Exception("Wrong operation! The index is out of range!")
            else:
                # 标记删除处前一节点，将前节点指向后节点
                curNode = self.head
                if index == 0:
                    self.head = self.head.pnext
                else:
                    while index-1:
                        curNode = curNode.pnext
                        index -= 1
                    curNode.pnext = curNode.pnext.pnext
                    self.size -= 1
                return
        else:
            raise Exception("Wrong operation! Wrong index type (int is required)!")

    def update(self,data,index):
        if type(index) is int:
            if index > self.size or index < 0:
                raise Exception("Wrong operation! The index is out of range!")
            else:
                # 标记更新处前一节点，更改更新处节点的数据
                curNode = self.head
                if index == 0:
                    curNode.data = data
                else:
                    while index - 1:
                        curNode = curNode.pnext
                        index -= 1
                    curNode.pnext.data = data
                    self.size -= 1
                return
        else:
            raise Exception("Wrong operation! Wrong index type (int is required)!")

    def searchOnIndex(self,index):
        if type(index) is int:
            if index > self.size or index < 0:
                raise Exception("Wrong operation! The index is out of range!")
            else:
                # 标记查询处前一节点，返回查寻处节点
                curNode = self.head
                if index == 0:
                    return curNode
                else:
                    while index - 1:
                        curNode = curNode.pnext
                        index -= 1
                return curNode.pnext
        else:
            raise Exception("Wrong operation! Wrong index type (int is required)!")

    def searchOndata(self,data):
        if self.isEmpty():
            raise Exception("Wrong operation! The linked list is empty!")
        else:
            # 标记节点，遍历比较
            curNode = self.head
            while curNode:
                if curNode.data == data:
                    # print('data is found in linked list!')
                    return curNode
                else:
                    curNode = curNode.pnext
            else:
                # print('data is not found in linked list!')
                return

    def isExisted(self,data):
        if self.searchOndata(data):
            return True
        else:
            return False

    def clear(self):
        self.head = None
        self.size = 0

if __name__ == '__main__':
    node1 = Node('data')
    ll = LinkedList()
    ll.append(node1)
    ll.append('node2')
    ll.append('node3')
    print(ll)
    ll.insert('first',1)
    print(ll)
    ll.delete(0)
    ll.delete(2)
    print(ll)
    ll.update('second',1)
    print(ll)
    re1 = ll.searchOnIndex(1)
    print(re1)
    print(ll.isExisted('first'))