单链表反转（Python）

前边的话

最近一直在学数据结构的知识，今天接触到了链表，通过Python实现了单链表，双向链表以及单向循环链表。采用面向对象的思想，对其进行封装成一个类，就类似list的一样，具有一些简单的操作函数，如：append、insert以及查找、删除等操作。
最后想到了list中反转操作：

	tamp_list = [1,2,3,4]
	# 第一种方法
	list(reversed(tamp_list))
	# 第二种方法
	sorted(tamp_list, reverse=True)
	# 第三种方法
	tamp_list[::-1]

于是，封装了一个反转链表的方法reverse

反转链表思路

1. 新建一个链表
2. 遍历旧链表中的节点，取出每一个节点的值
3. 通过前插的方式加入到新链表

代码

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


class SignalLinkList(object):
    def __init__(self):
        self.head = None

    def is_empty(self):
        '''判断链表是否为空'''
        if self.head == None:
            return True
        return False

    def lenght(self):
        '''链表长度'''
        cur = self.head
        count = 0
        while cur != None:
            count += 1
            cur = cur.next
        return count

    def travel(self):
        '''遍历链表'''
        cur = self.head
        while cur != None:
            print(cur.data, end=' ')
            cur = cur.next
        print(' ')

    def add(self, item):
        '''头部增加节点'''
        node = Node(item)
        node.next = self.head
        self.head = node

    def append(self, item):
        '''尾部增加节点'''
        node = Node(item)
        cur = self.head
        if self.is_empty():
            self.head = node
        else:
            while cur.next != None:
                cur = cur.next
            cur.next = node

    def insert(self, pos, item):
        '''
        在指定位置增加节点
        :param pos: 位置
        :param item: 增加的节点
        '''
        if pos == 0:
            self.add(item)
        elif pos == self.lenght()-1:
            self.append(item)
        else:
            node = Node(item)
            pre = self.head
            count = 0
            while count < pos-1:
                pre = pre.next
                count += 1
            node.next, pre.next = pre.next, node

    def delete(self, item):
        '''删除节点'''
        pre = self.head
        # 首先判断删除的节点是否位于首节点
        if self.head.data == item:
            self.head = self.head.next
        else:
            while pre.next != None:
                if pre.next.data == item:
                    pre.next = pre.next.next
                    break
                pre = pre.next

    def search(self, item):
        '''查找某个节点，并返回该节点的位置'''
        cur = self.head
        count = 0
        while cur != None:
            if cur.data == item:
                return count
            cur = cur.next
            count += 1
        return None

    def reverse(self):
        '''反转链表'''
        # 思路：新建一个链表，依次取出旧链表的第一个元素，通过前插入的方式放入新链表
        self.new_head = None
        cur = self.head
        while cur != None:
            node = Node(cur.data)
            node.next = self.new_head
            self.new_head = node
            cur = cur.next
        cur = self.new_head
        while cur != None:
            print(cur.data, end=' ')
            cur = cur.next
        print(' ')


if __name__ == '__main__':
    sll = SignalLinkList()
    sll.append(0)
    sll.append(1)
    sll.append(2)
    sll.append(3)
    sll.append(4)
    sll.append(5)
    sll.travel()
    sll.reverse()

运行结果

0 1 2 3 4 5  
5 4 3 2 1 0