# Sort a K-Increasing-Decreasing Array

Given a K-increasing-decreasing array arr[], the task is to sort the given array. An array is said to be K-increasing-decreasing if elements repeatedly increase upto a certain index after which they decrease, then again increase, a total of K times. The diagram below shows a 4-increasing-decreasing array.

Example:

Input: arr[] = {57, 131, 493, 294, 221, 339, 418, 458, 442, 190}
Output: 57 131 190 221 294 339 418 442 458 493
Input: arr[] = {1, 2, 3, 4, 3, 2, 1}
Output: 1 1 2 2 3 3 4

Approach: The brute-force approach is to sort the array without taking advantage of the k-increasing-decreasing property. The time complexity of this approach is O(n logn) where n is the length of the array.
If k is significantly smaller than n, a better approach can be found with less time complexity. For example, if k=2, the input array consists of two subarrays, one increasing, the other decreasing. Reversing the second subarray yields two sorted arrays and the result is then merged which can be done in O(n) time. Generalizing, we could first reverse the order of each of the decreasing subarrays. For example, in the above figure, the array could be decomposed into four sorted arrays as {57, 131, 493}, {221, 294}, {339, 418, 458} and {190, 442}. Now the min-heap technique can be used to merge these sorted arrays.
Below is the implementation of the above approach:

