zoukankan      html  css  js  c++  java
  • python 链表实现 单链表

      1.  链表的定义

        链表是一种基础数据结构,是一种线性表,不想顺序表一样连续存储数据,而是在每一个节点(数据存储单元)里存放下一个节点的位置信息(即地址)。

      1.1  单链表

      

      表元素域elem用来存放具体的数据

      链接域next用来存放于下一个节点的位置

      变量p指向链表的头节点的位置,从p出发能找到表中的任意节点

        节点实现:

    class Node(object):
        #单链表节点类实现
        def __init__(self,elem):
            self.elem = elem
            self.next = None

      单链表的操作

    • is_empty() 链表是否为空
    • length() 链表长度
    • travel() 遍历整个链表
    • add(item) 链表头部添加元素
    • append(item) 链表尾部添加元素
    • insert(pos, item) 指定位置添加元素
    • remove(item) 删除节点
    • search(item) 查找节点是否存在

      单链表的实现:

    class SingleLinkList(object):
        #单链表类实现
        def __init__(self,node=None):
            self.__head = node
            
        def is_empty(self):
            #判断链表是否为空
            return self.__head == None
            
        def length(self):
            #链表的长度
            #cur游标,用来遍历节点,count记录数量
            cur = self.__head
            count = 0
            while cur != None:
                count += 1
                cur = cur.next  #将cur后移一个节点
            return count
            
        def travel(self):
            #遍历链表
            cur = self.__head
            while cur != None:
                print(cur.elem,end=' ')
                cur = cur.next
            print('')

      头部添加元素,在插入的时候,一般不先破坏原始链表的结构,而是先用新的节点指向。

          插入节点前

          插入节点后的状态

        def add(self,item):
            #在链表头部添加节点
            node = Node(item)
            node.next = self.__head
            self.__head = node

      尾部添加元素

        def append(self,item):
            #在链表尾部添加节点
            node = Node(item)
            if self.is_empty():
                self.__head = node
            else:
                cur = self.__head
                while cur.next != None:
                    cur = cur.next
                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:
                pre = self.__head
                count = 0
                while count < (pos-1):
                    count += 1
                    pre = pre.next
                #当退出循环后,pre指向pos-1位置
                node = Node(item)
                node.next = pre.next
                pre.next = node

      删除节点

        def remove(self,item):
            #移除节点
            cur = self.__head
            pre = None
            while cur != None:
                if cur.elem == item:
                    #先判断此节点是否是头节点
                    #头节点
                    if cur == self.__head:
                        self.__head = cur.next
                    else:
                        pre.next = cur.next
                    break
                else:
                    pre = cur
                    cur = cur.next

      查找节点

        def search(self,item):
            #查找节点
            cur = self.__head
            while cur != None:
                if cur.elem == item:
                    return True
                else:
                    cur = cur.next
            return False

      完整代码:

    class Node(object):
        #单链表节点类实现
        def __init__(self,elem):
            self.elem = elem
            self.next = None
    
    class SingleLinkList(object):
        #单链表类实现
        def __init__(self,node=None):
            self.__head = node
            
        def is_empty(self):
            #判断链表是否为空
            return self.__head == None
            
        def length(self):
            #链表的长度
            #cur游标,用来遍历节点,count记录数量
            cur = self.__head
            count = 0
            while cur != None:
                count += 1
                cur = cur.next
            return count
            
        def travel(self):
            #遍历链表
            cur = self.__head
            while cur != None:
                print(cur.elem,end=' ')
                cur = cur.next
            print('')
        def add(self,item):
            #在链表头部添加节点
            node = Node(item)
            node.next = self.__head
            self.__head = node
            
        def append(self,item):
            #在链表尾部添加节点
            node = Node(item)
            if self.is_empty():
                self.__head = node
            else:
                cur = self.__head
                while cur.next != None:
                    cur = cur.next
                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:
                pre = self.__head
                count = 0
                while count < (pos-1):
                    count += 1
                    pre = pre.next
                #当退出循环后,pre指向pos-1位置
                node = Node(item)
                node.next = pre.next
                pre.next = node
            
        def remove(self,item):
            #移除节点
            cur = self.__head
            pre = None
            while cur != None:
                if cur.elem == item:
                    #先判断此节点是否是头节点
                    #头节点
                    if cur == self.__head:
                        self.__head = cur.next
                    else:
                        pre.next = cur.next
                    break
                else:
                    pre = cur
                    cur = cur.next
            
        def search(self,item):
            #查找节点
            cur = self.__head
            while cur != None:
                if cur.elem == item:
                    return True
                else:
                    cur = cur.next
            return False
    
    if __name__ == '__main__':
        ll = SingleLinkList()
        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()
        ll.insert(3,100)
        ll.travel()
        ll.insert(10,200)
        ll.travel()
        ll.remove(100)
        ll.travel()
        ll.remove(9)
        ll.travel()
        ll.remove(200)
        ll.travel()
    '''
    运行结果:    
    True
    0
    False
    1
    9 8 1 2 3 4 5 6
    9 8 1 100 2 3 4 5 6
    9 8 1 100 2 3 4 5 6 200
    9 8 1 2 3 4 5 6 200
    8 1 2 3 4 5 6 200
    8 1 2 3 4 5 6
    '''        
    View Code
  • 相关阅读:
    用户行为分析之实时数据采集
    用户行为分析之离线数据采集
    RDDs之combineByKey()
    KeyValue对RDDs
    RDD基本操作之Action
    RDDs基本操作之Transformations
    Spark学习之Scala的基础知识
    Spark学习之RDDs介绍
    查看mysql中的用户和密码
    mysql-connector-java-5.-bin.jar 下载方法
  • 原文地址:https://www.cnblogs.com/homle/p/8848047.html
Copyright © 2011-2022 走看看