链表回顾：
leetcode 题目（No.203 移除链表元素）：
不使用虚拟头节点：
1 class Solution {
2 public ListNode removeElements(ListNode head, int val) {
3 //1，head.val 就是应该删除的节点
4 // if(head != null && head.val == val ){
5 while(head != null && head.val == val ){ //之所以使用while是因为可能有多个。
6 ListNode delNode = head;
7 head = delNode.next;
8 delNode.next = null;
9 }
10 //2，head.val 不是应该删除的节点
11 if(head ==null){
12 return null;
13 }
14 ListNode prePtr = head; //删除时应该要知道前一个节点。
15 while (prePtr.next != null){
16 if(prePtr.next.val == val){
17 ListNode delNode = prePtr.next;
18 prePtr.next = delNode.next;
19 delNode.next = null;
20 }else{
21 prePtr = prePtr.next;
22 }
23 }
24 return head;
25 }
26 }
使用虚拟头节点：
1 class Solution {
2 public ListNode removeElements(ListNode head, int val) {
3 //使用虚拟头节点 将代码处理逻辑统一。
4 ListNode dummyNode = new ListNode(0);
5 dummyNode.next = head;
6 ListNode prePtr = dummyNode;
7 while(prePtr.next != null){
8 if(prePtr.next.val == val){
9 ListNode delNode = prePtr.next;
10 prePtr.next = delNode.next;
11 delNode.next = null;
12 }else{
13 prePtr = prePtr.next;
14 }
15 }
16 return dummyNode.next;
17
18
19 }
20 }
链表和递归：
递归是一个很重要的概念，它甚至是 初级程序员和高级程序员 拉开距离的分水岭。
递归基础和递归的宏观语意：
它的本质：
将原来的问题，转化为更小的同一问题！
下面我们用递归来实现一下 数组求和。
1 package cn.zcb.demo01;
2
3 public class MySum {
4 public static void main(String[] args) {
5 int [] arr = {1,2,3,4,5,6,7,8,9,10};
6 int ret = sum(arr);
7 System.out.println(ret);
8
9 }
10 public static int sum(int []arr){
11 //为用户设计
12 return sum(arr,0); // 初始索引是0
13 }
14 private static int sum(int []arr,int leftIdx){
15 //真正的递归函数，它额外需要一个左边界的索引 。
16 //终止条件
17 if(leftIdx == arr.length ){
18 return 0;
19 }
20 //递归链条
21 return arr[leftIdx] + sum(arr,leftIdx+1);
22 }
23 }
上面递归分两处：
1，终止条件。终止条件一般比较简单，
2，递归链条。一般难的是下面的递归链表的创建（即 把原问题 转化成更小的问题）。
其实有的时候，我们不必关系递归的具体每一步骤，
而仅仅知道 该函数是干嘛的就行了（即递归函数的宏观语意）。然后，围绕它来构建终止条件 和 递归链条。
总结：宏观语意很重要，可以直接将 函数中调用自身的函数当做是已经解决的函数。
链表的天然递归结构：
所以，对于链表来说 ，绝大多数都是可以通过递归来进行解决的。
下面使用递归来解决上面的LeetCode题目。
1 class Solution {
2 public ListNode removeElements(ListNode head, int val) {
3 //终止条件
4 if(head == null)
5 return null;
6
7 //递归链条
8 ListNode res = removeElements(head.next,val); //假设 res 是已经清理好的链表。
9 if(head.val == val){ //如果head 需要清理 直接返回 res
10 return res;
11 }else{
12 head.next = res;
13 return head;
14 }
15 }
16 }
1 package cn.zcb.demo01;
2 class Solution {
3 public ListNode removeElements(ListNode head, int val) {
4 //终止条件
5 if(head == null)
6 return null;
7
8 //递归链条
9 head.next = removeElements(head.next,val); //假设函数的返回值是 已经清理好的链表。
10 if(head.val == val){ //如果head 需要清理 直接返回head.next
11 return head.next;
12 }else{
13 return head;
14 }
15 }
16 }
1 package cn.zcb.demo01;
2 class Solution {
3 public ListNode removeElements(ListNode head, int val) {
4 //终止条件
5 if(head == null)
6 return null;
7
8 //递归链条
9 head.next = removeElements(head.next,val); //假设函数的返回值是 已经清理好的链表。
10 return head.val == val?head.next:head;
11 }
12 }
递归运行的机制：递归的“微观”解读：
就解决问题本身而言，我们只需要掌握 “宏观”语意，基本上问题都能解决。
下面我们也看下微观发生了什么！
另一题：
递归的代价：
对于线性结构来说，我们是可以直接使用循环来解决的。所以，我们不能发现递归的很多好处。
但是对于非线性结构（树啊，图啊之类的）来说，我们就会发现递归的好处。它的书写逻辑是清晰的。而且是简单的。
递归算法的调试（程序中调试）：
上面是在图纸上写的。对于平时写程序来说，如果每个都写在纸上也挺浪费时间，虽然它的学习效果是最好的。
其实，我们是完全可以通过打印输出进行递归调试 的 。
1 package cn.zcb.demo01;
2 class Solution {
3 public ListNode removeElements(ListNode head, int val,int depth) { //depth 是递归的深度
4 //终止条件
5 //1,一进来就输出个 关于深度的信息。 这里用- 表示， - 表示一个深度。
6 String depthString = generateDepthString(depth); //专门用来生成深度信息的函数
7 System.out.print(depthString);
8 System.out.println("Call: remove " + val + " in "+head);
9
10 if(head == null) {
11 //2, 结束递归时候的输出。
12 System.out.print(depthString);
13 System.out.println("0Return: "+head);
14 return null;
15 }
16 //递归链条
17 ListNode res = removeElements(head.next,val,depth+1);
18 //3 处理完小问题之后输出一下。
19 System.out.print(depthString);
20 System.out.println("After remove "+val +": "+res);
21
22 ListNode ret;
23 if(head.val == val){
24 ret = res;
25 }else{
26 head.next = res;
27 ret = head;
28 }
29 System.out.print(depthString);
30 System.out.println("1Return: "+ret);
31 return ret;
32 }
33 private String generateDepthString(int depth){
34 StringBuilder builder = new StringBuilder();
35 for (int i=0;i<depth;i++){
36 builder.append("-");
37 }
38 return builder.toString();
39
40
41 }
42 public static void main(String[] args) {
43 int [] nums = {1,2,6,3,4,5,6};
44 ListNode head = new ListNode(nums);
45 System.out.println(head);
46
47 //构建链表完毕，下面为测试 removeElements() 代码
48 ListNode res = (new Solution()).removeElements(head,6,0);
49 System.out.println(res);
50 }
51
52 }
1 package cn.zcb.demo01;
2
3 public class ListNode {
4 public int val;
5 public ListNode next;
6 public ListNode(int val){
7 this.val = val;
8 }
9 //int [] 数组作为参数的构造器
10 public ListNode(int [] arr){
11 if(arr == null || arr.length ==0 ){
12 throw new IllegalArgumentException("数组不能为空 ！");
13 }
14 this.val = arr[0];
15
16 ListNode temp = this;
17 for (int i=1;i<arr.length;i++){
18 temp.next = new ListNode(arr[i]);
19 temp = temp.next;
20 }
21 }
22 //重写toString()
23 @Override
24 public String toString(){
25 StringBuilder builder = new StringBuilder();
26 ListNode temp =this;
27 while (temp != null){
28 builder.append(temp.val +"->");
29 temp = temp.next;
30 }
31 builder.append("null");
32 return builder.toString();
33 }
34 }
原本只有四行的代码，被我们整成了 这么多行， 它说明 牛逼的算法可能是需要上百上千的代码才可以透彻的理解的。才能潇洒的写出那四行代码的。
更多的 和 链表相关的话题：
链表的形态了解：
1，双链表：
我们之前的问题，在对队列尾端删除的时候，即使有tail ，也需要O(n) 的时间复杂度。
其实，我们可以用双链表来 解决这个事情。
不过，这样带给我们的代价是，由于有两个指针，所以维护起来会比较麻烦。
当然，双链表也可以通过使用 虚拟头节点 去使得处理逻辑统一。
2，循环链表：
进一步，有循环链表（双向），它可避免使用tail 指针了就。
链表也可以用数组来实现：
3，数组链表：
至此，之前的内容都是关于线性的。下面将进入非线性。首先的就是二分搜索树。