【数据结构】单链表及其操作

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

节点实现

class SingleNode(object):
"""单链表的结点"""
def __init__(self,item):
# _item存放数据元素
self.item = item
# _next是下一个节点的标识
self.next = None

单链表的操作

• is_empty() 链表是否为空
• length() 链表长度
• travel() 遍历整个链表
• add(item) 链表头部添加元素
• append(item) 链表尾部添加元素
• insert(pos, item) 指定位置添加元素
• remove(item) 删除节点
• search(item) 查找节点是否存在

#-*-coding=utf-8-*-

# 单链表
# 顺序表优点：存取元素的时候可以通过O(1)的方式一次性定位，缺点是空间必须是连续的，存大数的时候没有那么多连续内存供其存储
# 链表优点：链表对离散的内存空间可以充分利用，缺点：利用的同时开销也大，且存取元素时候时间复杂度大

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


class SingleLinkList(object):
    def __init__(self,node = None):
        # 头指针 在线性表的链式存储结构中，头指针是指链表指向第一个结点的指针，若链表有头结点，则头指针就是指向链表头结点的指针。
        self.__head = node

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

    # length() 链表长度
    def length(self):
        # cur游标用来移动便利节点
        cur = self.__head
        # count用来记录数量
        count = 0
        while cur != None:
            count += 1
            cur = cur.next
        return count

    # travel() 遍历整个链表
    def travel(self):
        cur = self.__head
        while cur != None:
            print(cur.elem,end=" ")
            # print(cur.next)
            cur = cur.next

    # add(item) 链表头部添加元素 头插法
    def add(self,item):
        node = Node(item)
        cur = self.__head
        # print(cur.elem)
        node.next = cur
        self.__head = node

    # append(item) 链表尾部添加元素 尾插法
    def append(self,item):
        node = Node(item)
        if self.is_empty():
            self.__head = node
        else:
            cur = self.__head
            while cur.next != None:
                cur = cur.next
            cur.next = node

    # insert(pos, item) 指定位置添加元素
    def insert(self,pos,item):
        if pos<=0:
            self.add()
        if self.length()>pos:
            node = Node(item)
            pre = self.__head
            # pose是从0开始的
            for i in range(pos-1):
                pre = pre.next
            node.next = pre.next
            pre.next = node
            # 另一种方法
            # count = 0
            # while count < (pos-1):
            #     count += 1
            #     pre = pre.next
            # node.next = pre.next
            # pre.next = node
        else:
            self.append(item)

    # remove(item) 删除节点
    def remove(self,item):
        cur = self.__head
        pre = None
        while cur != None:
            if cur.elem == item:
                if cur == self.__head:
                    self.__ = cur.next
                pre.next = cur.next
                break
            else:
                # 注意移动顺序
                pre = cur
                cur = cur.next

    # search(item) 查找节点是否存在
    def search(self,item):
        cur = self.__head
        count = 0
        while cur != None:
            cur = cur.next
            count += 1
            if cur.elem == item:
                print("found it:%d and pos is %d"%(item,count))
                break

if __name__ == "__main__":
    single_obj=SingleLinkList()
    print(single_obj.is_empty())
    print(single_obj.length())

    single_obj.append(1)
    print(single_obj.is_empty())
    print(single_obj.length())

    for i in range(10):
        single_obj.append(i)
    single_obj.add(100)
    single_obj.insert(3,500)
    single_obj.search(500)
    single_obj.remove(9)
    single_obj.travel()