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 no
4000
thead = 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++;

   

  }