单向链表 python

初始化链表

class Node(object):
    def __init__(self):
        self.data = data
        self.nex = None
#初始化链表
def __init__(self):
    self.head = None

获取链表长度

从头结点依次遍历，直到最后一个节点(node.nex = None) 结束。

def len(self):
    pre = self.head
    length = 0
    while pre:
        length += 1
        pre = pre.nex
    return length

追加节点

若链表为空，则当前节点为头节点，否则找到尾节点，将尾节点的next指向该节点即可。

def append(self,data):
    #使用节点的值初始化节点
    node = Node(data)
    if self.head is None:
        self.head = node
    else:
        pre = self.head
        while pre.nex:
            pre = pre.nex
        pre.nex = node

获取节点

给出索引，获取索引指向的节点

def get(self,index):
    if len(self)<index or index<0:
        return None
    else:
        pre = self.head
        while(index):
            pre = pre.nex
            index -= 1
        return pre

设置节点

给出节点的索引和值，设置该索引处节点的值

def set(self,index,data):
    node = self.get(index)
    if node:
        node.data = data
    return node

插入节点

def insert(self,index,data):
    node = Node(data)
    if abs(index+1) > len(self):
        return False

    if index = 0:
        node.nex = self.head
        self.head = node
    else:
        if pre:
            pre = self.get(index-1)
            node.nex = pre.nex
            pre.nex = node
        else:
            return False
    return node

删除节点

"""删除某个元素"""

def delete(self, index):
    f = index if index > 0 else abs(index + 1)
    if len(self) <= f:
        return False
    pre = self.head
    index = index if index >= 0 else len(self) + index
    prep = None
    while index:
        prep = pre
        pre = pre.nex
        index -= 1
    if not prep:
        self.head = pre.nex
    else:
        prep.nex = pre.nex
    return pre.data

反转链表

"""反转链表"""

def __reversed__(self):
    """
    1.pre-->next 转变为 next-->pre
    2.pre 若是head 则把 pre.nex --> None
    3.tail-->self.head
    :return:
    """

    def reverse(pre_node, node):
        if pre_node is self.head:
            pre_node.nex = None
        if node:
            next_node = node.nex
            node.nex = pre_node
            return reverse(node, next_node)
        else:
            self.head = pre_node

    return reverse(self.head, self.head.nex)

清空链表

"""清空链表"""

def clear(self):
    self.head = None