剑指offer 反转链表

python如何创建一个链表

class Node:
    def __init__(self, data):
        '''
        :param data: 数据
        '''
        self.data=data
        self.next=None

    def __repr__(self):
        return str(self.data)

class ChainTable(Node):

    def __init__(self):
        self.head=None
        self.length=0

    def isEmpty(self):
        return (self.length==0)

    def add(self, dataOrNode):
        item=None
        if isinstance(dataOrNode, Node):
            item=dataOrNode
        else:
            item=Node(dataOrNode)

        if not self.head:
            self.head=item
            self.length+=1

        else:
            node=self.head
            while node.next:
                node=node.next

            node.next=item
            self.length+=1

    def delete(self, index):
        if self.isEmpty():
            print("链表是空的")
            return
        if index < 0 or index >= self.length:
            print("超出索引长度")
            return

        # 删除第一个节点
        if index == 0:
            self.head = self.head.next
            self.length -= 1
            return

        # prev为保存前导节点
        # node为保存当前节点
        # 当j与index相等时就
        # 相当于找到要删除的节点
        j = 0
        node = self.head
        prev = self.head
        while node.next and j < index:
            prev = node
            node = node.next
            j += 1
        if j == index:  # 找到节点后将下一个节点覆盖到本节点
            prev.next = node.next
            self.length -= 1

    def update(self, index, data):
        if self.isEmpty() or index < 0 or index >= self.length:
            print('超出索引长度')
            return
        j = 0
        node = self.head
        while node.next and j < index:
            node = node.next
            j += 1
        if j == index:
            node.data = data

    # 查找一个节点
    def getItem(self, index):
        if self.isEmpty() or index < 0 or index >= self.length:
            print('超出索引长度')
            return
        j = 0
        node = self.head
        while node.next and j < index:
            node = node.next
            j += 1
        return node.data

    # 从头到尾打印链表
    def print_chain(self):
        if self.isEmpty():
            print('链表为空')
        num = []
        node = self.head
        while node:
            num.append(node)
            node = node.next
        return num

    # 查找一个节点的索引
    def getIndex(self, data):
        j = 0
        if self.isEmpty():
            print('链表为空')
            return
        node = self.head
        while node:
            if node.data == data:
                return j
            node = node.next
            j += 1
        if j == self.length:
            print("%s not found" % str(data))
            return

    def insert(self, index, dataOrNode):
        if self.isEmpty():
            print('链表为空')
            return
        if index < 0 or index >= self.length:
            print('超出索引长度')
            return
        item = None
        if isinstance(dataOrNode, Node):
            item = dataOrNode
        else:
            item = Node(dataOrNode)
        if index == 0:
            item.next = self.head
            self.head = item
            self.length += 1
            return
        j = 0
        node = self.head
        prev = self.head
        while node.next and j < index:
            prev = node
            node = node.next
            j += 1
        if j == index:
            item.next = node
            prev.next = item
            self.length += 1

    def clear(self):
        self.head = None
        self.length = 0

    def __repr__(self):
        if self.isEmpty():
            return "链表为空"
        node = self.head
        nlist = ''
        while node:
            nlist += str(node.data) + ' '
            node = node.next
        return nlist

    def __getitem__(self, ind):
        if self.isEmpty() or ind < 0 or ind >= self.length:
            print("超出索引长度")
            return
        return self.getItem(ind)

    def __setitem__(self, ind, val):
        if self.isEmpty() or ind < 0 or ind >= self.length:
            print("超出索引长度")
            return
        self.update(ind, val)

    def __len__(self):
        return self.length

留以后慢慢研究

反转链表

直接反向打印

def printListFromTailToHead(listNode):
        # write code here
        res=[]
        while listNode:
            res.append(listNode.val)
            listNode=listNode.next
        return res[::-1]  #逆序打印

递归反向打印

递归是栈的一种应用，栈是一种先进后出后进先出的数据结构。
递归：调用自己或通过一系列语句间接调用自己。

def printListFromTailToHead(listNode):
    res=[]
    def printListnode(listNode):
        # write code here
        if listNode:
            printListnode(listNode.next)#先递归到最后一层
            res.append(listNode.val)#添加值，退出函数，返回到上一层函数中的这行，继续添加值
    printListnode(listNode)
    return res

上图解释的非常好，就是函数在递归调用的时候，前半部分很好理解，反复地调用自己直到终止条件，但是接下来还要逐级返回，而不是简单的一层就结束了，这里就用到了栈的结构去理解。

void fun(int n)  
{  
    printf("1th - Level: %d  Address: %d\n", n, &n);  
    if(n < 3)  
        fun(n+1);  
    printf("2th - Level: %d  Address: %d\n", n, &n);  
}  
  
int main()  
{  
    fun(1);  
    return 0;  
}

反转链表（实现前后节点关系）

可以理解为将链表的数据域不变，将指针域由原数据域的右侧移到左侧，指向发生变化，在末尾添加None

• 非递归

def ReverseList(pHead):
    prev=None
    while pHead:
        '''
        curr:临时变量，保留当下的链表元素
        prev：链表反转后的部分链表，为当下操作的元素作为指针域
        '''
        curr=pHead # 把链表的第一个赋给指针curr，也复制了一份链表
        pHead=pHead.next  # 然后链表的下一个往前提
        curr.next=prev  # 将None赋给结尾，也就是将反转后的链表的后一位作为前一位的指针指向
        prev=curr  # 将刚才的curr指针在新建链表后移
    return prev

综上，反转链表就实现了。