数据结构一：python实现简单的单向链表

参照python基本数据类型list实现部分功能 ：

#!/usr/bin/env python
# -*- coding: utf-8 -*-


class BaseNode(object):
    """
    结点
    """
    def __init__(self, item):
        # 结点的值
        self.item = item
        # 下一个结点
        self.next = None

class SingleLinkedList(object):
    """
    单项链表
    保存一个链表只需要保存它的头结点即可
    """

    def __init__(self, node=None):
        # 头结点
        self.head = node

    def is_empty(self):
        """
        判断链表好似否为空
        :return: bool
        """
        return self.head is None

    def length(self):
        """
        链表的长度
        :return: 链表的结点个数
        """
        # 用于记录链表的结点个数
        length = 0
        # 获取头结点
        node = self.head
        # 如果当前结点不是None
        while node:
            # 结点个数加1
            length += 1
            # 将当前结点指定到下个结点
            node = node.next
        # 返回结点个数
        return length

    def __str__(self):
        """
        打印实例时的输出
        :return:
        """
        # 获取头结点
        node = self.head
        travel = "["
        while node:
            if node == self.head:
                travel += str(node.item)
            else:
                travel += ", %r" % node.item
            node = node.next
        return travel + "]"

    def search(self, item):
        """
        查询值是否在链表中
        :param item: 要查询的值
        :return: bool
        """
        # 获取头结点
        node = self.head
        # 如果当前结点不为None
        while node:
            # 如果当期按结点的值等于要查询的值
            if node.item == item:
                # 返回True
                return True
            node = node.next
        else:
            # 如果所有结点的值都不等于要查询的值  返回False
            return False

    def add(self, item):
        """
        从头部添加一个结点
        item: 将要添加的结点的值
        :return: None
        """
        # 创建结点
        new_node = BaseNode(item)
        # 把将要添加的结点的下一个结点指向链表的头结点，并将链表的头结点指向将要添加的结点
        new_node.next, self.head = self.head, new_node

    def append(self, item):
        """
        从尾部添加一个结点
        :param item: 将要添加的结点的值
        :return: None
        """
        # 创建新结点
        new_node = BaseNode(item)
        # 如果链表为空
        if self.head is None:
            # 则将链表的头结点指向新结点
            self.head = new_node
        else:
            # 获取头结点
            node = self.head
            # 如果当前结点不为None
            while node.next:
                # 将当前结点指向下一个结点
                node = node.next
            # 将当前结点的下一个结点指向新结点
            node.next = new_node

    def insert(self, site, item):
        """
        插入数据
        :param site: 插入的位置
        :param item: 插入的值
        :return:
        """
        # 判断位置参数是否是int类型
        if not isinstance(site, int):
            raise TypeError("site must be integers")
        # 如果要插入的位置小于等于0
        if site <= 0:
            # 从头部添加
            self.add(item)
        # 如果要插入的位置大于或等于链表的最大长度
        elif site >= self.length():
            # 从尾部添加
            self.append(item)
        else:
            # 创建新结点
            new_node = BaseNode(item)
            # 获取头结点
            node = self.head
            # 获取要插入的上一个结点
            for i in range(site - 1):
                node = node.next
            # 将新的结点的下一个结点指向当前结点的下一个结点 并把当前结点的下一个结点指向新结点
            new_node.next, node.next =  node.next, new_node

    def clear(self):
        """
        清空链表
        :return:
        """
        self.head = None

    def __getitem__(self, site):
        """根据索引取出对应的值"""
        # 判断位置参数是否是int类型
        if not isinstance(site, int):
            raise TypeError("site must be integers")
        if self.length() <= site:
            raise IndexError('Out of range')
        node = self.head
        for i in range(site):
            node = node.next
        return node.item

    def __setitem__(self, site, item):
        """
        设置结点的值
        :param site: 结点位置
        :param item: 要修改值
        :return:
        """
        # 判断位置参数是否是int类型
        if not isinstance(site, int):
            raise TypeError("site must be integers")
        if self.length() <= site:
            raise IndexError('Out of range')
        node = self.head
        for i in range(site):
            node = node.next
        node.item = item

    def remove(self, item):
        """
        根据值删除结点
        :param item: 要删除的值
        :return:
        """
        if self.head:
            # 获取头结点
            node = self.head
            # 如果头结点是要删除的结点
            if node.item == item:
                # 将头结点指向当前头结点的下一个结点
                self.head = node.next
                # 返回
                return
            # 如果当前结点有下一个结点
            while node.next:
                # 如果当前结点的下一个结点是要删除的节点
                if node.next.item == item:
                    # 将当前结点的下一个结点指向当前结点的下下个节点
                    node.next = node.next.next
                    # 返回
                    return
                # 将当前结点指向下一个结点
                node = node.next
        # 如果以上条件都不满足 则说明值不在链表内
        raise ValueError('item not in SingleLinkedList')

顺序表和链表的区别参考：https://blog.csdn.net/Y1730008223CONG/article/details/68958022