关于leetcode中数组与字符串的一些命题

数组问题：

1.从排序数组中删除重复项

思路：先给数组排序，在Java语言当中，Arrays类包含诸多可以操控数组的函数，里面Arrays.sort(int nums[])直接可以将数组从小到大排序（Java源码中是这么写的，如想知道为何从小到大排序，请参考Java源码）。排序后，遍历整个数组，当遇到前面的数和其后面一个数不同的时候，就将该数往这个数组的前方放置，且用此类方法一直往后，然后将数组从无重复数字的长度出截断，最后输出的就是该内部无重复项的数组。

代码如下：

public int removeDuplicates(int[]nums)
{
Arrays.sort(nums);
int j=1;
for(int i=1;i<nums.length;i++)
{
if(nums[i-1]!=nums[i])
{
nums[j]=nums[i];
j++;
}
}
return j;

}

2.买卖股票的最佳时机II

这道题看似有点实际，其实就是判断数组中相邻的两个数如果后面的比前面的大，就求出后面的减去前面的差然后遍历数组将这些差加起来，就是所得到的全部利润。

如：[5,1,2,3,4]就是用[（2-1）+（3-2）+（4-3）]=[4-1]=3;

[7,5,4,3,2]这样没有后面比前面大的所得利润就是0；

代码如下：

  public int maxProfit(int[] prices) {
    int sum=0;
  for(int i=1;i<prices.length;i++)
  {
  if(prices[i]>prices[i-1])
  {
  sum+=(prices[i]-prices[i-1]);
  }
  }
  return sum;

    }

3.旋转数组

[1,2,3,4,5,6,7]=>[5,6,7,1,2,3,4]一眼就看到是如何旋转的了，就像将数组从1往前推，然后1到后面去了，5，6，7去了前面成为了前面3个，这样就推了三步。

思路：将这个数组先颠倒，然后将要所推的步数k，将颠倒后的数组[0,k-1]的子数组进行颠倒，然后将[k,nums.lengh-1]的子数组进行颠倒，之后就得出旋转数组了。（注：别忘了给k的值进行判断，不能够是负数）

代码如下：

  public void rotate(int[] nums, int k) {
       k=(nums.length+(k%nums.length))%nums.length;
      int tmp=0;
      for(int i=0,j=nums.length-1;i<j;i++,j--)    
      {
      tmp=nums[i];
      nums[i]=nums[j];
      nums[j]=tmp;
      }
      for(int i=0,j=k-1;i<j;i++,j--)
      {
      tmp=nums[i];
      nums[i]=nums[j];
      nums[j]=tmp;
      }
      for(int i=k,j=nums.length-1;i<j;i++,j--)
      {
      tmp = nums[i];
      nums[i]=nums[j];
      nums[j]=tmp;
      }
      

    }

4.存在重复

思路：探寻数组中是否存在重复的元素，用hashset类的contains与add函数来判断，因为add是将数组中的元素添加到hashset中去，contains是判断某个元素到底有没有出现在hashset里面过。

代码如下：

public boolean containsDuplicate(int[]nums)
{
Set<Integer> set = new HashSet<>();
for(int i=0;i<nums.length;i++)
{
if(set.contains(nums[i]))
{
return true;
}
set.add(nums[i]);
}
return false;

}

5.只出现一次的数字

思路：这个问题是给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。所以这个问题还是很简单的。

通过^=这个运算符，会自动将int型的二进制进行位位的相与运算（即0^1=0,1^1=1），所以将数组中所有数字全部相与之后得到最终的那个数字就是单独的那个数字。

代码如下：

public int singleNumber(int[] nums) {
         int num=0;
        for(int i=0;i<nums.length;i++)
        {
        num^=nums[i];
        }
        return num;
    }

字符串问题：

1.反转字符串

思路：将字符串中的每一个元素都用charAt()拆分出来（记住charAt()只能用于字符串的拆分，细致到将每一个元素拆分出来）然后颠倒的放入一个char型的数组，然后将这个char型的数组再次转化为字符串。

代码如下：

 public String reverseString(String s) {

     char []array = new char[s.length()];
  for(int i=0;i<array.length;i++)
  {
  array[i]=s.charAt(s.length()-i-1);
  }
  return String.valueOf(array);

    }

2.颠倒整数

123变为321，-321变为-123，120变为21，如果超出范围就返回0

思路：将int型整数放置在long型之中，然后将最后的那个数字取出（即用整数取余即可）然后乘10叠加，最后得到结果，超出范围就返回0。

代码如下：

public int reverse(int x) {
          long result = 0;
      long X=x;
      while(X!=0)
      {
      result = result*10+X%10;
      X=X/10;
      }
      if(result<Integer.MIN_VALUE||result>Integer.MAX_VALUE)
      {
      result=0;
      }
      return (int) result;

    }

3.字符串中的第一个唯一字符

思路：在Java语言中有一个很特别的计数方法，就如此题一样，代码中运用了一个字符的计数方式

代码如下：

public int firstUniqChar(String s) {

        if (s == null || s.equals("")) return -1;
        char[] c = s.toCharArray();
        int[] cnt = new int[256];
        for (int i = 0; i < c.length; i++) {
            cnt[c[i]]++;
        }
        for (int i = 0; i < c.length; i++) {
            if (cnt[c[i]] == 1) return i; 
        }
        return -1;

    }

代码中将字符串s转化为字符数组， char[] c = s.toCharArray();

   int[] cnt = new int[256];
        for (int i = 0; i < c.length; i++) {
            cnt[c[i]]++;

        }

然后自动用ASCLL码的形式放入cnt[]的索引位置，cnt[c[i]]++进行计数，看看有那个字符出现了好几次，就是用其ASCLL码在cnt的索引位中出现了多少次一样。

4.有效的字母异位词

思路：字母都是一样的字母，只是换了个位置而已，其他的没有任何改变。

代码如下：

   public boolean isAnagram(String s, String t) {
        char[] sArr = s.toCharArray();  
        char[] tArr = t.toCharArray();  
        Arrays.sort(sArr);  
        Arrays.sort(tArr);      
        return String.valueOf(sArr).equals(String.valueOf(tArr));

    }

5.验证回文字符串

思路：判断一个字符串是否对开，即首尾呼应（例如：“level”或者“levvel”这就是回文）

代码如下：

public boolean isPalindrome(String s) {
        StringBuilder buffer = new StringBuilder();  
        String tempStr = "abcdefghijklmnopqrstuvwxyz0123456789";   
        char[] cArr = s.toCharArray();  
        for (int i = 0; i < cArr.length; i++) {   
            if (tempStr.contains(String.valueOf(cArr[i]).toLowerCase())) {  
                buffer.append(String.valueOf(cArr[i]).toLowerCase());  
            }  
        }  
        String currentStr = buffer.toString();  
        String reverseStr = buffer.reverse().toString();  
        if (currentStr.equals(reverseStr)) {  
            return true;  
        }  
        return false;  
    }