单链表部分实现

熟悉c语言以及数据结构的朋友们都知道，链表简单的说就是由很多个节点连接而成（有点像火车一样），每个节点分为指针域（next）和数据域（data），一个节点的指针域指向下一个节点（指针域用来存放下一个节点的地址）

以下代码均由python3实现
1.利用类实现一个简单的链表

class SingleLinkedList(object):
    def __init__(self):
        self.data = None#数据域，存放当前节点的数据
        self.next = None#指针域，存放下一个节点的地址


node1 = SingleLinkedList()
node2 = SingleLinkedList()
node3 = SingleLinkedList()
node1.data = 13
node2.data = 14
node3.data = 15
node1.next = node2
node2.next = node3
print(node1.data)
print(node1.next.data)
print(node1.next.next.data)

2.但是1中有不好的地方就是想把每个节点串起来的时候得一个一个连接起来，例如给data赋值，给next赋值都得一个一个来，最重要的是用户可以设置一个变量直接指向链表中间任意一个位置（修改指针域），获取原始数据优化之后

class SingleLinkedList(object):
    def __init__(self, data, next):
        self.data = data
        self.next = next


node = SingleLinkedList(13, None)#每次node都被重新赋值，之前的node作为作为下一个节点的next
node = SingleLinkedList(14, node)
node = SingleLinkedList(15, node)
print(node.data)
print(node.next.data)
print(node.next.next.data)

3.获取单链表节点的个数

class SingleLinkedList(object):
    def __init__(self, data, next):
        self.data = data
        self.next = next

    def size(self):#递归获取链表的总的节点数
        if self.next is None:
            return 1
        else:
            return 1 + self.next.size()

    def not_recursive_size(self):#非递归获取链表的总的节点数
        p = self
        count = 0
        while p is not None:
            count += 1
            p = p.next
        return count
	
node = SingleLinkedList(13, None)
node = SingleLinkedList(14, node)
node = SingleLinkedList(15, node)
print(node.size())
print(node.not_recursive_size())

4.改进的地方，现在的链表，每次声明节点的时候，内部数据都给暴露出来了，也就是我们希望在创建节点的时候传入的参数只有数据，而对应的指针域的处理让程序自动去处理它和下一个节点的关系；还有之前获取链表的总的节点个数时总要去把整个链表过一遍，略显累赘

class NodeStruct(object):  # 每个节点对象
    def __init__(self, data, next):
        self.data = data
        self.next = next


class SingleLinkedList(object):
    def __init__(self, data):  # 创建一个新链表的时候，我们需要先初始化一个header节点
        self.node = NodeStruct(data, None)  # 只有一个头节点的时候，指针域肯定没有存放任何东西的
        self.size = 1

    def add_first_node(self, data):  # 在链表头部添加一个节点
        self.node = NodeStruct(data, self.node)  # 这里有点类似上面的node = SingleLinkedList(14, node)
        self.size += 1

    def add_last_node(self, data):  # 在链表尾部添加一个节点
        p = self.node
        while p.next is not None:
            p = p.next
        p.next = NodeStruct(data, None)
        self.size += 1

    def get_first_value(self):
        return self.node.data

    def get_size(self):
        return self.size


node1 = SingleLinkedList(45)  # 初始化第一个节点,我们此时添加节点的时候，只需要实例化一次了
print(node1.get_first_value())
node1.add_first_node(24)
print(node1.get_first_value())
node1.add_first_node(56)
print(node1.get_first_value())
node1.add_last_node(1)
print(node1.get_first_value())
node1.add_last_node(2)
print(node1.get_size())

5.初始化一个空链表
空链表和非空链表的第一个元素是不一样的

class NodeStruct(object):  # 每个节点对象
    def __init__(self, data, next):
        self.data = data
        self.next = next


class SingleLinkedList(object):
    def __init__(self, data=None):  # 创建一个新链表的时候，我们需要先初始化一个header节点
        if data is None:
            self.node = None
            self.size = 0
        else:
            self.node = NodeStruct(data, None)  # 只有一个头节点的时候，指针域肯定没有存放任何东西的
            self.size = 1

    def add_first_node(self, data):  # 在链表头部添加一个节点
        self.node = NodeStruct(data, self.node)  # 这里有点类似上面的node = SingleLinkedList(14, node)
        self.size += 1

    def add_last_node(self, data):  # 在链表尾部添加一个节点
        p = self.node
        if p is None:
            self.node = NodeStruct(data, None)
        else:
            while p.next is not None:
                p = p.next
            p.next = NodeStruct(data, None)
        self.size += 1

    def get_first_value(self):
        return self.node.data

    def get_size(self):
        return self.size


node1 = SingleLinkedList()  # 初始化第一个节点,我们此时添加节点的时候，只需要实例化一次了
node1.add_last_node(1)
print(node1.get_first_value())
node1.add_last_node(2)
print(node1.get_size())

似乎上面的修改也不是特别的优雅，因为我们为了处理空链表这种情况的时候额外增加了连刺if判断，好像我们可以用一个引导节点（guide_node）将空链表后续添加的节点添加到正确的位置，这个引导节点的数据域我们任意指定；如果引导节点后面没有接入数据，则为空链表，反之则不为空链表

class SingleLinkedList(object):
    def __init__(self, data=None):
        self.guide_node = NodeStruct(3, None)
        if data is None:
            self.size = 0
        else:
            self.guide_node.next = NodeStruct(data, None)
            self.size = 1

    def add_first_node(self, data):
        first_node = self.guide_node.next
        new_first_node = NodeStruct(data, first_node)
        self.guide_node.next = new_first_node
        self.size += 1

    def add_last_node(self, data):
        p = self.guide_node
        while p.next is not None:
            p = p.next
        p.next = NodeStruct(data, None)
        self.size += 1

    def get_first_value(self):
        return self.guide_node.next.data  # 这里就不是原来的self.node.data，因为现在链表的第一个节点是引导节点了，所以我们要获取我们添加的第一个节点的data就得next以下

    def get_size(self):
        return self.size


node1 = SingleLinkedList()  # 初始化第一个节点,我们此时添加节点的时候，只需要实例化一次了
node1.add_last_node(1)
node1.add_first_node(10)
node1.add_first_node(20)
node1.add_last_node(2)
print(node1.get_first_value())
print(node1.get_size())

6.单链表的反转

class Lnode:  # d定义节点
    def __init__(self, x):
        self.val = x
        self.next = None


def ReverseList(pHead):
    if (pHead is None) or (pHead.next is None):
        return pHead
    p_1 = None
    p0 = pHead
    while p0 is not None:
        # tmp = p0.next#用一个临时变量存放p0的指针域，防止修改后，丢失了p0后面的节点
        # p0.next = p_1
        # p_1 = p0
        # p0 = tmp
        tmp, p0.next = p0.next, p_1
        p_1, p0 = p0, tmp
    return p_1#返回新的头节点


if __name__ == '__main__':
    phead = Lnode(1)  # 建立链表1->2->3->None
    p1 = Lnode(2)
    p2 = Lnode(3)
    phead.next = p1
    p1.next = p2
    p = ReverseList(phead)
    # print(p.val)
    while p:
        print(p.val)
        p = p.next