C++ (Cpp) Solution::findMedianSortedArrays Examples

Example #1

File: MedianOfTwoSortedArrays.cpp Project: hujingqiu/LeetCode

int main() {
    Solution test;
    vector<int> nums1;
    vector<int> nums2;
    for(int i = 1; i <= 9; i += 2) {
        nums1.push_back(i);
        nums2.push_back(i + 1);
    }
    double ans1 = test.findMedianSortedArrays(nums1, nums2);
    cout << ans1 << endl;

    vector<int> nums3;
    vector<int> nums4;
    nums3.push_back(2);
    double ans2 = test.findMedianSortedArrays(nums3, nums4);
    cout << ans2 << endl;

    vector<int> nums5;
    vector<int> nums6;
    nums5.push_back(1);
    nums5.push_back(2);
    nums6.push_back(1);
    nums6.push_back(2);
    double ans3 = test.findMedianSortedArrays(nums5, nums6);
    cout << ans3 << endl;

    return 0;
}

Example #2

File: main.cpp Project: Baternest/FirstGit

int main()
{
	vector<int> nums1 = { 1, 3 };
	vector<int> nums2 = { 2 };
	Solution solution;
	double a = solution.findMedianSortedArrays(nums1, nums2);

	nums1 = { 1, 2 };
	nums2 = { 3, 4 };
	double b = solution.findMedianSortedArrays(nums1, nums2);

	std::cout << "Hello World!\n";
}

Example #3

File: Median_of_two_sorted_array.cpp Project: Lin53/playground

int main(int argc, char *argv[]) {
	int arr[] = {1,2,3,4,5,6};
	int brr[] = {7,8};
	int la = sizeof(arr) / sizeof(int);
	int lb = sizeof(brr) / sizeof(int);
	Solution sol = Solution();
	double res;
	res = sol.findMedianSortedArrays(arr, la, brr, lb);
	cout<< res<< endl;
	res = sol.findMedianSortedArrays(brr, lb, arr, la);
	cout << res << endl;

}

Example #4

File: [LeetCode]Median of Two Sorted Arrays.cpp Project: Callmedoby/ACM_LeetCode

int main(void){
	Solution answer;
	int a[] = { 1, 2, 3, 4 }, b[] = { 3, 4, 5, 6 };
	cout << answer.findMedianSortedArrays(a, 4, b, 4) << endl;
	system("Pause");
	return 0;
}

Example #5

File: 004.cpp Project: jyh890312/leetcode

int main() {
	vector<int> nums1 = {};
	vector<int> nums2 = { 2, 3 };
	Solution sln;
	sln.findMedianSortedArrays(nums1, nums2);
	return 0;
}

Example #6

File: median_of_two_sorted_arrays.cpp Project: lanlingcloud/leetcode

int main() {
	vector<int> nums1 = {1, 3};
	vector<int> nums2 = {2};
	Solution s;
	cout << s.findMedianSortedArrays(nums1, nums2) << endl;
	return 0;
}

Example #7

File: 4.cpp Project: zephyrzoom/leetcode

int main() {
    Solution s;
    vector<int> nums1 = { 1, 5, 6, 7 };
    vector<int> nums2 = { 2, 3, 4 };
    double r = s.findMedianSortedArrays(nums1, nums2);
    return 0;
}

Example #8

File: median-of-two-sorted-arrays.cpp Project: sydchen/leetcode

int main(int argc, const char* argv[])
{
    vector<int> a = { 10, 11 };
    vector<int> b = { 3, 7, 8, 9, 12 };
    Solution s;
    cout << s.findMedianSortedArrays(a, b);
}

Example #9

File: 004_Median of Two Sorted Arrays.cpp Project: cahhbwy/leetcode

int main(int argc, char** argv) {
	Solution solution;
	vector<int> nums1 = { 1, 4 };
	vector<int> nums2 = { 2, 3, 5, 6, 7, 8 };
	cout << solution.findMedianSortedArrays(nums1, nums2) << endl;
	return 0;
}

Example #10

File: test.cpp Project: hex108/leetcode

int main()
{
    Solution solution;
    
    //Test cases
    {
        int A[] = {1, 8, 10, 15, 20};
        int B[] = {2, 8, 11, 12, 23, 24}; 
        cout << solution.findMedianSortedArrays(A, sizeof(A) / sizeof(A[0]), B, sizeof(B) / sizeof(B[0])) << endl;
    }
	
    {
        int A[] = {1, 8, 10, 15, 20, 21};
        int B[] = {2, 8, 11, 12, 23, 24}; 
        cout << solution.findMedianSortedArrays(A, sizeof(A) / sizeof(A[0]), B, sizeof(B) / sizeof(B[0])) << endl;
    }

    {
        int A[] = {1, 8};
        int B[] = {2, 8, 11, 12, 23, 24}; 
        cout << solution.findMedianSortedArrays(A, sizeof(A) / sizeof(A[0]), B, sizeof(B) / sizeof(B[0])) << endl;
    }

    {
        int A[] = {1};
        int B[] = {2, 8, 11, 12, 23, 24}; 
        cout << solution.findMedianSortedArrays(A, sizeof(A) / sizeof(A[0]), B, sizeof(B) / sizeof(B[0])) << endl;
    }

    //Error test cases from leetcode.com
    {
        int A[] = {1, 2, 3};
        int B[] = {1, 2}; 
        cout << solution.findMedianSortedArrays(A, sizeof(A) / sizeof(A[0]), B, sizeof(B) / sizeof(B[0])) << endl;
    }

    {
        int A[] = {1, 2, 2};
        int B[] = {1, 2, 3}; 
        cout << solution.findMedianSortedArrays(A, sizeof(A) / sizeof(A[0]), B, sizeof(B) / sizeof(B[0])) << endl;
    }

    {
        int A[] = {2};
        int B[] = {1, 3, 4}; 
        cout << solution.findMedianSortedArrays(A, sizeof(A) / sizeof(A[0]), B, sizeof(B) / sizeof(B[0])) << endl;
    }

    {
        int A[] = {1, 2, 5, 6};
        int B[] = {3, 4, 7, 8, 9, 10}; 
        cout << solution.findMedianSortedArrays(A, sizeof(A) / sizeof(A[0]), B, sizeof(B) / sizeof(B[0])) << endl;
    }

	
	return 0;
}

Example #11

File: median-of-two-sorted-arrays.cpp Project: Codefor/leetcode

int main(){
    int arr[] = {1};
    int arr2[] = {6};

    Solution s;
    cout<<s.findMedianSortedArrays(arr,1,arr2,1)<<endl;
    return 0;
}

Example #12

File: MedianOfTwoSortedArray.cpp Project: ranshiwei/Leetcode

int main(int argc,char *argv[])
{
	Solution so;
	int A[] = {};
	int B[] = {};
	double result = so.findMedianSortedArrays(A,0,B,0);
	cout<<result;
}

Example #13

File: median_of_two_sorted_arrays.cpp Project: blizzaaard/lc2015

int main()
{
    int A[] = { 0 };
    int B[] = { 1 };
    Solution s;
    std::cout << s.findMedianSortedArrays(A, 0, B, 1) << std::endl;
    return 0;
}

Example #14

File: MedianSortedArray.cpp Project: cat715/LeetCode

int main() {
	int A[2]={1,2};
	int B[2] = {1, 2};
	Solution s;
	cout << s.findMedianSortedArrays(A, 2, B, 2);
	system("pause");
	return 0;
}

Example #15

File: MedianOfTwoSortedArrays.cpp Project: sheepjian/algo_house

int main(int argc, char** argv) {
	Solution sol;

	int A[] = {1,2,3,4,5};
	int B[] = {3,4,5,6,7};
	cout<<sol.findMedianSortedArrays(A,5,B,5)<<endl;

	return 0;
}

Example #16

File: median_two_array_test.cpp Project: pkuashi/Leetcode

TEST(median_two_array, HappyPath_Even_SingleElement)
{
    Solution solution;
    int A[]{1};
    int B[]{1};
    double median = solution.findMedianSortedArrays(A, 1, B, 1);

    ASSERT_EQ(1, median);
}

Example #17

File: median_two_array_test.cpp Project: pkuashi/Leetcode

TEST(median_two_array, HappyPath_Even_DoubleElement)
{
    Solution solution;
    int A[]{1, 2};
    int B[]{1, 2};
    double median = solution.findMedianSortedArrays(A, 2, B, 2);

    ASSERT_EQ(1.5, median);
}

Example #18

File: median_two_array_test.cpp Project: pkuashi/Leetcode

TEST(median_two_array, NoOverlap)
{
    Solution solution;
    int A[]{1, 3, 5, 7, 9};
    int B[]{15, 19, 20, 24};
    double median = solution.findMedianSortedArrays(A, 5, B, 4);

    ASSERT_EQ(9, median);
}

Example #19

File: solution.cpp Project: uestcjerry/leetcode

int main()
{
    Solution obj;
    vector<int> data1 = {1,3,5,7,9,11};
    vector<int> data2 = {2,4,6,8,10,12}; 
    std::cout << obj.findMedianSortedArrays(data1, data2) << std::endl;

    return 0;
}

Example #20

File: median_two_array_test.cpp Project: pkuashi/Leetcode

