# Create a Sorted Array Using Binary Search

Given an array, the task is to create a new sorted array in ascending order from the elements of the given array.

Examples:

```Input : arr[] = {2, 5, 4, 9, 8}
Output : 2 4 5 8 9

Input : arr[] = {10, 45, 98, 35, 45}
Output : 10 35 45 45 98
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

The above problem can be solved efficiently using Binary Search. We create a new array and insert the first element if it’s empty. Now for every new element, we find the correct position for the element in the new array using binary search and then insert that element at the corresponding index in the new array.

Below is the implementation of the above approach:

## C++

 `// C++ program to create a sorted array ` `// using Binary Search ` ` `  `#include ` `using` `namespace` `std; ` ` `  `// Function to create a new sorted array ` `// using Binary Search ` `void` `createSorted(``int` `a[], ``int` `n) ` `{ ` `    ``// Auxilary Array ` `    ``vector<``int``> b; ` ` `  `    ``for` `(``int` `j = 0; j < n; j++) { ` `        ``// if b is empty any element can be at ` `        ``// first place ` `        ``if` `(b.empty()) ` `            ``b.push_back(a[j]); ` `        ``else` `{ ` ` `  `            ``// Perform Binary Search to find the correct ` `            ``// position of current element in the ` `            ``// new array ` `            ``int` `start = 0, end = b.size() - 1; ` ` `  `            ``// let the element should be at first index ` `            ``int` `pos = 0; ` ` `  `            ``while` `(start <= end) { ` ` `  `                ``int` `mid = start + (end - start) / 2; ` ` `  `                ``// if a[j] is already present in the new array ` `                ``if` `(b[mid] == a[j]) { ` `                    ``// add a[j] at mid+1. you can add it at mid ` `                    ``b.emplace(b.begin() + max(0, mid + 1), a[j]); ` `                    ``break``; ` `                ``} ` `                ``// if a[j] is lesser than b[mid] go right side ` `                ``else` `if` `(b[mid] > a[j]) ` `                    ``// means pos should be between start and mid-1 ` `                    ``pos = end = mid - 1; ` `                ``else` `                    ``// else pos should be between mid+1 and end ` `                    ``pos = start = mid + 1; ` ` `  `                ``// if a[j] is the largest push it at last ` `                ``if` `(start > end) { ` `                    ``pos = start; ` `                    ``b.emplace(b.begin() + max(0, pos), a[j]); ` ` `  `                    ``// here max(0, pos) is used because sometimes ` `                    ``// pos can be negative as smallest duplicates ` `                    ``// can be present in the array ` `                    ``break``; ` `                ``} ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// Print the new generated sorted array ` `    ``for` `(``int` `i = 0; i < n; i++) ` `        ``cout << b[i] << ``" "``; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``int` `a[] = { 2, 5, 4, 9, 8 }; ` `    ``int` `n = ``sizeof``(a) / ``sizeof``(a); ` ` `  `    ``createSorted(a, n); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program to create a sorted array ` `// using Binary Search ` `import` `java.util.*; ` ` `  `class` `GFG ` `{ ` ` `  `// Function to create a new sorted array ` `// using Binary Search ` `static` `void` `createSorted(``int` `a[], ``int` `n) ` `{ ` `    ``// Auxilary Array ` `    ``Vector b = ``new` `Vector<>(); ` ` `  `    ``for` `(``int` `j = ``0``; j < n; j++) ` `    ``{ ` `        ``// if b is empty any element can be at ` `        ``// first place ` `        ``if` `(b.isEmpty()) ` `            ``b.add(a[j]); ` `        ``else`  `        ``{ ` ` `  `            ``// Perform Binary Search to find the correct ` `            ``// position of current element in the ` `            ``// new array ` `            ``int` `start = ``0``, end = b.size() - ``1``; ` ` `  `            ``// let the element should be at first index ` `            ``int` `pos = ``0``; ` ` `  `            ``while` `(start <= end)  ` `            ``{ ` ` `  `                ``int` `mid = start + (end - start) / ``2``; ` ` `  `                ``// if a[j] is already present in the new array ` `                ``if` `(b.get(mid) == a[j]) ` `                ``{ ` `                    ``// add a[j] at mid+1. you can add it at mid ` `                    ``b.add((Math.max(``0``, mid + ``1``)), a[j]); ` `                    ``break``; ` `                ``} ` `                 `  `                ``// if a[j] is lesser than b[mid] go right side ` `                ``else` `if` `(b.get(mid) > a[j]) ` `                    ``// means pos should be between start and mid-1 ` `                    ``pos = end = mid - ``1``; ` `                ``else` `                    ``// else pos should be between mid+1 and end ` `                    ``pos = start = mid + ``1``; ` ` `  `                ``// if a[j] is the largest push it at last ` `                ``if` `(start > end)  ` `                ``{ ` `                    ``pos = start; ` `                    ``b.add(Math.max(``0``, pos), a[j]); ` ` `  `                    ``// here max(0, pos) is used because sometimes ` `                    ``// pos can be negative as smallest duplicates ` `                    ``// can be present in the array ` `                    ``break``; ` `                ``} ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// Print the new generated sorted array ` `    ``for` `(``int` `i = ``0``; i < n; i++) ` `        ``System.out.print(b.get(i) + ``" "``); ` `} ` ` `  `// Driver Code ` `public` `static` `void` `main(String args[])  ` `{ ` `    ``int` `a[] = { ``2``, ``5``, ``4``, ``9``, ``8` `}; ` `    ``int` `n = a.length; ` ` `  `    ``createSorted(a, n); ` `} ` `} ` ` `  `/* This code is contributed by PrinciRaj1992 */`

