Table of contents
1.
Introduction
2.
Approach-1
2.1.
Algorithm
2.2.
Implementation 
2.3.
Output
2.4.
Complexity Analysis 
3.
Approach2
3.1.
Algorithm
3.2.
Implementation
3.3.
Output
3.4.
Complexity Analysis 
4.
Frequently asked questions
4.1.
What is an array?
4.2.
How can we access an element in an array?
4.3.
What is recursion?
5.
Conclusion
Last Updated: Feb 13, 2025

C program to merge two sorted array in descending order

Author dhananjay
0 upvote
Career growth poll
Do you think IIT Guwahati certified course can help you in your career?

Introduction

We are going to know how we can merge the two sorted arrays given to us and sort the merged array but in descending order. Let's assume we have array1 with n number of elements and array 2 with m number of elements in it. Our desired output is to have an array 3 with n+m number of elements of both of the given array, and this array three should be sorted in descending order with efficient time complexity.

 

 

Approach-1

We are going to learn two approaches to how we can handle this problem. In this first approach, we will sort the array in descending order by selecting one element at a time and will iterate over the rest of the elements and start comparing with them until we find an element greater than that and swap the positions of those elements. We will loop over this logic until the array is sorted.

Algorithm

  1. Declare the size of arrays.
  2. Take input of size of arrays.
  3. Initialize array1 and array2.
  4. Copy the elements of the first array to the merged array when initializing it.
  5. Copy the elements of the second array to the merged array while initializing the second array.
  6. Sort the merged array.
  7. Display the array result.
     

Implementation 

#include <stdio.h>
int main() {
  /*Array Size Declaration*/
  int size1, size2, size3;
  printf("\nEnter the size for the first array: ");
  scanf("%d", & size1);
  printf("\nEnter the size for the second array: ");
  scanf("%d", & size2);
  
  size3 = size1 + size2;
  printf("\nEnter the elements in a sorted manner:");
  
  /*Array Declaration*/
  int array1[size1], array2[size2], array3[size3];
  /*Array Initialized*/
  for (int i = 0; i < size1; i++) {
    scanf("%d", & array1[i]);
    array3[i] = array1[i];
  }
  int k = size1;
  printf("\nEnter the elements in a sorted manner:");
  /*Array Initialized*/
  for (int i = 0; i < size2; i++) {
    scanf("%d", & array2[i]);
    array3[k] = array2[i];
    k++;
  }
  printf("\nmerged array of first and second:\n");
  for (int i = 0; i < size3; i++)
    /*Printing the merged array*/
    printf("%d ", array3[i]);

  printf("\nsorted array in descending order\n");
  /*Sorting Array*/
  for (int i = 0; i < size3; i++) {
    int temp;
    for (int j = i + 1; j < size3; j++) {
      if (array3[i] < array3[j]) {
        temp = array3[i];
        array3[i] = array3[j];
        array3[j] = temp;
      }
    }
  }
  /*Printing the sorted Array*/
  for (int i = 0; i < size3; i++) {
    printf(" %d ", array3[i]);
  }
  return 0;
}
You can also try this code with Online C Compiler
Run Code

Output

Complexity Analysis 

Time complexity: O((n+m)2), where n and m are the sizes of the first and second array respectively. 

Space complexity: O(n+m)

Approach2

This approach might be a little complicated if you are new to the programming because  recursion logic is used in this approach. In this method we have used merge sort with recursion to sort the array. 

Merge sort is a divide and conquer algorithm which divides the array into subarrays until we have only 1 element in subarrays and recursively merge and sort the subarrays into a complete sorted array.

This approach sorts the array in O(nlogn) complexity thats why this approach is good in solving the array when we have large data,

Algorithm

  1. Declare the size of arrays.
  2. Take input of size of arrays.
  3. Declare the arrays.
  4. Initialize array1 and array2.
  5. Copy the elements of the first array to the merged array when initializing it.
  6. Copy the elements of the second array to the merged array while initializing the second array.
  7. Call the mergesort function to divide the array into subarrays by finding the middle element using m = l +(r-l)/2 where l = index of first element of array and r = index of last element of array.
  8. After dividing the array into subarray, recursively merge and sort the array into descending order using merge function.
  9. Print the sorted array on the screen

Implementation

#include<stdlib.h>
#include<stdio.h>
 // Merge Function
void merge(int arr[], int l, int m, int r) {
  int i, j, k;
  int n1 = m - l + 1;
  int n2 = r - m;
  int L[n1], R[n2];
  for (i = 0; i < n1; i++)
    L[i] = arr[l + i];
  for (j = 0; j < n2; j++)
    R[j] = arr[m + 1 + j];
  i = 0;
  j = 0;
  k = l;
  while (i < n1 && j < n2) {
    if (L[i] >= R[j]) {
      arr[k] = L[i];
      i++;
    } else {
      arr[k] = R[j];
      j++;
    }
    k++;
  }
  while (i < n1) {
    arr[k] = L[i];
    i++;
    k++;
  }
  while (j < n2) {
    arr[k] = R[j];
    j++;
    k++;
  }
}


void mergeSort(int arr[], int l, int r) {
  if (l < r) {
    int m = l + (r - l) / 2;
    mergeSort(arr, l, m);
    mergeSort(arr, m + 1, r);
    merge(arr, l, m, r);
  }
}


void printArray(int A[], int size) {
  int i;
  for (i = 0; i < size; i++)
    printf("%d ", A[i]);
}


int main() {
  /*Array Size Declaration*/
  int size1, size2, size3;
  printf("\nEnter the size for the first array: ");
  scanf("%d", & size1);
  printf("\nEnter the size for the second array: ");
  scanf("%d", & size2);


  size3 = size1 + size2;
  printf("\nEnter the elements in a sorted manner:");
  /*Array Declaration*/
  int array1[size1], array2[size2], array3[size3];
  /*Array Initialized*/
  for (int i = 0; i < size1; i++) {
    scanf("%d", & array1[i]);
    array3[i] = array1[i];
  }
  int k = size1;
  printf("\nEnter the elements in a sorted manner:");
  /*Array Initialized*/
  for (int i = 0; i < size2; i++) {
    scanf("%d", & array2[i]);
    array3[k] = array2[i];
    k++;
  }
  printf("Given array is \n");
  printArray(array3, size3);
  mergeSort(array3, 0, size3 - 1);
  printf("\nSorted array is \n");
  printArray(array3, size3);
  return 0;
}
You can also try this code with Online C Compiler
Run Code

Output

Complexity Analysis 

Time complexity: O(nlogn) here n is the size of the merged array that is array3

Space complexity: O(n)

Frequently asked questions

What is an array?

An array is a container that contains collections of elements having the same datatype like int , float,char and double. It stores the elements in a continuous manner.

How can we access an element in an array?

Each element in an array has an unique index through which we can access them and perform some operations.

What is recursion?

Recursion is the process of calling a function by itself, and a recursive function is a function that calls itself. Recursion is a technique for solving various mathematical problems by breaking them down into smaller chunks.

Conclusion

In this article, we learned about how we can merge two sorted arrays and sort the merged array into descending order.

Recommended Problem - Merge K Sorted Arrays

To learn more about c programming, please refer to the following articles.

Recommended Readings:

 

Live masterclass