最小化使第一个和最后一个元素分别成为数组中最大和最小元素所需的交换

给定一个由N 个整数组成的数组arr[] ，任务是找到使数组中的第一个和最后一个元素分别成为数组中存在的最大和最小元素所需的最小相邻交换次数。

例子：

Input: arr[] = {1, 3, 2}
Output: 2
Explanation:
Initially the array is {1, 3, 2}.
Operation 1: Swap element at index 0 and 1. The array modifies to {3, 1, 2}.
Operation 2: Swap element at index 1 and 2. The array modifies to {3, 2, 1}.
Therefore, the minimum number of operation required is 2.

Input: arr[] = {100, 95, 100, 100, 88}
Output: 0

方法：按照以下步骤解决给定的问题：

• 初始化一个变量，比如count ，以存储所需的交换总数。
• 找到数组的最小和最大元素并将其存储在一个变量中，分别说minElement和maxElement 。
• 如果发现最小和最大元素相同，则数组由单个不同元素组成。因此，打印0因为这两个元素分别位于正确的位置。
• 否则，遍历数组并找到第一次出现的maxElement和最后一次出现的minElement 的索引，并将其存储在一个变量中，分别说minIndex和maxIndex 。
• 将count的值更新为maxIndex和(N – 1 – minIndex)的总和，作为将最大和最小元素分别作为数组的第一个和最后一个元素所需的交换操作数。
• 如果minIndex小于maxIndex ，则将count减少1 ，因为一个交换操作将重叠。
• 完成上述步骤后，打印count的值作为所需的最小交换次数。

下面是上述方法的实现：

C++

// C++ program for the above approach
 
#include 
using namespace std;
 
// Function to find the minimum number
// of swaps required to make the first
// and the last elements the largest
// and smallest element in the array
int minimum_swaps(int arr[], int n)
{
    // Stores the count of swaps
    int count = 0;
 
    // Stores the maximum element
    int max_el = *max_element(arr,
                              arr + n);
 
    // Stores the minimum element
    int min_el = *min_element(arr,
                              arr + n);
 
    // If the array contains
    // a single distinct element
    if (min_el == max_el)
        return 0;
 
    // Stores the indices of the
    // maximum and minimum elements
    int index_max = -1;
    int index_min = -1;
 
    for (int i = 0; i < n; i++) {
 
        // If the first index of the
        // maximum element is found
        if (arr[i] == max_el
            && index_max == -1) {
            index_max = i;
        }
 
        // If current index has
        // the minimum element
        if (arr[i] == min_el) {
            index_min = i;
        }
    }
 
    // Update the count of operations to
    // place largest element at the first
    count += index_max;
 
    // Update the count of operations to
    // place largest element at the last
    count += (n - 1 - index_min);
 
    // If smallest element is present
    // before the largest element initially
    if (index_min < index_max)
        count -= 1;
 
    return count;
}
 
// Driver Code
int main()
{
    int arr[] = { 2, 4, 1, 6, 5 };
    int N = sizeof(arr) / sizeof(arr[0]);
    cout << minimum_swaps(arr, N);
 
    return 0;
}

Java

// Java program for the above approach
import java.util.Arrays;
import java.util.Collections;
 
class GFG{
 
// Function to find the minimum number
// of swaps required to make the first
// and the last elements the largest
// and smallest element in the array
static int minimum_swaps(Integer arr[], int n)
{
     
    // Stores the count of swaps
    int count = 0;
     
    // Stores the maximum element
    int max_el = Collections.max(Arrays.asList(arr));
 
    // Stores the minimum element
    int min_el = Collections.min(Arrays.asList(arr));
 
    // If the array contains
    // a single distinct element
    if (min_el == max_el)
        return 0;
 
    // Stores the indices of the
    // maximum and minimum elements
    int index_max = -1;
    int index_min = -1;
 
    for(int i = 0; i < n; i++)
    {
         
        // If the first index of the
        // maximum element is found
        if (arr[i] == max_el &&
            index_max == -1)
        {
            index_max = i;
        }
 
        // If current index has
        // the minimum element
        if (arr[i] == min_el)
        {
            index_min = i;
        }
    }
 
    // Update the count of operations to
    // place largest element at the first
    count += index_max;
 
    // Update the count of operations to
    // place largest element at the last
    count += (n - 1 - index_min);
 
    // If smallest element is present
    // before the largest element initially
    if (index_min < index_max)
        count -= 1;
 
    return count;
}
 
// Driver Code
public static void main (String[] args)
{
    Integer arr[] = { 2, 4, 1, 6, 5 };
    int N = arr.length;
     
    System.out.println(minimum_swaps(arr, N));
}
}
 
