java练习-数组练习、寻找数组的中心索引、两数之和、搜索插入位置、合并区间、旋转矩阵
寻找数组的中心索引
给定一个整数类型的数组 nums，请编写一个能够返回数组 “中心索引” 的方法。我们是这样定义数组 中心索引
的：数组中心索引的左侧所有元素相加的和等于右侧所有元素相加的和。如果数组不存在中心索引，那么我们应该返回
-1。如果数组有多个中心索引，那么我们应该返回最靠近左边的那一个。 示例 1：
输入： nums = [1, 7, 3, 6, 5, 6] 输出：3 解释： 索引 3 (nums[3] = 6) 的左侧数之和 (1 + 7 + 3 = 11)，与右侧数之和 (5 + 6 = 11) 相等。 同时, 3 也是第一个符合要求的中心索引
示例 2：
输入： nums = [1, 2, 3] 输出：-1 解释： 数组中不存在满足此条件的中心索引。
说明：
nums的长度范围为[0, 10000]。- 任何一个
nums[i]将会是一个范围在[-1000, 1000]的整数。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/find-pivot-index
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
我的理解
本题考的是对一位数组的操作，按照索引位，如果索引前的元素的和等于元素后的和，那么这个索引就符合要求，返回这个索引。
具体操作
1.利用.length方法判断出数组长度，然后遍历循环
2.利用遍历的索引在实现两个循环，分别计算索引前的和以及索引后的和
3.然后比较是否相等，如果相等返回这个索引，不相等就返回-1
根据以上思路可以实现代码
具体代码
public static void main(String[] args) { int [] arr = {-1,-1,-1,0,1,1}; System.out.println(pivotIndex(arr)); } public static int pivotIndex(int[] arr) { for (int i = 0; i < arr.length; i++) {//遍历整个数组 int s = 0;//存储左边得和 int q = 0;//存储右边得和 for (int j = i; j< arr.length; j++) { q += arr[j];//将索引对应元素相加 //System.out.println(q); } for (int n = i; n >= 0; n--) { s += arr[n]; //System.out.println(s); } if (s == q) { //判断是否相等 return i; } } return -1; } //返回索引位0
两数之和
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
示例:
给定 nums = [2, 7, 11, 15], target = 9 因为 nums[0] + nums[1] = 2 + 7 = 9 所以返回 [0, 1]
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/two-sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
我的理解
本题是对一位数组的基本操作，给定一个数组和一个数，遍历这个数组如果数组中有两个数相加等于给定的数，则返回这两个数的索引。
具体操作
1.判断数组大小进行数组循环
2.利用上面循环的索引在写一个循环，以上一个循环的索引位置的元素加上这个循环中索引位置的元素
3.判断给的值是否和这两个元素相加相等，相等就返回这两个索引
具体代码
public static void main(String[] args) { int [] arr = {3,2,4}; int target = 6; System.out.println(twoSum(arr, target)[0] + " " + twoSum(arr, target)[1]); System.out.println(twoSum(arr, target)[0] + " " + twoSum(arr, target)[1]); } //第一种 public static int[] twoSum(int[] nums, int target) { int [] num = new int [2];//定义长度为2的数组存储答案 for (int i = 0; i < nums.length - 1; i++) {//遍历数组 int sum = 0; for (int j = i + 1; j < nums.length; j++) {//遍历上面索引后的元素 sum = nums[i] + nums[j];//进行两个元素的求和 if (sum == target) {//判断和赋值 num[0] = i; num[1] = j; break; } } } return num; } //第二种 public static int[] Sum(int[] nums, int target) { int [] num = new int [2]; for (int i = 0; i < nums.length - 1; i++) { int s = target - nums[i]; for (int j = i + 1 ; j < nums.length ; j++) { if (s == nums[j]) { num[0] = i; num[1] = j; break; } } } return num; } //返回1 2
搜索插入位置
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
你可以假设数组中无重复元素。
示例 1:
输入: [1,3,5,6], 5
输出: 2
示例 2:
输入: [1,3,5,6], 2
输出: 1
示例 3:
输入: [1,3,5,6], 7
输出: 4
示例 4:
输入: [1,3,5,6], 0
输出: 0
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/search-insert-position
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
我的理解
本题是一个有序数组，在有序的数组查找元素，如果没有查到则就将这个数添加进这个数组，并排序。最简单的做法就是在定义一个数组，如果没有查到这个数，则将这个数和排序数组都加入这个新建数组，然后排序返回这个数组。，本题只需要返回这个索引就行，所以只要找出这个数的前一个数的索引加一。
具体操作
1.本题采用二分法比较节约时间
2.首先计算出数组num的长度high，然后定义出一个低索引变量low为0
3.使用while循环判断low < high
4.在while循环中计算high和low的中间值mid
5.判断num[mid]大于或等于传入的数target，则定义一个接收索引的ans=mid，然后high-1，否则low=mid+1
6.进行下一次while循环；
具体代码
public static void main(String[] args) { int [] arr = {1,3,5,6}; int a = 7; System.out.println(searchInsert(arr, a)); } public static int searchInsert(int[] nums, int target) { int low = 0,ans = nums.length;//定义低位索引low和索引长度 int high = nums.length-1;//定义数组长度 while(low <= high) { int mid = (high + low) >> 1;//利用位运算计算中间值 //System.out.println(mid); if (nums[mid] >= target) { //判断是否大于或等于tageet，符合就赋值给ans ans = mid; high = mid - 1; } else { low = mid + 1; } } return ans; }
合并区间
给出一个区间的集合，请合并所有重叠的区间。
示例 1:
输入: intervals = [[1,3],[2,6],[8,10],[15,18]] 输出: [[1,6],[8,10],[15,18]] 解释: 区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].
示例 2:
输入: intervals = [[1,4],[4,5]] 输出: [[1,5]] 解释: 区间 [1,4] 和 [4,5] 可被视为重叠区间。
注意：输入类型已于2019年4月15日更改。 请重置默认代码定义以获取新方法签名。
提示：
intervals[i][0] <= intervals[i][1]
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/merge-intervals
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
我的理解
本题是将一个二维数组 中相邻的一维数组如果前一个数组中[1]大于下一个数组中[0]则取前一个中的[0]后一个中的[1],何为一个数组，依次判断其余数组，返回一个新的合并数组。
具体操作
1.定义一个[.lenght][2]的数组来存储符合条件的合并数组
2.以二维数组中的[i][0]为条件对二维数组进行排序
3.利用循环判断是否符合我的理解中的条件，符合就添加进新的数组
具体代码
public static void main(String[] args) { int[][] nums = new int[][] { { 1, 3 }, { 1, 2 }, { 4, 5 }, { 3, 7 } }; int[][] s = merge(nums); for (int i = 0; i < s.length; i++) { for (int j = 0; j < s[i].length; j++) { System.out.print(s[i][j] + "\t"); } System.out.println(); } } public static int[][] merge(int[][] intervals) { int[][] res = new int [intervals.length][2];//存储合并数组 //使用数组中sort方法中Comparator函数表达式接口重写compare方法使用lamdba表达式简化来对数组进行简化 Arrays.sort(intervals, (a,b) -> a[0] - b[0]); int idx = -1;//索引 for(int[] arr : intervals) {//使用增强for遍历数组 if(idx == -1 || arr[0] > res[idx][1]) {//比较后一个的前一个是否大于前一个的后一个 res[++idx] = arr;//添加进合并数组 }else { res[idx][1] = Math.max(arr[1],res[idx][1]);//判断后一个的后一个和前一个的后一个的大小 } } return Arrays.copyOf(res, idx+1);//返回一个新的二维数组 }
旋转矩阵
给你一幅由 N × N 矩阵表示的图像，其中每个像素的大小为 4 字节。请你设计一种算法，将图像旋转 90 度。
不占用额外内存空间能否做到？
示例 1:
给定 matrix = [ [1,2,3], [4,5,6], [7,8,9] ], 原地旋转输入矩阵，使其变为: [ [7,4,1], [8,5,2], [9,6,3] ]
示例 2:
给定 matrix = [ [ 5, 1, 9,11], [ 2, 4, 8,10], [13, 3, 6, 7], [15,14,12,16] ], 原地旋转输入矩阵，使其变为: [ [15,13, 2, 5], [14, 3, 4, 1], [12, 6, 8, 9], [16, 7,10,11] ]
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/rotate-matrix-lcci
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
我的理解
题目要求是不占用额外内存空间，就是在原数组进行操作，这题可以在定义一个数组在存储原数组的值，然后通过这个数组来将原数组进行旋转赋值
具体操作
这里使用将旋转后的元素存储进行新的数组，然后将其中值赋给原数组
1.分析数组的旋转可以得到，按照示例1来说明。
2.坐标为00会变为坐标为02，01->12，02->22,
10->01,11->11.12->21,
20->00,21->10,22->20
通过以上可以发现旋转时都是一列过去，所以说旋转过去后的数组元素的后一位索引可以不变我们只要计算前一位索引，m*n数组，我们以m来计算不变的后一位，前一位变得索引以n来计算，得出随着循环索引变化为[n][m-1-i],其中i随着外层循环而增加，比如m = 3，n = 2，此时为
[0][3-1-0] = [0][0] -> [0][2] = [0][0]
[1][3-1-0] = [0][1] -> [1][2] = [0][1],
具体代码
public void rotate(int[][] matrix) { int [][] ma_new = new int[matrix[0].length][matrix.length]; for (int i = 0; i < matrix.length; i++ ) { for (int j = 0; j< matrix[i].length; j++) { ma_new[j][matrix.length - i - 1] = matrix[i][j]; } } for (int i = 0; i < matrix.length; i++ ) { for (int j = 0; j< matrix[i].length; j++) { matrix[i][j] = ma_new[i][j]; } } }
