| java数据结构与算法刷题目录（剑指Offer、LeetCode、ACM）-----主目录-----持续更新(进不去说明我没写完)：https://blog.youkuaiyun.com/grd_java/article/details/123063846 |
|---|
- 思路分析
- 双指针遍历法，先得到中位数的下标
- 比如数组[1,2]和[3,4]，合起来是[1,2,3,4]那么中位数的下标就是2和3
- 然后用双指针，依次遍历数组，如果数组1的值比数组2的值小，那么记录这个值，然后数组1的下标后移
- 反之，数组2的下标后移。直到找到中位数
- 需要考虑数组长度不一样的问题，比如[1,2]和[1,2,3]，这样的情况，需要遍历完数组1后，只遍历数组2
- 最终，找到中位数对应的下标
- 代码
class Solution {
//双指针遍历法，先得到中位数的下标
// 比如数组[1,2]和[3,4]，合起来是[1,2,3,4]那么中位数的下标就是2和3
//然后用双指针，依次遍历数组，如果数组1的值比数组2的值小，那么记录这个值，然后数组1的下标后移
//反之，数组2的下标后移。直到找到中位数
//需要考虑数组长度不一样的问题，比如[1,2]和[1,2,3]，这样的情况，需要遍历完数组1后，只遍历数组2
//最终，找到中位数对应的下标
//时间复杂度O(min(m,n)) ===>> O((m+n)/2) 空间复杂度O(1)
public static double findMedianSortedArrays(int[] nums1, int[] nums2) {
int m = nums1.length;
int n = nums2.length;
int mid1 = (m+n)/2;//中位数的位置
int mid2 = mid1-1;//如果一共偶数个元素的中位数位置有两个
double chu = 2.0;//最终的除数，如果最终元素个数是偶数需要除2
if((m+n)%2!=0){//如果是奇数个元素，只有一个中位数，除数是1
mid2 = -1;//标志不用考虑第二个中位数
chu = 1;
}
int midnum1 = 0;//第一个中位数
int midnum2 = 0;//第二个中位数，没有就是0
int nums1Index = 0,nums2Index = 0;//第一个数组和第二个数组的下标
int num = 0;//辅助变量，记录当前遍历的元素
for(int i = 0;i<=mid1;i++){//遍历中位数(m+n)/2次
if(nums2Index>=n || (nums1Index < m && nums1[nums1Index]<=nums2[nums2Index])) {
num = nums1[nums1Index++];
}
else if(nums2Index<n){
num = nums2[nums2Index++];
}
if(i==mid1) midnum1 = num;//如果是中位数就赋值
if(mid2!=-1 &&i==mid2) midnum2 = num;//如果需要第二个中位数也赋值
}
return (midnum1+midnum2)/chu;
}
//时间复杂度O(min(m,n))空间复杂度O(1)
// public double findMedianSortedArrays(int[] nums1, int[] nums2) {
// if (nums1.length > nums2.length) {
// return findMedianSortedArrays(nums2, nums1);
// }
// int m = nums1.length;
// int n = nums2.length;
// int left = 0, right = m;
// // median1：前一部分的最大值
// // median2：后一部分的最小值
// int median1 = 0, median2 = 0;
// while (left <= right) {
// // 前一部分包含 nums1[0 .. i-1] 和 nums2[0 .. j-1]
// // 后一部分包含 nums1[i .. m-1] 和 nums2[j .. n-1]
// int i = (left + right) / 2;
// int j = (m + n + 1) / 2 - i;
// // nums_im1, nums_i, nums_jm1, nums_j 分别表示 nums1[i-1], nums1[i], nums2[j-1], nums2[j]
// int nums_im1 = (i == 0 ? Integer.MIN_VALUE : nums1[i - 1]);
// int nums_i = (i == m ? Integer.MAX_VALUE : nums1[i]);
// int nums_jm1 = (j == 0 ? Integer.MIN_VALUE : nums2[j - 1]);
// int nums_j = (j == n ? Integer.MAX_VALUE : nums2[j]);
// if (nums_im1 <= nums_j) {
// median1 = Math.max(nums_im1, nums_jm1);
// median2 = Math.min(nums_i, nums_j);
// left = i + 1;
// } else {
// right = i - 1;
// }
// }
// return (m + n) % 2 == 0 ? (median1 + median2) / 2.0 : median1;
// }
//时间复杂度O(max(m,n))，空间复杂度O(m+n)
// public static double findMedianSortedArrays(int[] nums1, int[] nums2) {
// int m = nums1.length;
// int n = nums2.length;
// int[] resultArr = new int[m+n];
// if(m == 0 || n==0)
// mergeTheExcess(resultArr,nums1,nums2,0,0, 0);
// else
// merge(resultArr,nums1,nums2,0,0,0);
// int len = resultArr.length;
// if(len%2==0){
// int i = resultArr[len/2-1];
// int j = resultArr[len/2];
// return (i+j)/2.0;
// }else{
// return resultArr[len/2];
// }
// }
// private static void merge(int[] resultArr,int[] nums1,int[] nums2,int i,int j,int resultArrIndex){
// if(i==nums1.length || j==nums2.length) return;
// if(nums1[i]<=nums2[j]){
// resultArr[resultArrIndex++] = nums1[i++];
// merge(resultArr,nums1,nums2,i,j, resultArrIndex);
// }else{
// resultArr[resultArrIndex++] = nums2[j++];
// merge(resultArr,nums1,nums2,i,j, resultArrIndex);
// }
// mergeTheExcess(resultArr,nums1,nums2,i,j, resultArrIndex);
// }
// private static void mergeTheExcess(int[] resultArr,int[] nums1,int[] nums2,int i,int j,int resultArrIndex){
// if(i==nums1.length){
// while(j<nums2.length){
// resultArr[resultArrIndex++] = nums2[j++];
// }
// }
// if(j==nums2.length){
// while(i<nums1.length){
// resultArr[resultArrIndex++] = nums1[i++];
// }
// }
// }
//时间复杂度O(log(m+n))，空间复杂度O(1)
// public double findMedianSortedArrays(int[] nums1, int[] nums2) {
// int length1 = nums1.length, length2 = nums2.length;
// int totalLength = length1 + length2;
// if (totalLength % 2 == 1) {
// int midIndex = totalLength / 2;
// double median = getKthElement(nums1, nums2, midIndex + 1);
// return median;
// } else {
// int midIndex1 = totalLength / 2 - 1, midIndex2 = totalLength / 2;
// double median = (getKthElement(nums1, nums2, midIndex1 + 1) + getKthElement(nums1, nums2, midIndex2 + 1)) / 2.0;
// return median;
// }
// }
// public int getKthElement(int[] nums1, int[] nums2, int k) {
// /* 主要思路：要找到第 k (k>1) 小的元素，那么就取 pivot1 = nums1[k/2-1] 和 pivot2 = nums2[k/2-1] 进行比较
// * 这里的 "/" 表示整除
// * nums1 中小于等于 pivot1 的元素有 nums1[0 .. k/2-2] 共计 k/2-1 个
// * nums2 中小于等于 pivot2 的元素有 nums2[0 .. k/2-2] 共计 k/2-1 个
// * 取 pivot = min(pivot1, pivot2)，两个数组中小于等于 pivot 的元素共计不会超过 (k/2-1) + (k/2-1) <= k-2 个
// * 这样 pivot 本身最大也只能是第 k-1 小的元素
// * 如果 pivot = pivot1，那么 nums1[0 .. k/2-1] 都不可能是第 k 小的元素。把这些元素全部 "删除"，剩下的作为新的 nums1 数组
// * 如果 pivot = pivot2，那么 nums2[0 .. k/2-1] 都不可能是第 k 小的元素。把这些元素全部 "删除"，剩下的作为新的 nums2 数组
// * 由于我们 "删除" 了一些元素（这些元素都比第 k 小的元素要小），因此需要修改 k 的值，减去删除的数的个数
// */
// int length1 = nums1.length, length2 = nums2.length;
// int index1 = 0, index2 = 0;
// int kthElement = 0;
// while (true) {
// // 边界情况
// if (index1 == length1) {
// return nums2[index2 + k - 1];
// }
// if (index2 == length2) {
// return nums1[index1 + k - 1];
// }
// if (k == 1) {
// return Math.min(nums1[index1], nums2[index2]);
// }
// // 正常情况
// int half = k / 2;
// int newIndex1 = Math.min(index1 + half, length1) - 1;
// int newIndex2 = Math.min(index2 + half, length2) - 1;
// int pivot1 = nums1[newIndex1], pivot2 = nums2[newIndex2];
// if (pivot1 <= pivot2) {
// k -= (newIndex1 - index1 + 1);
// index1 = newIndex1 + 1;
// } else {
// k -= (newIndex2 - index2 + 1);
// index2 = newIndex2 + 1;
// }
// }
// }
}
刷题一定要坚持，总结套路，不单单要把题做出来，要举一反三，也要参考别人的思路，学习别人解题的优点，找出你觉得可以优化的点。
- 单链表解题思路：双指针、快慢指针、反转链表、预先指针
- 双指针：对于单链表而言，可以方便的让我们遍历结点，并做一些额外的事
- 快慢指针：常用于找链表中点，找循环链表的循环点，一般快指针每次移动两个结点，慢指针每次移动一个结点。
- 反转链表：通常有些题，将链表反转后会更好做，一般选用三指针迭代法，递归的空间复杂度有点高
- 预先指针：常用于找结点，比如找倒数第3个结点，那么定义两个指针，第一个指针先移动3个结点，然后两个指针一起遍历，当第一个指针遍历完成，第二个指针指向的结点就是要找的结点
- 数组解题思路：双指针、三指针，下标标记
- 双指针：多用于减少时间复杂度，快速遍历数组
- 三指针：多用于二分查找，分为中间指针，左和右指针
- 下标标记：常用于在数组范围内找东西，而不想使用额外的空间的情况，比如找数组长度为n，元素取值范围为[1,n]的数组中没有出现的数字，遍历每个元素，然后将对应下标位置的元素变为负数或者超出[1,n]范围的正数，最后没有发生变化的元素，就是缺少的值。
- 栈解题思路：倒着入栈，双栈
- 倒着入栈：适用于出栈时想让输出是正序的情况。比如字符串’abc’，如果倒着入栈，那么栈中元素是（c,b,a）。栈是先进后出，此时出栈，结果为abc。
- 双栈：适用于实现队列的先入先出效果。一个栈负责输入，另一个栈负责输出。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
