[算法Rust,Go,Python,JS实现)]LeetCode之4-寻找两个有序数组的中位数

题目

给定两个大小为 m 和 n 的有序数组 nums1 和 nums2。

请你找出这两个有序数组的中位数，并且要求算法的时间复杂度为 O(log(m + n))。

你可以假设 nums1 和 nums2 不会同时为空。

示例 1:

nums1 = [1, 3]
nums2 = [2]

则中位数是 2.0
示例 2:

nums1 = [1, 2]
nums2 = [3, 4]

则中位数是 (2 + 3)/2 = 2.5

思路

1.边界判断：
  1）当nums1为空时计算nums2：如果nums2数组元素个数为1个时，则返回nums2[0];个数大于1：如果偶数个，返回数组中间两数和/2,奇数：返回中间一个数。
  2）当nums2为空时，同1）
2.计算两个数组的总长度len_sum,循环次数最大值：limit;循环计数：times;和保存元素的数组ans
3.当满足条件while (times < limit),进行判断：
 1） 如果两个元素都不为空，则进行判断：如果nums1[0] > nums2[0],如果成立：ans.push(nums2[0]),同时移出当前元素nums2.pop(0)；反之一样操作。。。。
 2）当一个数组为空，另一个数组不为空，则同1）操作
4.判断返回  

Rust实现

impl Solution {
    pub fn find_median_sorted_arrays(nums1: Vec<i32>, nums2: Vec<i32>) -> f64 {
        let len1 = nums1.len();
        let len2 = nums2.len();
        let mut nums_1 = nums1.clone();
        let mut nums_2 = nums2.clone();
        if len1 == 0 {
            if len2 == 1 {
                return nums2[0] as f64;
            } else {
                if len2 % 2 == 0 {
                    let v = len2 / 2;
                    return ((nums2[v] + nums2[v-1]) as f64)/2.0;
                } else {
                    let v = len2 / 2;
                    return nums2[v] as f64;
                }
            }
        }
        if len2 == 0 {
            if len1 == 1 {
                return nums1[0] as f64;
            } else {
                if len1 % 2 == 0 {
                    let v = len1 / 2;
                    return ((nums1[v] + nums1[v-1]) as f64)/2.0;
                } else {
                    let v = len1 / 2;
                    return nums1[v] as f64;
                }
            }
        }
        let mut limit = 0;
        let mut times = 0;
        let mut  flag = 0;
        let len_sum = len1 + len2;
        if len_sum % 2 == 0 {
            flag = 2;
//            循环的次数
            limit = len_sum / 2 + 1
        } else {
            flag = 1;
            limit = len_sum / 2 + 1
        }
        let mut ans = vec![];
        while times < limit {
            let mut l1 = nums_1.len();
            let mut l2 = nums_2.len();
            let l = ans.len();
            if l1 != 0 && l2 != 0 {
                if nums_1[0] > nums_2[0] {
                    let el = nums_2[0];
                    ans.push(el);
                    nums_2.remove(0 as usize);
                } else {
                    let el = nums_1[0];
                    ans.push(el);
                    nums_1.remove(0 as usize);
                }
            } else if l1 == 0 && l2 != 0 {
                let el = nums_2[0];
                ans.push(el);
                nums_2.remove(0 as usize);
            } else if l2 == 0 && l1 != 0 {
                let el = nums_1[0];
                ans.push(el);
                nums_1.remove(0 as usize);
            }
            times += 1
        }
        let l = ans.len();
        if flag == 2 {
           return  ((ans[l-1] + ans[l-2]) as f64)/2.0;
        } else {
            return ans[l-1] as f64;
        }
    }
}

GO实现

