python算法 单链表的基本操作

python中没有指针的概念，而类似指针的功能都是通过引用来实现的，而实现的代码中，都是通过引用来建立结点之间的联系。
默认操作都是带头结点的单链表

创建单链表

头插法

class LNode:
    def __init__(self, x=None):
        self.data = x
        self.next = None
def HeadInsert():
    """
    功能：头插法插入数据
    """
    head = LNode()
    head.next = None
    print("请输入数据，每输入一个结点数据就回车一次，直接回车就结束输入。")
    data = input()
    try:
        data = eval(data)
    except:
        pass
    while data != '':
        node = LNode()
        node.data = data
        node.next = head.next
        head.next = node
        data = input()
        try:
            data = eval(data)
        except:
            pass
    return head

尾插法

def TailInsert():
    """
    功能：尾插法插入数据
    """
    head = LNode()
    point = head
    print("请输入数据，每输入一个结点数据就回车一次，直接回车就结束输入。")
    data = input()
    try:
        data = eval(data)
    except:
        pass
    while data!='':
        node = LNode()
        node.data = data
        node.next = None
        point.next = node
        point = node
        data = input()
        try:
            data = eval(data)
        except:
            pass
    return head

输出

def Output(head):
    if head == None or head.next == None:
        return
    cur = head.next
    cnt = 0
    print("打印数据结果：")
    while cur:
        cnt += 1
        print(cur.data, end='\t')
        cur = cur.next
        if cnt % 10 == 0:
            print("\n")
    print("\n")

查找结点

按位置查找

# 按位序查找结点
def GetElem(head, i):
    """
    parame:head 是链表头结点， i是待查找的位置序列号
    return: 返回被查找位置的结点
    """
    j=1
    if i == 0:
        return head
    if i < 1:
        return None
    p = head.next
    while p is not None and j<i:
        j += 1
        p = p.next
    if p is not None:
        print("按位查找，已被找到，值为：", p.data)
    return p

按值查找节点

# 按值查找节点
def LocateElem(head, e):
    """
    parame:head 是链表头结点， e是待查找的值。
    return: 返回被查找值的结点
    """
    p = head.next
    while p is not None and p.data != e:
        p = p.next
    if p is not None:
        print("按值查找，已被找到！")
    return p

按位插入某个值在结点上

def Insert(head, data, i=0):
    """
    parame: head是链表头结点，data是待插入值，i表示待插入位置，默认插入表头位置
    """
    pre = head
    p = pre.next
    if i < 0:
        print("i输入错误，无法插入数据")
    else:
        j=0
        while p is not None and j < i:
            pre = p
            p = p.next
            j += 1
        node = LNode(data)    # 或者 node=LNode()    node.data = data
        pre.next = node
        node.next = p

删除

按位置删除节点

# 按位删除结点
def DeleteNode2(head, i):
    """
    parame:head 是链表头结点， i是待删除结点的位置序列号
    """
    pre = GetElem(head, i-1)
    if pre is None:
        print("无法删除结点！")
    else:
        pre.next = pre.next.next
        print("删除成功")

按值删除节点

# 删除某个值的结点
def DeleteNode(head, e, dnum=float('inf')):
    """
    parame: head 是链表头结点， e是待查找的值, dnum是删除多少个与e重复的值的结点,默认是所有。
    """
    pre = head
    p = pre.next
    cnt = 0
    while p is not None and cnt < dnum:
        if p.data == e:
            cnt += 1
            pre.next = p.next
        else:
            pre = p
        p = p.next

C语言单链表基本操作：传送门