给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

示例：
给定二叉树 [3,9,20,null,null,15,7]，

    3
   / \
  9  20
    /  \
   15   7

返回它的最大深度 3 。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left;
 *     public TreeNode right;
 *     public TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public int MaxDepth(TreeNode root) {
        if(root == null)
        {
            return 0;
        }
        else
        {
            //递归实现，先进入到最深最深的左节点或右节点，然后慢慢加上来
            int left = MaxDepth(root.left);
            int right = MaxDepth(root.right);
            return left > right ? left + 1 : right + 1; 
        }
    }
}

我原本的思路是，用一个List来存储每一层的所有节点，然后取出来遍历（清空list），如果不为空就将他们的子节点添加到list中并将深度加1，直到list中的为空为止。

public class Solution {
    public int MaxDepth(TreeNode root) {
        List<TreeNode> list = new List<TreeNode>();
        list.Add(root);
        
        int height = 0;
        while(list.Count > 0)
        {
            bool isHeight = false;
            TreeNode[] all = list.ToArray();
            list.Clear();
            foreach(TreeNode node in all)
            {
                if(node != null)
                {
                    isHeight = true;
                    list.Add(node.left);
                    list.Add(node.right);
                }
            }
            
            if(isHeight)
            {
                height++;
            }
        }
        
        return height;
    }
}

给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。

示例 1:
输入: 1->1->2
输出: 1->2
示例 2:
输入: 1->1->2->3->3
输出: 1->2->3

public ListNode DeleteDuplicates(ListNode head) {
    if(head == null) return null;

    ListNode h = head;
    while(head.next != null)
    {
        if(head.next.val != head.val)
        {
            head = head.next;
        }else{
            //相同，直接去除掉
            head.next = head.next.next;
        }
    }

    return h;
}

实现 int sqrt(int x) 函数。

计算并返回 x 的平方根，其中 x 是非负整数。

由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。

示例 1:
输入: 4
输出: 2
示例 2:
输入: 8
输出: 2
说明: 8 的平方根是 2.82842..., 
     由于返回类型是整数，小数部分将被舍去。

public int MySqrt(int x) {
    int l = 1;
    int r = x;
    int mid = 0;
    while(l <= r)
    {
        mid = l + (r - l) / 2;
        if(mid == x / mid)
            return mid;
        else if(mid > x / mid)
            r = mid - 1;
        else
            l = mid + 1;
    }

    return r;
}

public int MySqrt(int x) {
    long r = x;
    while(r * r > x)
        r = (r + x / r) / 2;

    return (int)r;
}

给定一个仅包含大小写字母和空格 ' ' 的字符串，返回其最后一个单词的长度。

如果不存在最后一个单词，请返回 0 。

说明：一个单词是指由字母组成，但不包含任何空格的字符串。

示例:
输入: "Hello World"
输出: 5

public int LengthOfLastWord(string s) {

    if(s == null || s.Length == 0) return 0;

    //去除两边空格
    s = s.Trim();
    //从后面遍历到空格
    int length = 0;
    int index = s.Length - 1;
    while(index >= 0 && s[index] != ' ')
    {
        length++;
        index--;
    }

    return length;
}

报数序列是指一个整数序列，按照其中的整数的顺序进行报数，得到下一个数。其前五项如下：

1.     1
2.     11
3.     21
4.     1211
5.     111221

1 被读作  "one 1"  ("一个一") , 即 11。

11 被读作 "two 1s" ("两个一"）, 即 21。

21 被读作 "one 2",  "one 1" （"一个二" ,  "一个一") , 即 1211。

给定一个正整数 n ，输出报数序列的第 n 项。

注意：整数顺序将表示为一个字符串

示例 1:
输入: 1
输出: "1"
示例 2:
输入: 4
输出: "1211"

public string CountAndSay(int n) {
    if(n == 0) return "";
    
    string res  = "1";//初始化第一个报数
    StringBuilder tempRes;//临时计算报数的串
    for(int i = 2;i <= n;i++)
    {
        int index = 1;//有几个当前个体
        int targetIndex = 0;//当前个体
        tempRes = new StringBuilder();
        for(int j = 1;j < res.Length; j++)
        {
            //和前面的比较
            if(res[j-1] == res[j])
            {
                index++;
            }
            else
            {
                tempRes.Append( index.ToString() );
                tempRes.Append( res[targetIndex] );
                targetIndex = j;//更改当前个体为这个不相等的字符
                index = 1;//多少个，当然是1个了
            }
        }
        //收尾，最后一次的数数还没有算进来的
        tempRes.Append( index.ToString() );
        tempRes.Append( res[targetIndex] );
        res = tempRes.ToString();
    }

    return res;
}

没有办法的事了，只能不断的利用前一个数去推下一个数，直到推到指定位置的报数了