Skip to content
Related Articles

Related Articles

Improve Article

Sort an array without changing position of negative numbers

  • Difficulty Level : Medium
  • Last Updated : 31 May, 2021

Given an array arr[] of N integers, the task is to sort the array without changing the position of negative numbers (if any) i.e. the negative numbers need not be sorted.
Examples: 
 

Input: arr[] = {2, -6, -3, 8, 4, 1} 
Output: 1 -6 -3 2 4 8
Input: arr[] = {-2, -6, -3, -8, 4, 1} 
Output: -2 -6 -3 -8 1 4 

Approach: Store all the non-negative elements of the array in another vector and sort this vector. Now, replace all the non-negative values in the original array with these sorted values.
Below is the implementation of the above approach:  

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to sort the array such that
// negative values do not get affected
void sortArray(int a[], int n)
{
 
    // Store all non-negative values
    vector<int> ans;
    for (int i = 0; i < n; i++) {
        if (a[i] >= 0)
            ans.push_back(a[i]);
    }
 
    // Sort non-negative values
    sort(ans.begin(), ans.end());
 
    int j = 0;
    for (int i = 0; i < n; i++) {
 
        // If current element is non-negative then
        // update it such that all the
        // non-negative values are sorted
        if (a[i] >= 0) {
            a[i] = ans[j];
            j++;
        }
    }
 
    // Print the sorted array
    for (int i = 0; i < n; i++)
        cout << a[i] << " ";
}
 
// Driver code
int main()
{
    int arr[] = { 2, -6, -3, 8, 4, 1 };
 
    int n = sizeof(arr) / sizeof(arr[0]);
 
    sortArray(arr, n);
 
    return 0;
}

Java




// Java implementation of the approach
import java.util.*;
 
class GFG
{
 
// Function to sort the array such that
// negative values do not get affected
static void sortArray(int a[], int n)
{
 
    // Store all non-negative values
    Vector<Integer> ans = new Vector<>();
    for (int i = 0; i < n; i++)
    {
        if (a[i] >= 0)
            ans.add(a[i]);
    }
 
    // Sort non-negative values
    Collections.sort(ans);
 
    int j = 0;
    for (int i = 0; i < n; i++)
    {
 
        // If current element is non-negative then
        // update it such that all the
        // non-negative values are sorted
        if (a[i] >= 0)
        {
            a[i] = ans.get(j);
            j++;
        }
    }
 
    // Print the sorted array
    for (int i = 0; i < n; i++)
        System.out.print(a[i] + " ");
}
 
// Driver code
public static void main(String[] args)
{
    int arr[] = { 2, -6, -3, 8, 4, 1 };
 
    int n = arr.length;
 
    sortArray(arr, n);
}
}
 
// This code is contributed by 29AjayKumar

Python3




# Python3 implementation of the approach
 
# Function to sort the array such that
# negative values do not get affected
def sortArray(a, n):
 
    # Store all non-negative values
    ans=[]
    for i in range(n):
        if (a[i] >= 0):
            ans.append(a[i])
 
    # Sort non-negative values
    ans = sorted(ans)
 
    j = 0
    for i in range(n):
 
        # If current element is non-negative then
        # update it such that all the
        # non-negative values are sorted
        if (a[i] >= 0):
            a[i] = ans[j]
            j += 1
 
    # Print the sorted array
    for i in range(n):
        print(a[i],end = " ")
 
 
# Driver code
 
arr = [2, -6, -3, 8, 4, 1]
 
n = len(arr)
 
sortArray(arr, n)
 
# This code is contributed by mohit kumar 29

C#




// C# implementation of above approach
using System.Collections.Generic;
using System;
 
class GFG
{
 
// Function to sort the array such that
// negative values do not get affected
static void sortArray(int []a, int n)
{
 
    // Store all non-negative values
    List<int> ans = new List<int>();
    for (int i = 0; i < n; i++)
    {
        if (a[i] >= 0)
            ans.Add(a[i]);
    }
 
    // Sort non-negative values
    ans.Sort();
 
    int j = 0;
    for (int i = 0; i < n; i++)
    {
 
        // If current element is non-negative then
        // update it such that all the
        // non-negative values are sorted
        if (a[i] >= 0)
        {
            a[i] = ans[j];
            j++;
        }
    }
 
    // Print the sorted array
    for (int i = 0; i < n; i++)
        Console.Write(a[i] + " ");
}
 
// Driver code
public static void Main(String[] args)
{
    int []arr = { 2, -6, -3, 8, 4, 1 };
 
    int n = arr.Length;
 
    sortArray(arr, n);
}
}
 
// This code is contributed by 29AjayKumar

Javascript




<script>
 
// JavaScript implementation of the approach
 
// Function to sort the array such that
// negative values do not get affected
function sortArray(a, n)
{
 
    // Store all non-negative values
    var ans = [];
    for (var i = 0; i < n; i++) {
        if (a[i] >= 0)
            ans.push(a[i]);
    }
 
    // Sort non-negative values
    ans.sort((a,b)=> a-b);
 
    var j = 0;
    for (var i = 0; i < n; i++) {
 
        // If current element is non-negative then
        // update it such that all the
        // non-negative values are sorted
        if (a[i] >= 0) {
            a[i] = ans[j];
            j++;
        }
    }
 
    // Print the sorted array
    for (var i = 0; i < n; i++)
        document.write( a[i] + " ");
}
 
// Driver code
var arr = [2, -6, -3, 8, 4, 1];
var n = arr.length;
sortArray(arr, n);
 
 
</script>
Output: 
1 -6 -3 2 4 8

 

Time Complexity: O(n * log n)

Auxiliary Space: O(n)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :