/*
Given an unsorted array, sort it in wave form. That is, reorder it such that nums[0] <= nums[1] >= nums[2] <= nums[3]....

Input format
There are 2 lines of input.

First line contains an integer N ,the number of input integers in the array.

Second line contains N space separated integers.

Output format
N space separated elements which satisfy the given condition.

Sample Input 1
6

1 5 1 1 6 4

Sample Output 1
1 4 1 5 1 6

Explanation 1
nums[0] <= nums[1] >= nums[2] <= nums[3] >= nums[4] <= nums[5].

Constraints
1 <= N <= 100000

-10^9 <= A[i] <= 10^9
*/

/**
 * @param {number[]} arr
 * @param {number} n
 * @return {number[]}
 */
  /*
    1 5 1 1 6 4

    Sample Output 1
    1 4 1 5 1 6

    Explanation 1
    nums[0] <= nums[1] >= nums[2] <= nums[3] >= nums[4] <= nums[5].

    1. sort array
    2. split  into lefthalf and righthalf
    3. insert as pair from lefthalf and righthalf
    arr.sort()=1 1 1 , 4 5 6

    leftarray = 1 1 1 -> i=0 , len1=(n+1)/2;
    rightarray = 4 5 6 -> j=0; , len2=(n-len1);
    */
function wiggleSort(arr, n) {
    arr.sort((a,b)=>a-b);
    // console.log(arr);
    let leftArrayLength = Math.floor((n+1)/2);
    let waveArray= [];
    let i=leftArrayLength-1;
    let j=n-1;
    while (i >=0 && j >= leftArrayLength) {
      waveArray.push(arr[i]);
      i--;
      waveArray.push(arr[j]);
      j--;
    }
    // console.log(waveArray);
    while(i>=0){
        waveArray.push(arr[i]);
        i--;
    }

    while(j>=leftArrayLength){
        waveArray.push(arr[j]);
        j--;
    }
    return waveArray;

}

/*
Certainly, I'll explain why using default string sorting can lead to incorrect results for numbers, especially when there are multiple digits involved.

When you use the default sorting behavior (`arr.sort()` without a custom comparison function), JavaScript treats the elements in the array as strings and sorts them lexicographically (like words in a dictionary) rather than numerically. Here's an example to illustrate the issue:

Suppose you have the following array of numbers:

Input Array: `[10, 2, 25, 3, 11]`

When sorted using the default string sorting:

1. `10` comes before `2` because `'10'` is lexicographically smaller than `'2'`.
2. `2` comes before `25` because `'2'` is lexicographically smaller than `'25'`.
3. `25` comes before `3` because `'25'` is lexicographically smaller than `'3'`.
4. `3` comes before `11` because `'3'` is lexicographically smaller than `'11'`.

So, the result of default string sorting is: `[10, 11, 2, 25, 3]`.

As you can see, the sorted result is not numerically correct. The numbers are sorted based on their string representations, leading to unexpected results.

To correctly sort the numbers, especially when you want numeric sorting, you should use a custom comparison function like `arr.sort((a, b) => a - b)` to ensure that the elements are sorted based on their numerical values. With this custom comparison function, the sorting algorithm understands that you want to compare numbers, and it arranges them accordingly:

Sorted result with custom numeric sorting: `[2, 3, 10, 11, 25]`

In summary, using default string sorting can lead to incorrect results for numbers because it doesn't consider their numerical values but treats them as strings. To achieve correct numeric sorting, it's essential to use a custom comparison function that explicitly instructs the sorting algorithm to compare the elements numerically.
*/

function main() {
    const n = parseInt(readLine(), 10);
    let arr = readIntArr()
    const result = wiggleSort(arr, n)
    console.log(result.join(" "))

}