## CPP

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// A pair of pairs, first element is going to``// store value, second element index of array``// and third element index in the array``typedef` `pair<``int``, pair<``int``, ``int``> > ppi;` `// This function takes an array of arrays as an``// argument and all arrays are assumed to be``// sorted``// It merges them together and returns the``// final sorted output``vector<``int``> mergeKArrays(vector > arr)``{``    ``vector<``int``> output;` `    ``// Create a min heap with k heap nodes``    ``// Every heap node has first element of an array``    ``priority_queue, greater > pq;` `    ``for` `(``int` `i = 0; i < arr.size(); i++)``        ``pq.push({ arr[i][0], { i, 0 } });` `    ``// Now one by one get the minimum element``    ``// from min heap and replace it with next``    ``// element of its array``    ``while` `(pq.empty() == ``false``) {``        ``ppi curr = pq.top();``        ``pq.pop();` `        ``// i ==> Array Number``        ``// j ==> Index in the array number``        ``int` `i = curr.second.first;``        ``int` `j = curr.second.second;` `        ``output.push_back(curr.first);` `        ``// The next element belongs to same array as``        ``// current``        ``if` `(j + 1 < arr[i].size())``            ``pq.push({ arr[i][j + 1], { i, j + 1 } });``    ``}` `    ``return` `output;``}` `// Function to sort the alternating``// increasing-decreasing array``vector<``int``> SortKIncDec(``const` `vector<``int``>& A)``{``    ``// Decompose the array into a``    ``// set of sorted arrays``    ``vector > sorted_subarrays;``    ``typedef` `enum` `{ INCREASING,``                   ``DECREASING } SubarrayType;``    ``SubarrayType subarray_type = INCREASING;``    ``int` `start_idx = 0;``    ``for` `(``int` `i = 0; i <= A.size(); i++) {` `        ``// If the current subarrays ends here``        ``if` `(i == A.size()``            ``|| (i>0 && A[i - 1] < A[i]``                ``&& subarray_type == DECREASING)``            ``|| (i>0 && A[i - 1] >= A[i]``                ``&& subarray_type == INCREASING)) {` `            ``// If the subarray is increasing``            ``// then add from the start``            ``if` `(subarray_type == INCREASING) {``                ``sorted_subarrays.emplace_back(A.cbegin() + start_idx,``                                              ``A.cbegin() + i);``            ``}` `            ``// If the subarray is decreasing``            ``// then add from the end``            ``else` `{``                ``sorted_subarrays.emplace_back(A.crbegin()``                                                  ``+ A.size() - i,``                                              ``A.crbegin()``                                                  ``+ A.size()``                                                  ``- start_idx);``            ``}``            ``start_idx = i;``            ``subarray_type = (subarray_type == INCREASING``                                 ``? DECREASING``                                 ``: INCREASING);``        ``}``    ``}` `    ``// Merge the k sorted arrays```    ``return` `mergeKArrays(sorted_subarrays);``}` `// Driver code``int` `main()``{``    ``vector<``int``> arr = { 57, 131, 493, 294, 221,``                        ``339, 418, 458, 442, 190 };` `    ``// Get the sorted array``    ``vector<``int``> ans = SortKIncDec(arr);` `    ``// Print the sorted array``    ``for` `(``int` `i = 0; i < ans.size(); i++)``        ``cout << ans[i] << ``" "``;` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.util.*;` `public` `class` `Main {``    ``static` `class` `Pair ``implements` `Comparable {``        ``int` `first, second, third;``        ` `        ``// A pair of pairs, first element is going to``        ``// store value, second element index of array``        ``// and third element index in the array``        ``public` `Pair(``int` `f, ``int` `s, ``int` `t) {``            ``first = f;``            ``second = s;``            ``third = t;``        ``}``        ``public` `int` `compareTo(Pair p) {``            ``return` `Integer.compare(first, p.first);``        ``}``    ``}` `    ` `    ``// This function takes an array of arrays as an``    ``// argument and all arrays are assumed to be``    ``// sorted``    ``// It merges them together and returns the``    ``// final sorted output``    ``static` `List mergeKArrays(List> arr) {``        ``List output = ``new` `ArrayList<>();` `        ``// Create a min heap with k heap nodes``        ``// Every heap node has first element of an array``        ``PriorityQueue pq = ``new` `PriorityQueue<>();` `        ``for` `(``int` `i = ``0``; i < arr.size(); i++) {``            ``pq.add(``new` `Pair(arr.get(i).get(``0``), i, ``0``));``        ``}`   `        ``// Now one by one get the minimum element``        ``// from min heap and replace it with next``        ``// element of its array``        ``while` `(!pq.isEmpty()) {``            ``Pair curr = pq.poll();` `    ` `    ` `            ``// i ==> Array Number``            ``// j ==> Index in the array number``            ``int` `i = curr.second;``            ``int` `j = curr.third;` `            ``output.add(curr.first);` `            ``// The next element belongs to same array as``            ``// current``            ``if` `(j + ``1` `< arr.get(i).size()) {``                ``pq.add(``new` `Pair(arr.get(i).get(j + ``1``), i, j + ``1``));``            ``}``        ``}` `        ``return` `output;``    ``}` `    ``enum` `SubarrayType {``        ``INCREASING, DECREASING``    ``}` `    ``// Function to sort the alternating``    ``// increasing-decreasing array``    ``public` `static` `List SortKIncDec(``final` `List A) {``        ` `        ` `        ``// Decompose the array into a``        ``// set of sorted arrays``        ``List> sorted_subarrays = ``new` `ArrayList<>();``        ``SubarrayType subarray_type = SubarrayType.INCREASING;``        ``int` `start_idx = ``0``;``        ``for` `(``int` `i = ``0``; i <= A.size(); i++) {``            ` `            ``// If the current subarrays ends here``            ``if` `(i == A.size()``                    ``|| (i > ``0` `&& A.get(i - ``1``) < A.get(i)``                            ``&& subarray_type == SubarrayType.DECREASING)``                    ``|| (i > ``0` `&& A.get(i - ``1``) >= A.get(i)``                            ``&& subarray_type == SubarrayType.INCREASING)) {``    ` `                ``// If the subarray is increasing``                ``// then add from the start``                ``if` `(subarray_type == SubarrayType.INCREASING) {``                    ``sorted_subarrays.add(A.subList(start_idx, i));``                    ` `                ``// If the subarray is decreasing``                ``// then add from the end``                ``} ``else` `{``                    ``List subList = ``new` `ArrayList<>(A.subList(start_idx, i));``                    ``Collections.reverse(subList);``                    ``sorted_subarrays.add(subList);``                ``}``                ``start_idx = i;``                ``subarray_type = (subarray_type == SubarrayType.INCREASING``                        ``? SubarrayType.DECREASING : SubarrayType.INCREASING);``            ``}``        ``}` `        ` `        ``// Merge the k sorted arrays```        ``return` `mergeKArrays(sorted_subarrays);``    ``}`  `    ``// Driver code``    ``public` `static` `void` `main(String[] args) {``        ``List arr = Arrays.asList(``57``, ``131``, ``493``, ``294``, ``221``, ``339``, ``418``, ``458``, ``442``, ``190``);` `        ``List ans = SortKIncDec(arr);` `        ``for` `(``int` `i = ``0``; i < ans.size(); i++) {``            ``System.out.print(ans.get(i) + ``" "``);``        ``}``    ``}``}`  `// This code is contributed by Shiv1o43g`

