算法—详细讲解单向链表的实现（python）

一、链表

链表是一种物理存储单元上非连续、非顺序的存储结构
数据元素的逻辑顺序通过链表中的指针链接次序实现
链表由一系列节点组成，节点可以在运行时动态生成
每个节点包含两个部分：存储数据元素的数据区、存储下一个节点地址的指针域
每去存储一个数据就去申请一个节点

二、单向链表特点：

无法根据某一个节点去访问前一个节点
第一个节点为头节点
最后一个节点的指针域为空，称为尾节点

三、单向链表的实现

链表头部新增一个节点

1、新建一个节点

    node=Node(data)
    if not self.head:
        # 再让链表的head指向当前node节点
        self.head = node
    else:
        # 先让node指向当前链表中的头节点
        node.next=self.head
        #再让链表的head指向当前node节点
        self.head=node
        #添加节点之后，链表的长度加1
        self._length+=1

链表尾部新增一个节点

2、新建一个节点node，值为data

    node=Node(data)
    # 找到链表的尾节点
    # 思路：从头节点开始遍历链表中的所有节点
    # 每次判断当前节点的next是否为空
    # 为空这说明当前节点就是尾节点
    # 不为空，通过当前节点的next方法去访问下一个节点，
    if self.head:
        cur=self.head   #将头节点的地址赋给了变量cur
        while cur.next:
            cur=cur.next
        cur.next = node
    else:
        self.head=node
    # 让当前的尾节点的指针指向新建的节点node
    # 链表的长度加1
    self._length+=1

链表中插入一个新的节点

    if pos<=0:
        self.add(data)
    elif pos>self._length:
        self.append(data)
    else:
        # 1新建一个节点
        node = Node(data)
        # 2找到链表中索引为pos-1的节点
        cur=self.head
        while pos-1:
            cur=cur.next
            pos-=1
        #到这里之后，cur指向的是索引为pos-1的节点
        # 3让node的next指向索引为pos的节点
        node.next=cur.next
        # 4让索引为pos-1的节点的next指向node
        cur.next=node
        # 5链表的长度加1
        self._length+=1

删除链表中第一个值为data的节点

一、当删除的节点为头节点时：

二、当删除的节点为非头节点

	   cur=self.head
       prev=None    #要删除节点的前驱节点
       while cur:
           if cur.data==data:
               #如果前驱节点为空，说明我们要删除的节点是第一个节点
               if not prev:
                   self.head=cur.next
               else:
                   prev.next = cur.next
               self._length-=1
               return 0
           prev=cur
           cur = c

修改链表中指定位置的值

    if 0<pos<self._length:
        cur = self.head
        while pos:
            cur = cur.next
            pos -= 1
        cur.data=data
    else:
        print('输入的范围不符合要求')

查找链表中是否有节点的值为data

例如：search(4)
		cur = self.head
        while cur:
            if cur.data == data:
                return True
            cur = cur.next
        return False

代码块为：

class Node:

    def __init__(self, data, _next=None):
        self.data = data  # 数据域
        self.next = _next  # 指针域


class SingleLinkList:

    def __init__(self):
        self.head = None  # 链表的的头节点
        self._length = 0  # 链表的长度，链表的元素个数

    def is_empty(self):
        # 判断链表的是否为空
        return self._length==0

    def length(self):
        # 返回链表的长度
        return self._length

    def nodes_list(self):
        # 返回链表中的所有节点的值组成的列表
        res=[]
        cur=self.head
        while cur:
            res.append(cur.data)
            cur=cur.next
        return res


    def add(self, data):
        # 往链表的头部添加一个节点，值为data
        # 新建一个节点
        node=Node(data)
        # 先让node指向当前链表中的头节点
        node.next=self.head
        #再让链表的head指向当前node节点
        self.head=node
        #添加节点之后，链表的长度加1
        self._length+=1

    def append(self, data):
        # 往链表的尾部添加一个节点，值为data
        # 新建一个节点node，值为data
        node=Node(data)
        # 找到链表的尾节点
        # 思路：从头节点开始遍历链表中的所有节点
        # 每次判断当前节点的next是否为空
        # 为空这说明当前节点就是尾节点
        # 不为空，通过当前节点的next方法去访问下一个节点，
        if self.head:
            cur=self.head   #将头节点的地址赋给了变量cur
            while cur.next:
                cur=cur.next
            cur.next = node
        else:
            self.head=node
        # 让当前的尾节点的指针指向新建的节点node
        # 链表的长度加1
        self._length+=1
    def insert(self, pos, data):
        # 往链表的指定位置插入一个节点，值为data
        if pos<=0:
            self.add(data)
        elif pos>self._length:
            self.append(data)
        else:
            # 1新建一个节点
            node = Node(data)
            # 2找到链表中索引为pos-1的节点
            cur=self.head
            while pos-1:
                cur=cur.next
                pos-=1
            #到这里之后，cur指向的是索引为pos-1的节点
            # 3让node的next指向索引为pos的节点
            node.next=cur.next
            # 4让索引为pos-1的节点的next指向node
            cur.next=node
            # 5链表的长度加1
            self._length+=1

    def remove(self, data):
        # 删除链表中第一个值为data的节点
        cur=self.head
        prev=None    #要删除节点的前驱节点
        while cur:
            if cur.data==data:
                #如果前驱节点为空，说明我们要删除的节点是第一个节点
                if not prev:
                    self.head=cur.next
                else:
                    prev.next = cur.next
                self._length-=1
                return 0
            prev=cur
            cur = cur.next
        return -1

    def modify(self, pos,data):
        # 修改链表中指定位置节点的值
        if 0<pos<self._length:
            cur = self.head
            while pos:
                cur = cur.next
                pos -= 1
            cur.data=data
        else:
            print('输入的范围不符合要求')

    def search(self, data):
        # 查找链表中是否有节点的值为data
        cur = self.head
        while cur:
            if cur.data == data:
                return True
            cur = cur.next
        return False

if __name__ == '__main__':
    l1=SingleLinkList()    #新建一个链表类
    print(l1.head,l1.length())
    l1.add(1)
    print(l1.head.data, l1.length())