leetcode+链表+反转链表

反转一个单链表。

示例:

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

进阶:
你可以迭代或递归地反转链表。你能否用两种方法解决这道题？

拿到题目第一反应是从头节点遍历到尾节点，新建一个链表进行存储并返回。但该方法时间复杂度O(n^2)，空间复杂度O(n)

方法一：迭代

• 在遍历列表时，将当前节点的 next 指针改为指向前一个元素。
• 由于节点没有引用其上一个节点，因此必须事先存储其前一个元素。
• 在更改引用之前，还需要另一个指针来存储下一个节点。
• 最后返回新的头引用！

迭代是按步骤一步一步执行的过程：

、

时间复杂度O(n)，空间复杂度O(1)

方法二：递归

递归稍微复杂一些，关键在于反向工作。

假设列表的其余部分已经被反转，现在我该如何反转它前面的部分？

• 假设列表为：n1 → … → nk-1 → nk → nk+1 → … → nm → Ø
• 若从节点 nk+1 到 nm 已经被反转，而我们正处于 nk。
• n1 → … → nk-1 → nk → nk+1 ← … ← nm
• 我们希望 nk+1 的下一个节点指向 nk。
• 所以，nk.next.next = nk;
• 注意 n1 的下一个必须指向 Ø 。如果忽略了这一点，链表中可能会产生循环

递归，参数传递从前到后①→ ②→③，代码操作④→⑤→⑥反向从后向前操作

时间复杂度O(n)，空间复杂度O(n)

class ListNode{
	public ListNode next;
	public int val;
	public ListNode(int x) {
		this.val=x;
	}
}

public class Solution{
	public ListNode head;
	public int length=0;
	//打印链表
	public void printLinkList(ListNode x)
	{
		ListNode p=x;
		while(p!=null)
		{
			System.out.print(p.val+" ");
			p=p.next;
		}
		System.out.println();
		System.out.println("长度为："+length);		
	}
	//尾插法添加结点
	public void addLastNode(ListNode x)
	{
		if(head==null)
		{
			head=x;
			length++;
			return;
		}
		ListNode q=head;
		while(q.next!=null)
			q=q.next;
		q.next=x;
		length++;
	}
	//迭代法反转链表
	public ListNode reverseList0(ListNode head) {
		ListNode prev=null;
		ListNode curr=head;
		while(curr!=null)
		{
			ListNode nextTemp=curr.next;
			curr.next=prev;
			prev=curr;
			curr=nextTemp;
		}
		return prev;
    }
	
	//递归法反转链表
	public ListNode reverseList1(ListNode head) {
		if(head==null||head.next==null)
			return head;	
		ListNode p=reverseList1(head.next);
		head.next.next=head;
		head.next=null;
		return p;
    }
	public static void main(String[] args)
	{
		Solution main=new Solution();
		ListNode x1=new ListNode(1);
		main.addLastNode(x1);
		ListNode x2=new ListNode(2);
		main.addLastNode(x2);
		ListNode x3=new ListNode(3);
		main.addLastNode(x3);
		main.printLinkList(x1);
		ListNode nh=main.reverseList1(x1);
		main.printLinkList(nh);
	}
}