## Python3

 `import` `heapq` `# This function takes an array of arrays as an``# argument and all arrays are assumed to be``# sorted``# It merges them together and returns the``# final sorted output``def` `mergeKArrays(arr):``    ``output ``=` `[]` `    ``# Create a min heap with k heap nodes``    ``# Every heap node has first element of an array``    ``pq ``=` `[]` `    ``for` `i ``in` `range``(``len``(arr)):``        ``heapq.heappush(pq, (arr[i][``0``], i, ``0``))` `    ``# Now one by one get the minimum element``    ``# from min heap and replace it with next``    ``# element of its array``    ``while` `pq:``        ``curr ``=` `heapq.heappop(pq)` `        ``# i ==> Array Number``        ``# j ==> Index in the array number``        ``i, j ``=` `curr[``1``], curr[``2``]` `        ``output.append(curr[``0``])` `        ``# The next element belongs to same array as``        ``# current``        ``if` `j ``+` `1` `< ``len``(arr[i]):``            ``heapq.heappush(pq, (arr[i][j ``+` `1``], i, j ``+` `1``))` `    ``return` `output` `# Function to sort the alternating``# increasing-decreasing array``def` `SortKIncDec(A):``    ``# Decompose the array into a``    ``# set of sorted arrays``    ``sorted_subarrays ``=` `[]``    ``INCREASING, DECREASING ``=` `range``(``2``)``    ``subarray_type ``=` `INCREASING``    ``start_idx ``=` `0``    ``for` `i ``in` `range``(``len``(A) ``+` `1``):` `        ``# If the current subarrays ends here``        ``if` `(i ``=``=` `len``(A)``            ``or` `(i>``0` `and` `A[i ``-` `1``] < A[i]``                ``and` `subarray_type ``=``=` `DECREASING)``            ``or` `(i>``0` `and` `A[i ``-` `1``] >``=` `A[i]``                ``and` `subarray_type ``=``=` `INCREASING)):` `            ``# If the subarray is increasing``            ``# then add from the start``            ``if` `subarray_type ``=``=` `INCREASING:``                ``sorted_subarrays.append(A[start_idx:i])` `            ``# If the subarray is decreasing``            ``# then add from the end``            ``else``:``                ``sorted_subarrays.append(A[i``-``1``:start_idx``-``1``:``-``1``])` `            ``start_idx ``=` `i``            ``subarray_type ``=` `DECREASING ``if` `subarray_type ``=``=` `INCREASING ``else` `INCREASING` `    ``# Merge the k sorted arrays``    ``return` `mergeKArrays(sorted_subarrays)` `# Driver code``arr ``=` `[``57``, ``131``, ``493``, ``294``, ``221``, ``339``, ``418``, ``458``, ``442``, ``190``]` `# Get the sorted array``ans ``=` `SortKIncDec(arr)` `# Print the sorted array``for` `i ``in` `range``(``len``(ans)):``    ``print``(ans[i], end``=``' '``)` `# This code is contributed by Prince Kumar`

