程序在钟摆安排中打印数组

编写程序以在数组中输入整数列表，并以类似于钟摆的往复运动的方式排列它们。

• 整数列表中的最小元素必须位于数组的中心位置。
• 编号从小到大依次排列，在最小号的右边，下一个更大的号在最小号的左边，然后继续。
• 当达到更高的数字时，人像钟摆一样以往复的方式移到一侧。

例子：

Input : 1   3   2   5   4
Output :5   3   1   2   4
Explanation: 
The minimum element is 1, so it is moved to the middle.
The next higher element 2  is moved to the right of the 
middle element while the next higher element 3 is 
moved to the left of the middle element and 
this process is continued.

Input : 11   12   31   14   5
Output :31   12   5   11   14

这个想法是先对数组排序。数组排序后，使用辅助数组一个接一个地存储元素。

C++

// C++ program for pendulum arrangement of numbers
#include 
using namespace std;
 
// Prints pendulam arrangement of arr[]
void pendulumArrangement(int arr[], int n)
{
    // sorting the elements
    sort(arr, arr+n);
 
    // Auxiliary array to store output
    int op[n];
 
    // calculating the middle index
    int mid = (n-1)/2;
 
    // storing the minimum element in the middle
    // i is index for output array and j is for
    // input array.
    int j = 1, i = 1;
    op[mid] = arr[0];
    for (i = 1; i <= mid; i++)
    {
        op[mid+i] = arr[j++];
        op[mid-i] = arr[j++];
    }
 
    // adjustment for when no. of elements is even
    if (n%2 == 0)
        op[mid+i] = arr[j];
 
 
    // Printing the pendulum arrangement
    cout << "Pendulum arrangement:" << endl;
    for (i = 0 ; i < n; i++)
        cout << op[i] << " ";
 
    cout << endl;
}
 
// Driver function
int main()
{
    //input Array
    int arr[] = {14, 6, 19, 21, 12};
 
    // calculating the length of array A
    int n = sizeof(arr)/sizeof(arr[0]);
 
    // calling pendulum function
    pendulumArrangement(arr, n);
 
    return 0;
}

Java

// Java program for pendulum arrangement of numbers
 
import java.util.Arrays;
 
class Test
{
    // Prints pendulum arrangement of arr[]
    static void pendulumArrangement(int arr[], int n)
    {
        // sorting the elements
        Arrays.sort(arr);
      
        // Auxiliary array to store output
        int op[] = new int[n];
      
        // calculating the middle index
        int mid = (n-1)/2;
      
        // storing the minimum element in the middle
        // i is index for output array and j is for
        // input array.
        int j = 1, i = 1;
        op[mid] = arr[0];
        for (i = 1; i <= mid; i++)
        {
            op[mid+i] = arr[j++];
            op[mid-i] = arr[j++];
        }
      
        // adjustment for when no. of elements is even
        if (n%2 == 0)
            op[mid+i] = arr[j];
      
      
        // Printing the pendulum arrangement
        System.out.println("Pendulum arrangement:");
        for (i = 0 ; i < n; i++)
            System.out.print(op[i] + " ");
      
        System.out.println();
    }
     
    // Driver method
    public static void main(String[] args)
    {
        //input Array
        int arr[] = {14, 6, 19, 21, 12};
        
        // calling pendulum function
        pendulumArrangement(arr, arr.length);
    }
}

Python3

# Python 3 program for pendulum
# arrangement of numbers
 
# Prints pendulam arrangement of arr[]
def pendulumArrangement(arr, n):
 
    # sorting the elements
    arr.sort()
 
    # Auxiliary array to store output
    op = [0] * n
 
    # calculating the middle index
    mid = int((n-1)/2)
 
    # storing the minimum
        # element in the middle
    # i is index for output
        # array and j is for
    # input array.
    j = 1
    i = 1
    op[mid] = arr[0]
    for i in range(1,mid+1):
     
        op[mid+i] = arr[j]
        j+=1
        op[mid-i] = arr[j]
        j+=1
     
 
    # adjustment for when no.
        # of elements is even
    if (int(n%2) == 0):
        op[mid+i] = arr[j]
 
 
    # Printing the pendulum arrangement
    print("Pendulum arrangement:")
    for i in range(0,n):
        print(op[i],end=" ")
 
# Driver function
# input Array
arr = [14, 6, 19, 21, 12]
 
# calculating the length of array A
n = len(arr)
 
# calling pendulum function
pendulumArrangement(arr, n)
 
# This code is contributed by
# Smitha Dinesh Semwal

C#

// C# program for pendulum
// arrangement of numbers
using System;
 
class Test {
     
    // Prints pendulum arrangement of arr[]
    static void pendulumArrangement(int []arr,
                                    int n)
    {
         
        // sorting the elements
        Array.Sort(arr);
     
        // Auxiliary array to store output
        int []op = new int[n];
     
        // calculating the middle index
        int mid = (n - 1) / 2;
     
        // storing the minimum element in
        // the middle i is index for output
        // array and j is for input array.
        int j = 1, i = 1;
        op[mid] = arr[0];
        for (i = 1; i <= mid; i++)
        {
            op[mid + i] = arr[j++];
            op[mid - i] = arr[j++];
        }
     
        // adjustment for when no.
        // of elements is even
        if (n % 2 == 0)
            op[mid + i] = arr[j];
     
     
        // Printing the pendulum arrangement
        Console.Write("Pendulum arrangement:");
        for (i = 0 ; i < n; i++)
            Console.Write(op[i] + " ");
     
        Console.WriteLine();
    }
     
    // Driver code
    public static void Main()
    {
         
        //input Array
        int []arr = {14, 6, 19, 21, 12};
         
        // calling pendulum function
        pendulumArrangement(arr, arr.Length);
    }
}
 
// This code is contributed by Nitin Mittal.

Javascript

      // JavaScript program for pendulum
      // arrangement of numbers
 
      // Prints pendulam arrangement of arr[]
      function pendulumArrangement(arr, n)
      {
         
        // sorting the elements
        arr.sort(function (a, b) {
          return a - b;
        });
 
        // Auxiliary array to store output
        var op = [...Array(n)];
 
        // calculating the middle index
        var mid = parseInt((n - 1) / 2);
 
        // storing the minimum element in the middle
        // i is index for output array and j is for
        // input array.
        var j = 1,
          i = 1;
        op[mid] = arr[0];
        for (i = 1; i <= mid; i++) {
          op[mid + i] = arr[j++];
          op[mid - i] = arr[j++];
        }
 
        // adjustment for when no. of elements is even
        if (n % 2 == 0) op[mid + i] = arr[j];
 
        // Printing the pendulum arrangement
        document.write("Pendulum arrangement:<br>");
        for (i = 0; i < n; i++)
        document.write(op[i] + "  ");
 
        document.write("<br>");
      }
 
      // Driver function
       
      //input Array
      var arr = [14, 6, 19, 21, 12];
       
      // calculating the length of array A
      var n = arr.length;
       
      // calling pendulum function
      pendulumArrangement(arr, n);
    

输出：

Pendulum arrangement:
21 14 6 12 19