初级算法【数组】

---

• 单个数组

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

说明：

你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？

示例 1:
输入: [2,2,1]
输出: 1

示例 2:
输入: [4,1,2,1,2]
输出: 4

使用异或运算 把数组中所有字母异或 剩下的就是那个只出现了一次的元素
a^a=0 a^0=a 最终剩下的就是只出现了一次的元素 线性复杂度为O(n)

class Solution{
	public int SingleNumber(int[] nums){
		int reduce = 0;
		for(int num:nums)
			reduce = reduce^num;
		return reduce;
	}
}

• 旋转数组

给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。
进阶：
尽可能想出更多的解决方案，至少有三种不同的方法可以解决这个问题。
你可以使用空间复杂度为 O(1) 的 原地 算法解决这个问题吗？

示例 1:

输入: nums = [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]

//新数组
class Solution{
	public void ratate(int[] nums;int k){
		int length = nums.length;
		int temp[] = new int[length];
		for(int i = 0 ;i<length;i++){
			temp[i] = nums[i];
		}
		for(int i = 0;i<length;i++){
			nums[(i+k)%length] = temp[i];
		}
	}
}

//数组反转
class Solution{
	public void rotate(int nums[],int k){
		int length  = nums.length;
		reverse(nums,0,length-1)
		reverse(nums,0,k-1)
		reverse(nums,k,length-1)
	}
	public void reverse(int nums[],int start,int end){
		while(start<end){
			int temp = nums[start];
			nums[start++] = nums[end];
			nums[end--] = temp;
		}
	}
}

//循环
class Solution{
	public static void rotate(int nums[],int k){
		int hold = nums[0];
		int index = 0;
		int length = nums.length;
		boolean[] visited = new boolean[length];
		for(int i =0;i<length;i++){
			index = (index+k)%length;
			if(visited[index]){
				index = (index+1)%length;
				hold = nums[index];
				i--;
			}else{
				visited[index] = true;
				int temp = nums[index];
				nums[index] = hold;
				hold = temp;
			}
		}
	}
}

//函数
class Solution{
	public void rotate(int[] nums,int k){
		k = k%nums.length;
//Arrays.copyOfRange(数组，开始位置，结束位置）
		int[] rightpart = Arrays.copyOfRange(nums,nums.length-k,nums.length);
//arraycopy(源数组，起始位置，目标数组，目标数组起始位置，转移个数）
		System.arrraycopy(nums,0,nums,k,nums.length-k);
		System.arraycopy(rightpart,0,nums,0,k);
	}
}

• 两个数组的交集

给定两个数组，编写一个函数来计算他们的交集

示例 1：
输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2,2]

示例 2:
输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[4,9]

说明：
输出结果中每个元素出现的次数，应与元素在两个数组中出现次数的最小值一致。
我们可以不考虑输出结果的顺序。
进阶：
如果给定的数组已经排好序呢？你将如何优化你的算法？
如果 nums1 的大小比 nums2 小很多，哪种方法更优？
如果 nums2 的元素存储在磁盘上，内存是有限的，并且你不能一次加载所有的元素到内存中，你该怎么办？

//排序双指针
class Solution{
	public int[] intersect(int[] nums1,int[] nums2){
	//对两数组排序
	Arrays.sort(nums1);
	Arrays.sort(nums2);
	int i=0;
	int j=0;
	List<Integer> list = new ArrayList<>();
	while(i<nums1.length && j<nums2.length){
	   if(nums1[i]<nums2[j])
	   	  i++;
	   else if(nums1[i]>nums2[j])
	   	  j++;
	   else{
	   	  list.add(nums1[i]);
	   	  i++;
	   	  j++;
	   }
	}
	//转化为数组
	int index = 0;
	int[] res = new int[list.size()];
	for(int k=0;k<list.size();k++){
		res[index++] = list.get(k);
	}
	return res;
	}
}

//使用map解决
class Solution{
	public int[] intersect(int[] numsl,int[] nums2){
	  HashMap<Integer,Integer>map = new HashMap<>();
	  ArrayList<Integer> list = new ArrayList<>();
	  for(int i=0;i<nums1.length;i++){
	    map.put(nums1[i],map.getOrDefault(nums1[i],0)+1);
	    //map.put 获取map集合的所有键名存放在一个Set集合中。
	    //map.getOrDefault 获取key对应的 value 若没有则返回默认值
	   }
	  for(int i=0;i<nums2.length;i++){
	    if(map.getOrDefault(nums2[i],0)>0){
	      list.add(nums2[i]);
	      map.put(nums2[i],map.get(nums2[i])-1);
	    }
	  }
	  //集合转化为数组
	  int[] res = new int[list.size()];
	  for(int i=0;i<list.size();i++){
	    res[i] = list.get(i);
	  }
	  return res;
   }
}

总结 对数组链表不同集合之间的关系还不是很清楚，遇到题目还是有些手足无措，明天要理一篇关于不同集合区别的文章出来。多学多练会慢慢变好的。