单向链表的操作

单向链表也叫单链表，是链表中最简单的一种形式，它的每个节点包含两个域，一个信息域（元素域）和一个链接域。这个链接指向链表中的下一个节点，而最后一个节点的链接域则指向一个空值。

表元素域elem用来存放具体的数据。 链接域next用来存放下一个节点的位置（python中的标识）

创建节点类

# 创建节点类
class Node(object):
    def __init__(self, elem):
        self.elem = elem
        self.next = None

创建单链表类

# 创建单链表类
class SingleLinkList(object):
    """单链表"""

    def __init__(self):
        self.__head = None  # 创建指针并私有化

判断链表是否为空

  def is_empty(self):
        """链表是否为空"""
        return self.__head is None

计算链表长度

 def length(self):
        """链表长度"""
        cur = self.__head  # 创建指针指向第一个节点
        count = 0  # 创建计数器默认从0开始
        while cur != None:  # 不断循环,移动指针,计数器同时加1
            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):
    """在链表头部添加元素"""
    # 1.创建节点
    node = Node(item)
    # 2.把新节点的next指向到第一个节点
    node.next = self.__head
    # 3.把self.__head指向node
    self.__head = node

在链表尾部添加元素

def append(self, item):
    """链表尾部添加元素"""
    # 1.创建item的节点
    node = Node(item)
    # 2.判断当前链表是否为空
    if self.is_empty():
        # 为空
        self.__head = node
    else:
        # 不为空
        # 先找到当前链表的最后一个节点
        cur = self.__head  # 创建指针cur指向第一个节点
        while cur.next != None:
            # while循环,不断地移动指针,直到最后一个节点为止
            cur = cur.next
        # 跳出循环后,指针指的就是最后一个节点
        # 把最后一个节点的next竖向指向到node节点
        cur.next = node

在链表指定位置添加元素

 def insert(self, pos, item):
        """指定位置添加元素"""
        # 1.创建节点
        node = Node(item)
        # 2.如果pos<=0,直接调用开头插入方法
        if pos <= 0:
            self.add(item)
        # 如果pos>链表长度,直接调用尾部追加方法
        elif pos > self.length():
            self.append(item)
        # 如果在中间插入
        else:
            cur = self.__head  # 创建指针cur指向第一个节点
            count = 0  # 创建计数器
            # 循环到pos前面位置的一个节点
            while count < pos - 1:
                count += 1
                cur = cur.next
            # 先把新节点的next指向到cur的next
            node.next = cur.next
            # 然后把cur的next指向新节点
            cur.next = node

在链表中删除指定元素的第一个节点

  def remove(self, item):
        """删除节点"""
        # 1.定义两个指针
        cur = self.__head  # 创建指针cur指向第一个节点
        pre = None  # 创建指针pre指向None
        # 2.不断循环,两个指针同时向后移动
        while cur != None:
            # 3.如果找到要删除的元素
            if cur.elem == item:
                # 3.1 如果第一个节点就是要删除的元素
                if cur == self.__head:
                    self.__head = cur.next
                else:
                    pre.next = cur.next
                return
            else:
                # 如果没有找到要删除的元素
                # 就要移动指针的顺序,先把pre指向cur, 再把cur指向cur.next
                pre = cur
                cur = cur.next
        # 循环完成之后,没有找到要删除的元素,就返回False
        return False

查找链表中某个元素是否存在节点中

 def search(self, item):
        """查找节点是否存在"""
        cur = self.__head  # 创建指针指向第一个节点
        # 不断循环,同时让指针向后移动
        while cur != None:
            # 如果指针所在节点和要查找的元素相同,返回True
            if cur.elem == item:
                return True
            cur = cur.next
        # 循环至最后也没有就会跳出循环,然后返回False
        return False

测试

if __name__ == '__main__':
    s = SingleLinkList()

    # 访问类的私有属性,不建议这么用
    # print(s._SingleLinkList__head)

    print(s.length())
    s.add(500)
    s.append(10)
    s.append(20)
    s.add(100)
    s.travel()  # 100 500 10 20
    print(s.length())
    s.append(30)
    s.add(200)  # 200 100 500 10 20 30
    s.travel()
    s.insert(2, 60)
    s.travel()
    s.insert(100, 120)
    s.travel()
    print(s.length())
    print(s.search(10))
    print(s.search(111))
    s.remove(10)
    s.travel()
    s.remove(200)
    s.travel()
    s.remove(120)
    s.travel()

下面是单向循环链表的操作，可以对比着看，找寻其中的差别，更利于学习

单向循环链表的操作