func findMedianSortedArrays(nums1 []int, nums2 []int) float64 {
	//边界判断
	nums_1 := nums1
	nums_2 := nums2
	len1 := len(nums1)
	len2 := len(nums2)
	if len1 == 0 {
		if len2 == 1 {
			return  float64(nums_2[0])
		} else {
			v := len2/2
			if len2 % 2 == 0{
				return  float64(nums_2[v-1]+nums_2[v])/2.0
			} else {
				return float64(nums_2[v])
			}
		}
	}
	if len2 == 0 {
		if len1 == 1 {
			return float64(nums_1[0])
		} else {
			v := len1/2
			if len1 % 2 == 0{
				return float64(nums_1[v-1]+nums_1[v]) / 2.0
			} else {
				return float64(nums_1[v])
			}
		}
	}
	len_sum := len1 + len2
	flag_s :=  0
	limit_c := 0
	if len_sum % 2 == 0 {
		flag_s = 2
		limit_c = len_sum / 2 + 1.0
	} else {
		flag_s = 1
		limit_c = len_sum / 2.0 + 1
	}
	times := 0
	ans := []int{}

	for;times < limit_c;{
		l1 := len(nums_1)
		l2 := len(nums_2)
		fmt.Println("1->",nums_1,"2->",nums_2)
		if l1 != 0 && l2 != 0{
			if nums_1[0] > nums_2[0]{
				ans = append(ans, nums_2[0])
				nums_2 = nums_2[1:]
			} else {
				ans = append(ans, nums_1[0])
				nums_1 = nums_1[1:]
			}
		} else if l1 == 0 && l2 != 0 {
			ans = append(ans, nums_2[0])
			nums_2 = nums_2[1:]
		} else if l2 == 0 && l1 != 0 {
			ans = append(ans, nums_1[0])
			nums_1 = nums_1[1:]
		}
		times += 1
	}
	if flag_s == 1 {
		l := len(ans)
		return float64(ans[l-1])
	} else {
		l := len(ans)
		return float64((ans[l-1] + ans[l-2]))/2
	}
}

Python实现

class Solution:
    def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
        if not nums1:
            if len(nums2)%2==0:
                return (nums2[int(len(nums2)/2-1)]+nums2[int(len(nums2)/2)])/2.0
            else:
                return nums2[math.floor(len(nums2)/2)]/1.0
        if not nums2:
            if len(nums1)%2==0:
                return (nums1[int(len(nums1)/2)-1]+nums1[int(len(nums1)/2)])/2.0
            else:
                return nums1[math.floor(len(nums1)/2)]/1.0
        length_of_1=len(nums1)
        length_of_2=len(nums2)
        totallength =length_of_2+length_of_1
        if totallength%2==0:
            n=2
            limit=totallength/2 + 1
        else:
            n=1
            limit=totallength/2
        times=0
        ans=[]
        while times<limit:
            if nums1 and nums2:
                if nums1[0]>nums2[0]:
                    ans.append(nums2.pop(0))
                    
                else:
                    ans.append(nums1.pop(0))
                    
            elif not nums1 and nums2:
                ans.append(nums2.pop(0))
                
            elif not nums2 and nums1:
                ans.append(nums1.pop(0))
                
            times+=1
        if n==1:
            return ans[-1]/1.0
        else:return (ans[-1]+ans[-2])/2.0

JavaScript实现

var findMedianSortedArrays = function (nums1, nums2) {
    let nums_1 = nums1
    let nums_2 = nums2
    // 计算长度
    let len1 = nums_1.length
    let len2 = nums_2.length
    let arr2_c = 0
  // 边界判断
  if(len1==0) {
     if (len2 == 1) {
         arr2_c = nums_2[0]
     } else {
         let v = parseInt(len2/2)
         if(len2%2 == 1) {
             arr2_c = nums_2[v]
         } else {
             arr2_c = (nums_2[v-1] + nums_2[v])/2.0
         }
       return arr2_c
     }
   }
  if (len2 == 0) {
      if (len1 == 1) {
          arr2_c = nums_1[0]
      } else {
          let v = parseInt(len1/2)
          if(len1%2 == 1) {
              arr2_c = nums_1[v]
          } else {
              arr2_c = (nums_1[v-1] + nums_1[v])/2.0
          }
      }
      return arr2_c
  }
  let len_sum = len2 + len1
  let flag = 0
  let limit = 0
  if (len_sum%2==0) {
     flag = 2
      limit = len_sum / 2 + 1
  } else {
      flag = 1
      limit = len_sum / 2

  }
  let times = 0
    let ans = []
    while (times < limit) {
      let l1 = nums_1.length
      let l2 = nums_2.length
      if (l1 !==0 && l2!==0 ) {
          if (nums_1[0] > nums_2[0]){
              let v = nums_2.shift()
              ans.push(v)
          } else {
              let v = nums_1.shift()
              ans.push(v)
          }
      } else if (l1 == 0 && l2 !== 0){
          ans.push(nums_2.shift())
      } else if (l2 == 0 && l1 !== 0) {
          ans.push(nums_1.shift())
      }
        times ++
    }
  if (flag == 1) {
      return ans.pop()
  } else {
      return (ans.pop() + ans.pop())/2
  }
};

结果

资源下载
资源下载