python ：单向链表的实现

（1）单向链表：

单向链表：有一个头结点和一个尾部节点
节点：每个节点有拥有一个元素域和指针域，尾节点的指针域指向空

（2）模拟单向链表
length() 链表的长度
is_empty() 判断链表是否为空
add_first(element) 向链表的头部添加元素

 def add_first(self,item):   #向头部添加元素
        """
        1.创建一个新的节点
        2.新节点指向下个节点
        3.将新节点设置为头结点
        """
        node = self.Node(item)     #创建的新节点
        if self.is_empty() :     #如果尾空，那么新节点指向None,并将新节点赋值与self._head
            node.next = None
            self._head = node
        else :
            node.next =self._head
            self._head = node
        self._size +=1

add_last(element) 向链表的尾部添加元素

    def add_last(self,item):    #向尾部添加元素
        """
        如果链表为空 :
        1.直接创建一个新的节点，指向为空
        如果链表非空：
        1.遍历整个链表直到尾部节点的前一个节点cur
        2.将新节点的下一下赋值给cur
        """
        if self.is_empty() :
            return False
        else :
            node = self.Node(item)
            node.next = None     #创建一个空节点
            cur = self._head
            while cur.next != None :
                cur = cur.next       #遍历到链表的最后一个节点
            cur.next= node
            self._size += 1

insert_element(element) 向链表中添加元素

 def insert_element(self,pros,element):
        if self.is_empty() or pros < 0 or pros >self._size :
            return False
        elif pros == 0 :    #如果指定下标为0，那么将新节点添加在链表头部
            self.add_first(element)
        else :
            node = self.Node(element)
            cur = self._head
            count = 0
            while cur.next != None :   #遍历到指定的下标处
                if count == pros -1 :
                    node.next = cur.next  
                    cur.next = node
                    break
                count += 1
                cur = cur.next
        self._size += 1

del_first(）删除头部节点

 def del_first(self):  #删除头部节点
        """
        如果链表为空：返回False
        如果链表非空：
        1.将当前结点的下一指向赋值于头结点
        """
        if self.is_empty() :
            return False
        cur = self._head
        self._head = cur.next

del_between() 删除指定位置的节点

 def del_between(self,pors): #删除指定位置的节点
        if self.is_empty() or pors < 0 or pors > self._size :
            return False
        elif pors == 0:
            self.del_first()
        else :
            cur = self._head
            count = 0
            while count < pors :
                if count == pors - 1:
                   cur.next = cur.next.next     #核心
                   break
                count += 1
                cur = cur.next
        self._size -= 1

change() 更新指定位置的节点元素

 def change(self,index,num):   #更新摸个指定节点的元素值
        if self.is_empty() or index < 0 or index > self._size :
            return False
        else :
            cur =self._head
            count = 0
            while count < index :
                cur = cur.next
                count += 1
            cur.data = num

get_list() 得到整个链表的节点元素

  def get_list(self):
        if self.is_empty() :
            return False
        cur = self._head
        while cur :
            print(cur.data,end=" ")
            cur = cur.next

get_index()得到指定位置的节点元素

        if self.is_empty() or pros < 0  or pros >self._size :
            return  False
        else :
            cur = self._head
            count = 0
            while count < pros :  #遍历到指定的节点
                cur = cur.next
                count += 1
            return cur.data

实现框架：

class LinkList :
    class Node :                 #节点类，存放节点的元素与指针
        def __init__(self,data):
            self.data = data
            self.next = None
    def __init__(self,node= None):       #初始化头节点
        self._head = node
        self._size = 0

python ：单向链表的实现

猜你喜欢