- 从排序数组中删除重复项
给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。
不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。
自己问题代码（及正解）：
PS：自己的问题出在，没有看清楚题目，并且将赋值语句混乱为移动。
细节在于i++处，当相等的时候i下标先向后移动，在进行比较。
// 在一个数组中只能是赋值操作，不能修改长度。 length是静态常量
// 此方法为自己的方法，只能用于统计不重复的个数
public static int removeDuplicates(int[] nums) {
int b = nums.length;
for (int i = 0; i < nums.length - 1; i++) {
if (nums[i] == nums[i + 1]) {
b--;
}
}
return b;
}
*******正解********
public static int remove(int[] nums) {
if (nums.length == 0)
return 0;
int i = 0;
for (int j = 1; j < nums.length; j++) {
if (nums[j] != nums[i]) {
i++; // 这一步很关键，请注意。
nums[i] = nums[j];
System.out.println(nums[i]);
}
}
return i + 1;
}
2.旋转数组
给定一个数组，将数组中的元素向右移动k 个位置，其中k 是非负数。
输入:[1,2,3,4,5,6,7]和k= 3 输出:[5,6,7,1,2,3,4]
解释：
向右旋转 1 步:[7,1,2,3,4,5,6]
向右旋转 2 步:[6,7,1,2,3,4,5]
向右旋转 3 步:[5,6,7,1,2,3,4]
说明:
尽可能想出更多的解决方案，至少有三种不同的方法可以解决这个问题。
要求使用空间复杂度为 O(1) 的原地算法。
正解（自己结合网友的解法写的）：
public static void rotate(int nums [] , int k ){
int len = nums.length;
if(len<=1) return;
int a [] = new int [len];
for(int i =0 ; i<len ; i++){
a[i] = nums[i];
}
k = k%len; //去重
for(int i = 0 ; i<len ; i++){
int s = k+i;
s = s %len;
nums [s] = a[i];
}
}
注：以下解法并没有完全满足题目要求
解法（一）：
ps：在增加数组的操作上要注意：传值引用问题。 （使用了数组返回修改原引用）
public static int [] rotate1(int nums [] ,int k) {
int len = nums.length;
int a[] = new int[len];
for (int i = 0; i < len; i++) {
int s = k + i;
if (s >= len) {
s = s % len;
a[s] = nums[i];
}
a[s] = nums[i];
}
nums = a;
return nums;
}
解法（二）：
ps：时间复杂度过高。
public static void rotate3(int[] nums, int k) {
int len = nums.length;
if (len > 1) {
for (int i = 0; i < k; i++) {
int temp = nums[0];
nums[0] = nums[len - 1];
for (int j = len - 1; j > 1; j--) {
nums[j] = nums[j - 1];
}
nums[1] = temp;
}
}
}
3.只出现一次的数字
给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。
说明：
你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？
示例 1:
输入: [2,2,1]
输出: 1
示例 2:
输入: [4,1,2,1,2]
输出: 4
使用Java语言，想了很久通过下标来实现，但是没成功。在网上找到结果，利用异或来实现。细想一下这题主要考位运算符中的 ^ (异或) 运算符。 知识欠缺所致！
public int singleNumber(int[] nums) {
int res = 0 ;
for(int i = 0 ; i<nums.length ; i++){
res = res^nums[i] ;
}
return res;
}
转载：位运算符知识补充 .
https://blog.csdn.net/xiaopihaierletian/article/details/78162863
- 两个数组的交集 II
给定两个数组，编写一个函数来计算它们的交集。
示例 1:
输入: nums1 = [1,2,2,1], nums2 = [2,2]
输出: [2,2]
思路：最开始想到的是用最传统的下标来进行解决，发现写出的代码太过于复杂，可读性很差，而且时间复杂度太高了。
于是百度出正解。（对于Java中对于一些复杂数组的问题，应该结合类集中的底层数据结构来进行求解会更好。）
public int[] intersect(int[] nums1, int[] nums2) {
List<Integer> tmp = new ArrayList<>();
HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();
for(int i = 0 ;i<nums1.length;i++){
Integer temp = map.get(nums1[i]);
map.put(nums1[i],(temp == null? 0:temp)+1);
}
for(int i=0;i<nums2.length;i++){
if(map.containsKey(nums2[i])&&map.get(nums2[i])!=0){
tmp.add(nums2[i]);
map.put(nums2[i],map.get(nums2[i])-1);
}
}
int[] result = new int[tmp.size()];
int i = 0;
for(Integer in : tmp){
result[i++] = in;
}
return result;
}
5.两数之和
给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。
你可以假设每个输入只对应一种答案，且同样的元素不能被重复利用。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
思路：最开始想的是将数组装到集合中在进行值的判断，因为这样可以将已经获得的元素进行删除，不用在写删除元素的底层代码，也实现了，但是这样的方式增加了时间复杂度。后来用数组就可以直接解决，虽然时间复杂度下降了，但是离标准还是偏高。
public int [] twoSum(int [] nums , int target){
int result [] = new int [2];
for(int i = 0 ; i<nums.length ; i++){
for(int j = i+1 ; j<nums.length ; j++){
if(nums[i] + nums[j] == target){
result[0] = i;
result[1] = j;
break;
}
}
}
return result;
}