## C#

 `using` `System;``using` `System.Collections.Generic;` `class` `Program``{``    ``// A pair of pairs, first element is going to``    ``// store value, second element index of array``    ``// and third element index in the array``    ``class` `Triplet : IComparable``    ``{``        ``public` `int` `Value { ``get``; ``set``; }``        ``public` `Tuple<``int``, ``int``> ArrayIndex { ``get``; ``set``; }` `        ``public` `int` `CompareTo(Triplet other)``        ``{``            ``return` `this``.Value.CompareTo(other.Value);``        ``}``    ``}` `    ``// Enum for subarray types``    ``enum` `SubarrayType``    ``{``        ``INCREASING,``        ``DECREASING``    ``}` `    ``// Merges K sorted arrays into a final sorted output``    ``static` `List<``int``> MergeKArrays(List> arr)``    ``{``        ``var` `output = ``new` `List<``int``>();``        ``var` `pq = ``new` `SortedSet();` `        ``for` `(``int` `i = 0; i < arr.Count; i++)``            ``pq.Add(``new` `Triplet { Value = arr[i][0], ArrayIndex = Tuple.Create(i, 0) });` `        ``while` `(pq.Count > 0)``        ``{``            ``Triplet curr = pq.Min;``            ``pq.Remove(curr);` `            ``int` `i = curr.ArrayIndex.Item1;``            ``int` `j = curr.ArrayIndex.Item2;` `            ``output.Add(curr.Value);` `            ``if` `(j + 1 < arr[i].Count)``                ``pq.Add(``new` `Triplet { Value = arr[i][j + 1], ArrayIndex = Tuple.Create(i, j + 1) });``        ``}` `        ``return` `output;``    ``}` `    ``// Sorts the alternating increasing-decreasing array``    ``static` `List<``int``> SortKIncDec(List<``int``> A)``    ``{``        ``var` `sortedSubarrays = ``new` `List>();``        ``SubarrayType subarrayType = SubarrayType.INCREASING;``        ``int` `startIdx = 0;``        ``for` `(``int` `i = 0; i <= A.Count; i++)``        ``{``            ``if` `(i == A.Count ||``               ``(i > 0 && A[i - 1] < A[i] && subarrayType == SubarrayType.DECREASING) ||``               ``(i > 0 && A[i - 1] >= A[i] && subarrayType == SubarrayType.INCREASING))``            ``{``                ``if` `(subarrayType == SubarrayType.INCREASING)``                ``{``                    ``sortedSubarrays.Add(A.GetRange(startIdx, i - startIdx));``                ``}``                ``else``                ``{``                    ``var` `sub = A.GetRange(startIdx, i - startIdx);``                    ``sub.Reverse();``                    ``sortedSubarrays.Add(sub);``                ``}``                ``startIdx = i;``                ``subarrayType = (subarrayType == SubarrayType.INCREASING ? SubarrayType.DECREASING : SubarrayType.INCREASING);``            ``}``        ``}` `        ``return` `MergeKArrays(sortedSubarrays);``    ``}` `    ``static` `void` `Main(``string``[] args)``    ``{``        ``List<``int``> arr = ``new` `List<``int``> { 57, 131, 493, 294, 221, 339, 418, 458, 442, 190 };` `        ``List<``int``> ans = SortKIncDec(arr);` `        ``foreach` `(``var` `value ``in` `ans)``        ``{``            ``Console.Write(value + ``" "``);``        ``}``    ``}``}`

