Leetcode自我做题总结汇总（持续更新）

344. Reverse String（Easy）

解题思路：1.先将字符串转化为数组（.toCharArray）

                  2.数组前后对调（将第一个和倒数第一个对调，第二个和倒数第二个对调）

                  3.将数组转化为字符串(String.valueof())

核心代码：

                  char[] b = s.toCharArray();//step 1
                  for(int i = 0 ;i<=s.length()/2-1;i++)//step 2
                  {
                  char tmp = b[i];
                  b[i] = b[s.length()-1-i];
                  b[s.length() -i-1] = tmp;
                  }
 
                 s= String.valueOf(b);step 3
                 return s;

290. Word Pattern

问题解析：

    将两个字符串匹配。 Examples:

             pattern = "abba", str = "dog cat cat dog" should return true.

             pattern = "abba", str = "dog cat cat fish" should return false.

解题思路：

          将str按照空格分解成字符串数组。然后将pattern分解成char类型数组，然后两个循环遍历比较。（自己的方法，时间复杂度有点大）

         

核心代码：

          String[] s =str.split(" ");

          Char[] c = pattern.toCharArray();

          for(int i = 0;i<s.length;i++)

          {

             for(int j=i+1; j<s.length;j++)

                    {

                            if(s[i].equal(s[j])){

                                 if(c[i]!=c[j]) return false;

                                                    }else  if (c[i]==c[j]) return false;

                     }

           }

21. Merge Two Sorted Lists

问题解析：

        将两个已经从小到大排序好的链，融合为一个从小到大的链。

解题思路：

        将两个链表，元素之间比较，递归比较。

核心代码：

           public ListNode mergeTwoLists(ListNode l1, ListNode l2) {

           if(l1==null) return l2;

           if(l2==null) return l1;

           ListNode  head = l1.val > l2.val ？ l2:l1;

           ListNode nothead = l1.val >l2.val ? l1:l2;

           head = mergeTwoLists(head.next,nothead);

           return head;

}

121. Best Time to Buy and Sell Stock

问题解析：数组中，每个元素代表的是物品的价钱，你要买卖物品，并且卖出最大利润。

  for example: Input: [7, 1, 5, 3, 6, 4]
                       Output: 5

 核心代码：

            int max=0;

            int min =a[0];

            for(int i =0;i<a.length;i++)

            {

                   if(min<a[i])

                   {

                           max = Math.max(max,a[i]-min);

                    }else

                    {

                         min = a[i];

                      }

             }

            return max;

70. Climbing Stairs

问题解析：有n阶台阶，每次爬1阶或2阶，有几种爬法。

   //思路：爬楼梯就是裴波那契数列
//
//补：裴波那契数列
//
//斐波那契数列：0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, ...
//
//注：此时a1=0，a2=1，an=a(n-1)+a(n-2)（n>=2,n∈N*）
//
//即：裴波那契数列的第n项的值是第n阶楼梯的爬法的种类数
    public int climbStairs(int n) {
        if(n==1||n==0) return n;
     int sum;
     int j =1;
     int i = 0;
     int o = 0;
  do{
   sum = i+j;
      i = j;
      j= sum;
      o++;
     }while (o<n);
  return sum;
    }
}

100. Same Tree

问题解析：就是两个二叉树是否相同。

解题思路：先判断两个树，是否存在，然后递归比较节点和左右节点是否相同。

核心代码：

              

                 

    public boolean isSameTree(TreeNode p, TreeNode q) {
    if(p == null && q == null) return true;
    if(p == null || q == null) return false;
    return p.val == q.val && isSameTree(p.left, q.left) && isSameTree(p.right, q.right);

    }

ts

349. Intersection of Two Arrays

问题解析：问题是求解两个数组之间有相同的元素，并将相同的元素输出，且输出的元素是唯一不重复的。Example:
Given nums1 = [1, 2, 2, 1], nums2 = [2, 2], return [2].

解题思路：就是遍历找到相同的元素，并将相同的元素放到一个set中，避免重复。

核心代码：

                  public int[] intersection(int[] nums1, int[] nums2) {
                   Set<Integer> result = new HashSet<Integer>();
                        int l1=nums1.length;
                        int l2=nums2.length;
                        int o = 0;
                       for(int i = 0;i< l1 ; i++)
                       {
                       for(int j = 0;j<l2;j++)
                      {
                      if(nums2[j]==nums1[i])
                       {
                        result.add(nums2[j]);
                      }
                       }
                      }
                      int[] end = new int[result.size()];
                      Iterator<Integer> it = result.iterator();
                      while(it.hasNext()) 
                       {
                       end[o]= (int)it.next();
                       o++;
                        }
                       return end;
                       }

226. Invert Binary Tree(Easy)

问题解析：反转二叉树，

    4                                     
   /   \
  2     7               to
  / \   / \
1   3 6   9

     4
   /   \
  7     2
  / \   / \
9   6 3   1

解题思路：递归，先将根节点，左右子节点交换，然后递归它的左右节点。

核心代码：

               public root invertTree(TreeNode t){

                if (root== null )  return   null ;       

                TreeNode temp  = root.left;  

                 root.left = root.right;  

                root.right = temp;             

                invertTree(root.left);  

                 invertTree(root.right);  

         

                return root;      }

             

       

104. Maximum Depth of Binary Tree(Easy)

问题解析：寻找二叉树的的最深层数

解题思路：采用递归的思想，从树根开始，左右子节点往下广度搜索。直到节点为叶节点为止。

核心代码：public int MaxDepth(TreeNode t)

                 {

                 if(t==None) return 0;

                 return 1+Math.max(MaxDepth(t.left),MaxDepth(t.right));

                 }

292. Nim Game(Easy)

问题解析：一堆石头，你和你朋友可以抓取1-3哥石头，最后抓光石头的人，为胜利者。（两人都足够聪明，并且答题者先抓）

解题思路：这道题，其实是个发现规律的一道题，更多的考察的是我的智商。然后，可以找到寻规律，当这堆石子为4的整数倍时，先抓的那个人肯定输，而后抓的那个人肯定赢。如果不是4的倍数，情况相反。

核心代码 ：

                 return (s%4)！=0；

258. Add Digits（Easy）

问题解析：给你个整数，你把这个整数的各位数字相加，如果仍为一个>9的整数，依然需要将它的各位相加，直到这个数只剩下个位。

解题思路：这个题，我是看了别人的方法，才找到答案的。首先找出规律，设所求数为x,且x=ABCDE。

                 x=A*(9999+1)+B*(999+1)+C*(99+1)+D*(9+1)+E*(1)

                   =A*9*1111+B*9*111+C*9*11+D*9*1+A+B+C+D+E

                 因为 a * 9999 + b * 999 + c * 99 + d * 9 一定可以被9整除，因此num模除9的结果与 a + b + c + d + e 模除9的结果是一样的。

                 然后对数字a+b+c+d+e，一直这样算，它还是会由两部分组成，左边是一串能被9整除的数字，右边是一个1-9之间的数字组成。

核心代码：

               return (s-1)%9+1;

283. Move Zeroes（Easy）

问题解析：给你一个int数组（a），将数组中的‘0’元素挪动到数组的最后，同时保持之前非0元素的排列顺序。

解题思路：这个题，是在数组上先设两个指针，指向a[0],i是首先判断i所在的位置是否为0元素，如果不是，则i和j同时移动到下一个位置，如果是0，则由j指针向后查找非0元  素，找到非0元素后，j指针指向的非0元素和i指向的0元素互换。然后i移动到下一个位置，如此反复，指导j找不到非0元素，也就是j指针走到数组的最后一位。

核心代码：

    for(int i=0 ,j=0; j<nums.length;i++)
  {
    
   if(nums[i] == 0 )
   {
    while(nums[j]==0 && j<nums.length-1)
    {
     j++;
    
    }
    nums[i] = nums[j];
    nums[j]=0;

   }
   j++;
   
  }