// This code is contributed by AnkThon

Python3

# Python3 program for the above approach
 
# Function to find the minimum number
# of swaps required to make the first
# and the last elements the largest
# and smallest element in the array
def minimum_swaps(arr, n):
     
    # Stores the count of swaps
    count = 0
 
    # Stores the maximum element
    max_el = max(arr)
 
    # Stores the minimum element
    min_el = min(arr)
 
    # If the array contains
    # a single distinct element
    if (min_el == max_el):
        return 0
 
    # Stores the indices of the
    # maximum and minimum elements
    index_max = -1
    index_min = -1
 
    for i in range(n):
         
        # If the first index of the
        # maximum element is found
        if (arr[i] == max_el and
            index_max == -1):
            index_max = i
 
        # If current index has
        # the minimum element
        if (arr[i] == min_el):
            index_min = i
 
    # Update the count of operations to
    # place largest element at the first
    count += index_max
 
    # Update the count of operations to
    # place largest element at the last
    count += (n - 1 - index_min)
 
    # If smallest element is present
    # before the largest element initially
    if (index_min < index_max):
        count -= 1
 
    return count
 
# Driver Code
if __name__ == '__main__':
     
    arr = [2, 4, 1, 6, 5]
    N = len(arr)
     
    print(minimum_swaps(arr, N))
 
# This code is contributed by mohit kumar 29

C#

// C# program for the above approach
using System;
using System.Linq;
 
class GFG{
 
// Function to find the minimum number
// of swaps required to make the first
// and the last elements the largest
// and smallest element in the array
static int minimum_swaps(int[] arr, int n)
{
     
    // Stores the count of swaps
    int count = 0;
 
    // Stores the maximum element
    int max_el = arr.Max();
 
    // Stores the minimum element
    int min_el = arr.Min();
 
    // If the array contains
    // a single distinct element
    if (min_el == max_el)
        return 0;
 
    // Stores the indices of the
    // maximum and minimum elements
    int index_max = -1;
    int index_min = -1;
 
    for(int i = 0; i < n; i++)
    {
         
        // If the first index of the
        // maximum element is found
        if (arr[i] == max_el &&
            index_max == -1)
        {
            index_max = i;
        }
 
        // If current index has
        // the minimum element
        if (arr[i] == min_el)
        {
            index_min = i;
        }
    }
 
    // Update the count of operations to
    // place largest element at the first
    count += index_max;
 
    // Update the count of operations to
    // place largest element at the last
    count += (n - 1 - index_min);
 
    // If smallest element is present
    // before the largest element initially
    if (index_min < index_max)
        count -= 1;
 
    return count;
}
 
// Driver Code
public static void Main(string[] args)
{
    int[] arr = { 2, 4, 1, 6, 5 };
    int N = arr.Length;
 
    Console.WriteLine(minimum_swaps(arr, N));
}
}
 
// This code is contributed by ukasp

Javascript

      // JavaScript program for the above approach
      // Function to find the minimum number
      // of swaps required to make the first
      // and the last elements the largest
      // and smallest element in the array
      function minimum_swaps(arr, n) {
        // Stores the count of swaps
        var count = 0;
 
        // Stores the maximum element
        var max_el = Math.max(...arr);
 
        // Stores the minimum element
        var min_el = Math.min(...arr);
 
        // If the array contains
        // a single distinct element
        if (min_el === max_el) return 0;
 
        // Stores the indices of the
        // maximum and minimum elements
        var index_max = -1;
        var index_min = -1;
 
        for (var i = 0; i < n; i++) {
          // If the first index of the
          // maximum element is found
          if (arr[i] === max_el && index_max === -1) {
            index_max = i;
          }
 
          // If current index has
          // the minimum element
          if (arr[i] === min_el) {
            index_min = i;
          }
        }
 
        // Update the count of operations to
        // place largest element at the first
        count += index_max;
 
        // Update the count of operations to
        // place largest element at the last
        count += n - 1 - index_min;
 
        // If smallest element is present
        // before the largest element initially
        if (index_min < index_max) count -= 1;
 
        return count;
      }
 
      // Driver Code
      var arr = [2, 4, 1, 6, 5];
      var N = arr.length;
 
      document.write(minimum_swaps(arr, N));
    

输出：

4

时间复杂度： O(N)
辅助空间： O(1)

如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live