## Javascript

 `// Javascript implementation of the approach` `// A pair of pairs, first element is going to``// store value, second element index of array``// and third element index in the array``class Pair {``  ``constructor(f, s, t) {``    ``this``.first = f;``    ``this``.second = s;``    ``this``.third = t;``  ``}` `  ``compareTo(p) {``    ``return` `this``.first - p.first;``  ``}``}``class PriorityQueue {``  ``constructor(comparator = (a, b) => a - b) {``    ``this``.heap = [];``    ``this``.comparator = comparator;``  ``}` `  ``size() {``    ``return` `this``.heap.length;``  ``}` `  ``peek() {``    ``return` `this``.heap[0];``  ``}` `  ``push(...values) {``    ``values.forEach(value => {``      ``this``.heap.push(value);``      ``this``.bubbleUp(``this``.heap.length - 1);``    ``});``  ``}` `  ``pop() {``    ``const poppedValue = ``this``.peek();``    ``const bottom = ``this``.size() - 1;``    ``if` `(bottom > 0) {``      ``this``.swap(0, bottom);``    ``}``    ``this``.heap.pop();``    ``this``.bubbleDown(0);``    ``return` `poppedValue;``  ``}` `  ``bubbleUp(index) {``    ``while` `(index > 0) {``      ``const parentIndex = Math.floor((index + 1) / 2) - 1;``      ``if` `(``this``.comparator(``this``.heap[parentIndex], ``this``.heap[index]) <= 0) {``        ``break``;``      ``}``      ``this``.swap(parentIndex, index);``      ``index = parentIndex;``    ``}``  ``}` `  ``bubbleDown(index) {``    ``while` `(``true``) {``      ``const leftChildIndex = 2 * index + 1;``      ``const rightChildIndex = 2 * index + 2;``      ``let smallestChildIndex = index;``      ``if` `(``        ``leftChildIndex < ``this``.size() &&``        ``this``.comparator(``this``.heap[leftChildIndex], ``this``.heap[smallestChildIndex]) <= 0``      ``) {``        ``smallestChildIndex = leftChildIndex;``      ``}``      ``if` `(``        ``rightChildIndex < ``this``.size() &&``        ``this``.comparator(``this``.heap[rightChildIndex], ``this``.heap[smallestChildIndex]) <= 0``      ``) {``        ``smallestChildIndex = rightChildIndex;``      ``}``      ``if` `(smallestChildIndex === index) {``        ``break``;``      ``}``      ``this``.swap(smallestChildIndex, index);``      ``index = smallestChildIndex;``    ``}``  ``}` `  ``swap(index1, index2) {``    ``[``this``.heap[index1], ``this``.heap[index2]] = [``this``.heap[index2], ``this``.heap[index1]];``  ``}``}``// This function takes an array of arrays as an``// argument and all arrays are assumed to be``// sorted``// It merges them together and returns the``// final sorted output``function` `mergeKArrays(arr) {``  ``const output = [];``  ` `  ``// Create a min heap with k heap nodes``  ``// Every heap node has first element of an array``  ``const pq = ``new` `PriorityQueue((a, b) => a.compareTo(b));``  ``for` `(let i = 0; i < arr.length; i++) {``    ``pq.push(``new` `Pair(arr[i][0], i, 0));``  ``}``  ` `  ``// Now one by one get the minimum element``  ``// from min heap and replace it with next``  ``// element of its array``  ``while` `(pq.size() > 0) {``    ``const curr = pq.pop();``    ` `    ``// i ==> Array Number``    ``// j ==> Index in the array number``    ``const i = curr.second;``    ``const j = curr.third;``    ``output.push(curr.first);``    ` `    ``// The next element belongs to same array as``    ``// current``    ``if` `(j + 1 < arr[i].length) {``      ``pq.push(``new` `Pair(arr[i][j + 1], i, j + 1));``    ``}``  ``}``  ``return` `output;``}` `const SubarrayType = {``  ``INCREASING: 0,``  ``DECREASING: 1,``};``// Function to sort the alternating``// increasing-decreasing array``function` `SortKIncDec(A) {``    ` `  ``// Decompose the array into a``  ``// set of sorted arrays``  ``const sorted_subarrays = [];``  ``let subarray_type = SubarrayType.INCREASING;``  ``let start_idx = 0;``  ``for` `(let i = 0; i <= A.length; i++) {``    ` `    ``// If the current subarrays ends here``    ``if` `(i === A.length ||(i > 0 && A[i - 1] < A[i] &&``        ``subarray_type === SubarrayType.DECREASING) ||``      ``(i > 0 &&``        ``A[i - 1] >= A[i] &&``        ``subarray_type === SubarrayType.INCREASING)``    ``) {``        ` `      ``// If the subarray is increasing``      ``// then add from the start``      ``if` `(subarray_type === SubarrayType.INCREASING) {``        ``sorted_subarrays.push(A.slice(start_idx, i));``      ``} ``      ` `      ``// If the subarray is decreasing``      ``// then add from the end``      ``else` `{``        ``const subList = A.slice(start_idx, i).reverse();``        ``sorted_subarrays.push(subList);``      ``}``      ``start_idx = i;``      ``subarray_type =``        ``subarray_type === SubarrayType.INCREASING``          ``? SubarrayType.DECREASING``          ``: SubarrayType.INCREASING;``    ``}``  ``}``  ` `  ``// Merge the k sorted arrays```  ``return` `mergeKArrays(sorted_subarrays);``}` `// Driver code``const arr = [57, 131, 493, 294, 221, 339, 418, 458, 442, 190];``const ans = SortKIncDec(arr);``for` `(let i = 0; i < ans.length; i++) {``  ``console.log(ans[i] + ``" "``);``}` `// This code is contributed by Shivhack999`

Output
```57 131 190 221 294 339 418 442 458 493

```

Time Complexity: O(n*logk), where n is the length of array.

Previous
Next