## C#

 `// C# program to create a sorted array ` `// using Binary Search ` `using` `System;  ` `using` `System.Collections.Generic;  ` `     `  `class` `GFG ` `{ ` ` `  `// Function to create a new sorted array ` `// using Binary Search ` `static` `void` `createSorted(``int` `[]a, ``int` `n) ` `{ ` `    ``// Auxilary Array ` `    ``List<``int``> b = ``new` `List<``int``>(); ` ` `  `    ``for` `(``int` `j = 0; j < n; j++) ` `    ``{ ` `        ``// if b is empty any element can be at ` `        ``// first place ` `        ``if` `(b.Count == 0) ` `            ``b.Add(a[j]); ` `        ``else` `        ``{ ` ` `  `            ``// Perform Binary Search to find the correct ` `            ``// position of current element in the ` `            ``// new array ` `            ``int` `start = 0, end = b.Count - 1; ` ` `  `            ``// let the element should be at first index ` `            ``int` `pos = 0; ` ` `  `            ``while` `(start <= end)  ` `            ``{ ` ` `  `                ``int` `mid = start + (end - start) / 2; ` ` `  `                ``// if a[j] is already present in the new array ` `                ``if` `(b[mid] == a[j]) ` `                ``{ ` `                    ``// add a[j] at mid+1. you can add it at mid ` `                    ``b.Insert((Math.Max(0, mid + 1)), a[j]); ` `                    ``break``; ` `                ``} ` `                 `  `                ``// if a[j] is lesser than b[mid] go right side ` `                ``else` `if` `(b[mid] > a[j]) ` `                 `  `                    ``// means pos should be between start and mid-1 ` `                    ``pos = end = mid - 1; ` `                ``else` `                 `  `                    ``// else pos should be between mid+1 and end ` `                    ``pos = start = mid + 1; ` ` `  `                ``// if a[j] is the largest push it at last ` `                ``if` `(start > end)  ` `                ``{ ` `                    ``pos = start; ` `                    ``b.Insert(Math.Max(0, pos), a[j]); ` ` `  `                    ``// here Max(0, pos) is used because sometimes ` `                    ``// pos can be negative as smallest duplicates ` `                    ``// can be present in the array ` `                    ``break``; ` `                ``} ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// Print the new generated sorted array ` `    ``for` `(``int` `i = 0; i < n; i++) ` `        ``Console.Write(b[i] + ``" "``); ` `} ` ` `  `// Driver Code ` `public` `static` `void` `Main(String []args)  ` `{ ` `    ``int` `[]a = { 2, 5, 4, 9, 8 }; ` `    ``int` `n = a.Length; ` ` `  `    ``createSorted(a, n); ` `} ` `} ` ` `  `// This code is contributed by 29AjayKumar `

Output:

```2 4 5 8 9
```

Time Complexity: O (N log N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : princiraj1992, 29AjayKumar