实现列表 ：链表(python)

实现列表：链表

无序链表

Node类

节点是构建链表的基本数据结构。每一个节点对象都必须持有至少两份信息。首先，节点必须包含列表元素，我们称之为节点的数据变量。其次，节点必须保存指向下一个节点的引用。

类似于：

[a]->[b]->[c]

第一个节点的数据是a，第一个节点的下一个节点的数据是b，依次类推,数据大小不约束例如：

56 -> 12 ->89

基本实现

class Node:
    def __init__(self, init_data):
        self.data = init_data
        self.next = None

    def get_data(self):
        return self.data

    def get_next(self):
        return self.next

    def set_data(self, new_data):
        self.data = new_data

    def set_next(self, new_next):
        self.next = new_next

>>> head=Node('a')
>>> head.get_data()
'a'
>>> head.set_next(Node('b'))
>>> head.get_next().get_data()
'b'

UnorderedList类

class UnorderedList:
    # 初始化头节点为空
    def __init__(self):
        self.head = None

    # 判断列表是否为空就是判断头节点是否为空
    def is_empty(self):
        return self.head is None

    # 添加元素
    def add(self, item):
        tmp = Node(item)
        tmp.set_next(self.head)
        self.head = tmp

    # 获取链表长度 从前向后变量 直到没有节点
    def length(self):
        cur = self.head
        cnt = 0
        while not cur == None:
            cnt = cnt + 1
            cur = cur.get_next()
        return cnt

    # 选择元素
    def search(self, item):
        cur = self.head
        found = False
        while cur != None and not found:
            if cur.get_data() == item:
                found = True
            else:
                cur = cur.get_next()

        return found

    # 移除一个元素
    def remove(self, item):
        cur = self.head
        pre = None
        found = False
        while not found:
            if cur.get_data() == item:
                found = True
            else:
                pre = cur
                cur = cur.get_next()

        if pre is None:
            self.head = cur.get_next()
        else:
            pre.set_next(cur.get_next())

>>> ls=UnorderedList()
>>> ls.add(1)
>>> ls.add(2)
>>> ls.add(3)
>>> ls.length()
3
>>> ls.remove(2)
>>> ls.length()
2
>>> ls.search(1)
True
>>> ls.search(2)
False
>>> ls.search(3)
True

有序链表

在有序列表中，元素的相对位置取决于它们的基本特征。它们通常以升序或者降序排列。有序列表的众多操作与无序列表的相同。

OrderedList

class OrderedList:
    # 初始化
    def __init__(self):
        self.head = None

        # 获取链表长度 从前向后变量 直到没有节点

    def length(self):
        cur = self.head
        cnt = 0
        while not cur == None:
            cnt = cnt + 1
            cur = cur.get_next()
        return cnt

    # 移除一个元素

    def remove(self, item):
        cur = self.head
        pre = None
        found = False
        while not found:
            if cur.get_data() == item:
                found = True
            else:
                pre = cur
                cur = cur.get_next()

        if pre is None:
            self.head = cur.get_next()
        else:
            pre.set_next(cur.get_next())

    # 有序链表 如果找到比它大的数字还没有找到 就说明没这个元素
    def search(self, item):
        cur = self.head
        found = False
        stop = False
        while cur is not None and not found and not stop:
            if cur.get_data() == item:
                found = True
            else:
                if cur.get_data() > item:
                    stop = True
                else:
                    cur = cur.get_next()

        return found

    def add(self, item):
        cur = self.head
        pre = None
        stop = False
        while cur != None and not stop:
            if cur.get_data() > item:
                stop = True
            else:
                pre = cur
                cur = cur.get_next()

        tmp = Node(item)
        if pre == None:
            tmp.set_next(self.head)
            self.head = tmp
        else:
            tmp.set_next(cur)
            pre.set_next(tmp)

>>> ls=OrderedList()
>>> ls.add(12)
>>> ls.add(2)
>>> ls.add(99)
>>> ls.add(24)
>>> cur=ls.head 
>>> while cur!=None:
...     print(cur.get_data())
...     cur=cur.get_next()
...     
2
12
24
99

不论添加数据顺序怎样， 数据始终有序