[GeeksForGeeks] Sort an array in wave form

Given an unsorted array of integers, sort the array into a wave like array. An array arr[0...n-1] is sorted in wave form

if arr[0] >= arr[1] <= arr[2] >= arr[3] <= arr[4] >= ....

Solution 1. O(n * logn) runtime, using sorting

1. sort the input array.

2. swap all adjacent elements.

 1 import java.util.Arrays;
 2 public class Solution {
 3     public void sortInWaveForm(int[] nums){
 4         if(nums == null){
 5             return;
 6         }
 7         Arrays.sort(nums);
 8         for(int i = 0; i < nums.length - 1; i += 2){
 9             swap(nums, i, i + 1);
10         }
11     }
12     private void swap(int[] nums, int idx1, int idx2){
13         int temp = nums[idx1];
14         nums[idx1] = nums[idx2];
15         nums[idx2] = temp;
16     }
17     public static void main(String[] args){
18         int[] nums1 = {3, 4, 2, 1, 5};
19         int[] nums2 = {3, 5, 2, 4, 1, 6};
20         Solution sol = new Solution();
21         sol.sortInWaveForm(nums1);
22         for(int i = 0; i < nums1.length; i++){
23             System.out.print(nums1[i] + " ");
24         }
25         System.out.println();
26         sol.sortInWaveForm(nums2);
27         for(int i = 0; i < nums2.length; i++){
28             System.out.print(nums2[i] + " ");
29         }
30     }
31 }

Solution 2. O(n) runtime

Idea:  we only need to make sure that all even positioned elements are >= than their adjacent odd elements. No need to worry about odd positioned elements.

Algorithm:

Traverse all even positioned elements of input array, and do the following.

a. If current element is smaller than previous odd positioned element, swap previous and current.

b. If current element is smaller than next odd positioned element, swap next and current.

 1 public class Solution {
 2     public void sortInWaveForm(int[] nums){
 3         if(nums == null){
 4             return;
 5         }
 6         for(int i = 0; i < nums.length; i += 2){
 7             if(i > 0 && nums[i] < nums[i - 1]){
 8                 swap(nums, i, i - 1);
 9             }
10             if(i < nums.length - 1 && nums[i] < nums[i + 1]){
11                 swap(nums, i, i + 1);
12             }
13         }
14     }
15     private void swap(int[] nums, int idx1, int idx2){
16         int temp = nums[idx1];
17         nums[idx1] = nums[idx2];
18         nums[idx2] = temp;
19     }
20 }