算法题解第四章

题目

反转单链表
取自:leetcode

给定一个单链表的头结点pHead(该头节点是有值的，比如在下图，它的val是1)，长度为n，反转该链表后，返回新链表的表头。

数据范围： 0≤n≤1000
要求：空间复杂度 O(1) ，时间复杂度 O(n) 。
如当输入链表{1,2,3}时，
经反转后，原链表变为{3,2,1}，所以对应的输出为{3,2,1}。

解析

##首先我们知道 链表是一种非连续存储的数据结构,它的数据连接全是靠着指针指向下一个节点来完成,它有单链表和双链表,区别在于单链表只有一个头一个尾,从头到尾比较简单。
##已知条件 一个链表,要反转这个链表并且要求空间复杂度最低,时间复杂度随意,也就是说这个题的优化点在于要用时间换空间,最好不要有新的链表,还是在原链表上操作
##所以实现思路:
##1.先写一个链表
##2.写一个反转链表的类
##3.尽量在同一个链表操作反转
##4.对于条件限制做好容错

定义节点和单链表

class Node(object):
    def __init__(self,item):
        self.item=item
        self.nextNode=None


class SingleLinkList(object):
    def __init__(self):
        self._head=None

    def is_empty(self):
        return self._head is None

    def get_length(self):
        node =self._head
        count =0
        while node is not None:
            count+=1
            #指针下移动
            node= node.nextNode
        return count

    def get_items(self):
        """遍历链表"""
        node =self._head
        while node is not None:
            yield node.item
            #指针下移
            node =node.nextNode

    def add_item(self,item):
        """头部添加元素"""
        node =Node(item)
        node.nextNode =self._head
        self._head=node

    def append_item(self,item):
        """尾部添加"""
        node =Node(item)
        #有个判断是否是一个空链表
        if self.is_empty():
            self._head =node
        else:
            #不是空要找到最尾部的那个节点 要从头找起
            cur_node =self._head
            while cur_node.nextNode is not None:
                cur_node=cur_node.nextNode
            cur_node.nextNode=node

    def insert(self,pos,item):
        """指定位置插入元素"""
        if pos <=0:
            self.add_item(item)
        elif pos >(self.get_length()-1):
            self.append_item(item)
        else:
            node =Node(item)
            cur_node =self._head
            #找到指定位置前后的节点 断开然后连上自己
            for i in range(pos -1):
                cur_node=cur_node.nextNode
            node.next =cur_node.nextNode
            cur_node.next=node
    def remove_item(self,item):
        if not item in self.get_items():
            return "没有找到该节点"

        #也是从头开始找起,这时候你就发现优缺点了把 虽然插入删除数据自由灵活多变  但是查找数据相当麻烦
        cur_node =self._head
        pre_node =None
        while cur_node is not None:
            if cur_node.item ==item:
                #如果没有前节点那么就是头节点,删除头节点就是把头节点指向下一个节点
                if not pre_node:
                    self._head=cur_node.nextNode
                else:
                    #如果有前节点 就是把前节点的下一个节点指向当前节点的下一个节点
                    pre_node.nextNode=cur_node.nextNode
                return  True


            else:
                #下移动
                pre_node =cur_node
                cur_node=cur_node.nextNode



    def find_item(self,item):
        """查找元素是否存在"""
        return item in self.get_items()

##测试
newlist =SingleLinkList()
newlist.append_item(1)
newlist.append_item(2)
newlist.append_item(3)
for i in newlist.get_items():
    print(i)

newlist.remove_item(1)
for i in newlist.get_items():
    print(i)

反转链表

class Solution:
    ###1-2-3-none是正常顺序
    ###反顺序3->2->1->none

    def ReverseList(self , head: Node) -> Node:
        # write code here
        if head == None:
            return head

        cur =head
        #要反转的尾节点
        pre =None

        while cur:
            #在这里就是pre=none cur=1
            tmp =cur.nextNode
            #保存2-3位置
            ##把当前的节点的下一个节点设置为none
            cur.nextNode=pre
            ###pre节点为当前节点
            pre =cur
            ##现在就是 1>none  tmp 2->3
            ##现在开始接上2-3
            cur =tmp
            ##这样就是 1>none>2->3
            ##然后cur=2 pre=1

            ##然后迭代一次就变成 2->1->none->3

        return pre

solution=Solution()
data=solution.ReverseList(newlist._head)
##打印出所有逆反的数据
cur =data
while cur is not None:
    print(cur.item)
    cur =cur.nextNode

结果 3，2，1