TEST(median_two_array, HappyPath_Odd_3)
{
    Solution solution;
    int A[]{1};
    int B[]{2, 3, 4, 5};
    double median = solution.findMedianSortedArrays(A, 1, B, 4);

    ASSERT_EQ(3, median);
}

Example #21

File: median_two_array_test.cpp Project: pkuashi/Leetcode

TEST(median_two_array, HappyPath_Even_4)
{
    Solution solution;
    int A[]{4};
    int B[]{1, 2, 3};
    double median = solution.findMedianSortedArrays(A, 1, B, 3);

    ASSERT_EQ(2.5, median);
}

Example #22

File: median_two_array_test.cpp Project: pkuashi/Leetcode

TEST(median_two_array, HappyPath_Even_3)
{
    Solution solution;
    int A[]{1};
    int B[]{2, 3, 4, 5, 6, 7, 8};
    double median = solution.findMedianSortedArrays(A, 1, B, 7);

    ASSERT_EQ(4.5, median);
}

Example #23

File: median_two_array_test.cpp Project: pkuashi/Leetcode

TEST(median_two_array, HappyPath_Even_2)
{
    Solution solution;
    int A[]{1, 2, 3, 7};
    int B[]{4, 5, 6, 8, 9, 10};
    double median = solution.findMedianSortedArrays(A, 4, B, 6);

    ASSERT_EQ(5.5, median);
}

Example #24

File: median_two_array_test.cpp Project: pkuashi/Leetcode

TEST(median_two_array, Meidan_Appear_Multiple_Instances_2)
{
    Solution solution;
    int A[]{1, 1, 3, 3};
    int B[]{1, 1, 3, 3};
    double median = solution.findMedianSortedArrays(A, 4, B, 4);

    ASSERT_EQ(2, median);
}

Example #25

File: median_two_array_test.cpp Project: pkuashi/Leetcode

TEST(median_two_array, TwoSingleElement)
{
    Solution solution;
    int A[]{1};
    int B[]{2};
    double median = solution.findMedianSortedArrays(A, 1, B, 1);

    ASSERT_EQ(1.5, median);
}

Example #26

File: median_two_array_test.cpp Project: pkuashi/Leetcode

TEST(median_two_array, SmallAAndLargeB)
{
    Solution solution;
    int A[]{15};
    int B[]{1, 3, 5, 7, 9, 11, 13, 15, 17, 19};
    double median = solution.findMedianSortedArrays(A, 1, B, 10);

    ASSERT_EQ(11, median);
}

Example #27

File: Median-of-Two-Sorted-Arrays.cpp Project: songqiang/leetcode

int
main(int argn, char** argv)
{
    int A[] = {2};
    int B[] = {1, 3};
    Solution s;

    cout << s.findMedianSortedArrays(A, 1, B, 2) << endl;
}

Example #28

File: medianOfTwoSortedArrays.cpp Project: RobinWeng/leetcood

int main(){
	class Solution {
	public:
   		double findMedianSortedArrays(int A[], int m, int B[], int n) {
			int middle,totle=m+n;
			int *pa=A;
			int *pb=B;
			int cura=0;
			int curb=0;
			int count=0;
			double result;
			vector<int> temp;
			middle=totle/2+1;
			while(cura!=m&&curb!=n&&count<=middle){
				if(*pa<=*pb){
					temp.push_back(*pa);
					++pa;
					++cura;
					++count;
				}
				else{
					temp.push_back(*pb);
					++pb;
					++curb;
					++count;
				}
			}
			if(cura==m&&count<=middle){
				do{
					temp.push_back(*pb);
				++pb;
				++count;
				}while(count<=middle);
			}
			if(curb==n&&count<=middle){
				do{
					temp.push_back(*pa);
				++pa;
				++count;
				}while(count<=middle);
			}
			if(totle%2!=0)
				return temp[totle/2];
			else
				return (temp[totle/2-1]+temp[totle/2])/2.0;     
   		}
	};
	int a[]={2};
	int b[]={};
	int n=1;
	int m=0;
	Solution c;
	double d;
	d=c.findMedianSortedArrays(a,n,b,m);
	cout<<d<<endl;
	cin>>n;
}

Example #29

File: median_two_array_test.cpp Project: pkuashi/Leetcode

TEST(median_two_array, HappyPath_Even)
{
    Solution solution;
    int A[]{1,3,5,9,13};
    int B[]{7,8,15,19,20};
    double median = solution.findMedianSortedArrays(A, 5, B, 5);

    ASSERT_EQ(8.5, median);
}

Example #30

File: median_two_array_test.cpp Project: pkuashi/Leetcode

TEST(median_two_array, EmptyArray2)
{
    Solution solution;

    int B[]{2, 3};
    double median = solution.findMedianSortedArrays(nullptr, 0, B, 2);

    ASSERT_EQ(2.5, median);
}