Leetcode 88 89 104

88.合并两个有序数组

题目描述：给你两个有序整数数组 nums1 和 nums2，请你将 nums2 合并到 nums1 中，使 nums1 成为一个有序数组。
初始化 nums1 和 nums2 的元素数量分别为 m 和 n 。你可以假设 nums1 的空间大小等于 m + n，这样它就有足够的空间保存来自 nums2 的元素。

思路：nums1有足够的空间，因此可以从nums1的m-1，nums2的n-1开始从后往前比较，把较大的放在nums1的尾部。
代码如下：

     public class Solution
     {
         public void Merge(int[] nums1, int m, int[] nums2, int n)
         {
             int p1 = m - 1;
             int p2 = n - 1;
             int p = m + n - 1;
             while (p >= 0)
             {
                 if (p1 < 0)
                 {
                     nums1[p] = nums2[p2];
                     p2--;
                     p--;
                 }
                 else if (p2 < 0)
                 {
                     nums1[p] = nums1[p1];
                     p1--;
                     p--;
                 }
                 else if (nums1[p1] < nums2[p2])
                 {
                     nums1[p] = nums2[p2];
                     p--;
                     p2--;
                 }
                 else
                 {
                     nums1[p] = nums1[p1];
                     p--;
                     p1--;
                 }
             }
         }
     }

89.格雷编码

题目描述：格雷编码是一个二进制数字系统，在该系统中，两个连续的数值仅有一个位数的差异。
给定一个代表编码总位数的非负整数 n，打印其格雷编码序列。即使有多个不同答案，你也只需要返回其中一种。
格雷编码序列必须以 0 开头。

思路：先将0存入列表，以0为基础进行扩展。
代码如下：

     public class Solution
     {
         public IList<int> GrayCode(int n)
         {
             IList<int> result = new List<int>();
             result.Add(0);
             for (int i = 0; i < n; i++)
             {
                 for (int j = result.Count-1;j>=0;j--)
                 {
                     int item = result[j] + (1 << i);
                     result.Add(item);
                 }
             }
             return result;
         }
     }

104.二叉树的最大深度

题目描述：给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。

思路：利用队列，对二叉树进行层次遍历，每遍历完一层深度就加一。
代码如下：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left;
 *     public TreeNode right;
 *     public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
     public class Solution
     {
         public int MaxDepth(TreeNode root)
         {
             if (root == null)
                 return 0;
             Queue<TreeNode> queue = new Queue<TreeNode>();
             int result = 0;
             queue.Enqueue(root);
             while (queue.Count != 0)
             {
                 result++;
                 int size = queue.Count;
                 for (int count = 0; count < size; count++)
                 {
                     TreeNode temp = queue.Dequeue();
                     if (temp.left != null)
                         queue.Enqueue(temp.left);
                     if (temp.right != null)
                         queue.Enqueue(temp.right);
                 }
             }
             return result;
         }
     }