算法之链表

链表

链表的遍历方式

首先先简单的创建一个链表123，如下所示：

            ListNode head = new ListNode(1);
			ListNode twoNode = new ListNode(2);
			ListNode threeNode = new ListNode(3);

			head.next = twoNode;
			twoNode.next = threeNode;

方法一 使用for循环：

			for (ListNode node = head; node != null; node = node.next) {
				System.out.print(node.val + "   ");
			}
			
			// 打印结果 1   2   3 

方式二 使用递归迭代：

   void travel(ListNode head) {
		if (head != null) {
			System.out.print(head.val + "   ");
			travel(head.next);
		}
	}
	// 打印结果 1   2   3  (前序遍历)
	
    void travel(ListNode head) {
		if (head != null) {
			travel(head.next);
			System.out.print(head.val + "   ");
		}
	}	
	// 打印结果 3   2   1  (后序遍历)	

链表的一些题目

给定一个数组[1,2,3,4,5]，根据数组的数据生成链表

    public ListNode listCovertNode(List<Integer> list) {
		ListNode tempNode = new ListNode(-1);
		ListNode currentNode = tempNode;
		for (int i = 0; i < list.size(); i++) {
			currentNode.val = list.get(i);
			if(i < list.size() -1) {
				currentNode.next = new ListNode(-1);
				currentNode = currentNode.next;
			}
		}
		return tempNode;
	}

leetcode 206. 反转链表 比如输入 1->2->3->4->5->NULL 输出5->4->3->2->1->NULL

• 思路一 先后续遍历链表，生成数组54321，然后根据上面方法进行listCovertNode转化成链表
• 思路二 先创建一个哑结点tempNode，遍历链表的同时，tempNode都指向新结点,但是要缓存上一次的链表，代码如下:

    public ListNode reverseList(ListNode head) {
        ListNode tempNode = new ListNode(-1,null);
		ListNode lastNode = null;
		for (ListNode node = head; node != null; node = node.next) {
			lastNode = tempNode.next;
			ListNode currentNode = new ListNode(node.val);
			tempNode.next = currentNode;
			currentNode.next = lastNode;
		}
		return tempNode.next;
	}

• 思路三 思路二在画图的时候 其实就想到很像递归，递归也能解

leetcode 19. 删除链表的倒数第N个节点 给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。

示例：给定一个链表: 1->2->3->4->5, 和 n = 2. 当删除了倒数第二个节点后，链表变为 1->2->3->5.

• 遇到链表相关的问题一般都设置一个哑指针，便于操作。
• 该题可以通过快慢指针来做，使得最后快指针移到末尾为null的时候，慢指针与快指针相差距离n，这样直接给断掉一位即可。
• 需要注意的是为啥是i<n+1而不是n？假如n为2，链表为12345，当循环结束时，虽然qNode的位置是3，而pNode的位置是0，虽然相差为3了，但是当qNode移动到末尾的时候，while循环qNode会继续移动为null，而pNode也向右边移动一位，这样距离正好相差为2，所以i < n + 1是必须的。

public ListNode removeNthFromEnd(ListNode head, int n) {
		ListNode dummyHead = new ListNode(0, head);
		ListNode pNode = dummyHead;
		ListNode qNode = dummyHead;
		for (int i = 0; i < n + 1; i++) {
			qNode = qNode.next;
		}
		System.out.println("快：" + qNode.val + "  慢："+ pNode.val);
		while (qNode != null) {
			qNode = qNode.next;
			pNode = pNode.next;
		}
		pNode.next = pNode.next.next;
		return dummyHead.next;
	}

leetcode 141. 环形链表 给定一个链表，判断链表中是否有环。

• 思路一：判断是不是环，可以创建一个指针扫描这个链表，扫描的同时，可以通过hashSet判断是不是已经添加过该节点，如果是的，就是环了，否则hashSet添加该节点。而如果指针移动到null了，那么肯定不是环了。 这种方法虽然能解决，但是利用哈希表记录，不够优雅。
• 思路二： 使用快慢指针，快指针每次向前走两步，慢指针每次向前走一步，如果是环的话，那么两个指针最终会相遇；如果不是环，那么快指针肯定会走到null的位置。 代码如下：

   public boolean hasCycle(ListNode head) {
        if (head == null || head.next == null)return false;
		ListNode fastNode = head;
		ListNode slowNode = head;
		while (true) {
            if(fastNode.next == null) return false;
			fastNode = fastNode.next.next;
			slowNode = slowNode.next;
			if (fastNode == slowNode)return true;
			if (fastNode == null || slowNode == null)return false;
		}
    }