python实现单向链表

在C语言中，用指针来实现单向链表非常简单。而python是不存在指针这种结构的，但我们也可以实现链表数据结构，使用类和对象的引用即可达到C语言中的指针的效果。

图片来自于网络

图中我们可以看到，单向链表的每一个节点会包含两项数据，当前节点的元素，以及对下一个节点的引用（C语言中就是指针）。并且最后一个元素的引用为None(C语言中就是NULL).

下面我们定义节点对象

class Node(object):
    def __init__(self, value):
        self.value = value
        self.next = None

通过实例化这个Node类，我们就可以生成一个节点，并且每个节点会包含一个元素value，以及next（指向下一个节点）默认为None.

下面实现我们的单向链表

class Link(object):
    def __init__(self):
        """
        初始化一个头节点，并赋予为head
        """
        self.first = Node('head')

    def add(self, value):
        """
        添加一个节点
        """
        p = self.first
        newnode = Node(value)
        while p.next:
            p = p.next
        else:
            p.next = newnode

    def remove(self, value):
        """
        移除值为value的节点
        如果有重复的值，只会移除第一次出现的节点
        默认认为value一定在链表中
        """
        p = self.first
        while p.next:
            temp = p.next
            if temp.value == value:
                p.next = temp.next
                del temp
                break
            else:
                p = p.next

    def insert(self, value, index):
        """
        在指定的位置插入一个节点
        index必须大于等于1
        如果为0的话，我们定义的头结点就没意义了
        如果插入的位置大于当前链表的长度，就插入到链表的末尾
        """
        i = 0
        p = self.first
        newnode = Node(value)
        while p.next:
            i += 1      
            if i == index:
                p.next, newnode.next = newnode, p.next
                break
            p = p.next
        else:
            p.next = newnode

    def index(self, index):
        """
        返回index索引位置上的节点的值
        """
        length = self.length()
        if index > length:
            raise IndexError, 'out of the length!'
        else:
            i = 0
            p = self.first
            while 1:
                if i == index:
                    return p.value
                    break
                else:
                    p = p.next
                    i += 1


    def find(self, value):
        """
        返回节点第一次出现的位置
        如果没有找到，就返回-1
        """
        p = self.first
        i = 0
        while p.next:
            if p.value == value:
                return i
                break
            else:
                p = p.next
                i += 1
        else:
            return -1

    def length(self):
        """
        判断当前链表的长度
        """
        p = self.first
        i = 0
        while p.next:
            i += 1
            p = p.next
        else:
            return i

    def to_dict(self):
        """
        以字典的形式输出我们的链表
        """
        p = self.first
        d = {'value': p.value, 'next': p.next}
        b = d
        while p.next:
            p = p.next
            new = {'value': p.value,
                   'next': p.next}
            b['next'] = new
            b = b['next']
        else:
            return d

在这个单向链表中，我们实现了add(value)，find(value), insert(value, index), remove(value), index(value), length(), to_dict()这七个方法。我没有定义判断链表是否为空的方法，是因为在初始化链表的时候我会赋予一个头结点，这个节点我是算在链表的长度中的。所以，如果要查看链表是否为空，调用length()方法即可，返回为1，链表只有头结点而已。

其实只要理解了，就是这么简单。