插入排序以不同顺序对奇偶定位元素进行排序

我们得到了一个数组。我们需要按升序排列偶数位置的元素,按降序排列奇数位置的元素。我们必须申请 插入排序 把它们分类。 例如:

null
Input : a[] = {7, 10, 11, 3, 6, 9, 2, 13, 0}Output :      11  3   7  9  6  10  2  13  0Even positioned elements after sorting int ascending order : 3 9 10 13Odd positioned elements after sorting int descending order : 11 7 6 2 0

我们将插入排序技术分别应用于偶数位置元素和奇数位置元素,但它们位于同一数组中。循环从第0个索引(第1个元素)的奇数位置开始,从第1个索引(第2个元素)的偶数位置开始,并继续增加2,因为每个备用项都是奇数/偶数位置。 现在,我们只需在奇数和偶数位置上应用插入排序过程。奇数元素是[0,2,4,…],偶数元素是[1,3,5,7..]。因此,它们被视为独立的子数组,但在同一个数组中。 奇怪位置的解释: 第0个元素已排序。现在,第二个元素与第0个元素进行比较,然后插入,依此类推(i+2)个元素与之前的元素进行比较,直到数组结束。同样的方法也适用于中的均匀定位元素 阵列。(这与插入排序技术相同)。

C++

// C++ program to sort even positioned elements
// in ascending order and odd positioned
// elements in descending order.
#include<stdio.h>
#include<stdlib.h>
// Function to calculate the given problem.
void evenOddInsertionSort( int arr[], int n)
{
for ( int i = 2; i < n; i++)
{
int j = i-2;
int temp = arr[i];
/* checking whether the position is even
or odd. And after checking applying the
insertion sort to the given
positioned elements.*/
// checking for odd positioned.
if ((i+1) & 1 == 1)
{
// Inserting even positioned elements
// in ascending order.
while (temp >= arr[j] && j >= 0)
{
arr[j+2] = arr[j];
j -= 2;
}
arr[j+2] = temp;
}
// sorting the even positioned.
else {
// Inserting odd positioned elements
// in descending order.
while (temp <= arr[j] && j >= 0)
{
arr[j+2] = arr[j];
j -= 2;
}
arr[j+2] = temp;
}
}
}
// A utility function to print an array of size n
void printArray( int arr[], int n)
{
for ( int i=0; i < n; i++)
printf ( "%d " , arr[i]);
printf ( "" );
}
/* Driver program to test insertion sort */
int main()
{
int arr[] = {12, 11, 13, 5, 6};
int n = sizeof (arr)/ sizeof (arr[0]);
evenOddInsertionSort(arr, n);
printArray(arr, n);
return 0;
}


JAVA

// Java program to sort even positioned elements
// in ascending order and odd positioned
// elements in descending order.
class GFG
{
// Function to calculate the given problem.
static void evenOddInsertionSort( int arr[], int n)
{
for ( int i = 2 ; i < n; i++)
{
int j = i - 2 ;
int temp = arr[i];
/* checking whether the position is even
or odd. And after checking applying the
insertion sort to the given
positioned elements.*/
// checking for odd positioned.
if (((i + 1 ) & 1 ) == 1 )
{
// Inserting even positioned elements
// in ascending order.
while (j >= 0 && temp >= arr[j])
{
arr[j + 2 ] = arr[j];
j -= 2 ;
}
arr[j + 2 ] = temp;
}
// sorting the even positioned.
else
{
// Inserting odd positioned elements
// in descending order.
while (j >= 0 && temp <= arr[j])
{
arr[j + 2 ] = arr[j];
j -= 2 ;
}
arr[j + 2 ] = temp;
}
}
}
// A utility function to print an array of size n
static void printArray( int arr[], int n)
{
for ( int i = 0 ; i < n; i++)
{
System.out.printf( "%d " , arr[i]);
}
System.out.printf( "" );
}
/* Driver program to test insertion sort */
public static void main(String[] args)
{
int arr[] = { 12 , 11 , 13 , 5 , 6 };
int n = arr.length;
evenOddInsertionSort(arr, n);
printArray(arr, n);
}
}
// This code contributed by Rajput-Ji


Python3

# Python3 program to sort even
# positioned elements in ascending
# order and odd positionedelements
# in descending order.
# Function to calculate
# the given problem.
def evenOddInsertionSort(arr, n):
for i in range ( 2 , n):
j = i - 2
temp = arr[i]
# checking whether the position
#  is even or odd. And after
# checking applying the insertion
# sort to the given
# positioned elements.
# checking for odd positioned.
if ((i + 1 ) & 1 = = 1 ) :
# Inserting even positioned elements
# in ascending order.
while (temp > = arr[j] and j > = 0 ):
arr[j + 2 ] = arr[j]
j - = 2
arr[j + 2 ] = temp
# sorting the even positioned.
else :
# Inserting odd positioned elements
# in descending order.
while (temp < = arr[j] and j > = 0 ) :
arr[j + 2 ] = arr[j]
j - = 2
arr[j + 2 ] = temp
# A utility function to print an array of size n
def printArray(arr, n):
for i in range ( 0 , n):
print (arr[i], end = " " )
# Driver program
arr = [ 12 , 11 , 13 , 5 , 6 ]
n = len (arr)
evenOddInsertionSort(arr, n)
printArray(arr, n)
# This code is contributed by
# Smitha Dinesh Semwal


C#

// C# program to sort even positioned elements
// in ascending order and odd positioned
// elements in descending order.
using System;
class GFG
{
// Function to calculate the given problem.
static void evenOddInsertionSort( int []arr, int n)
{
for ( int i = 2; i < n; i++)
{
int j = i - 2;
int temp = arr[i];
/* checking whether the position is even
or odd. And after checking applying the
insertion sort to the given
positioned elements.*/
// checking for odd positioned.
if (((i + 1) & 1) == 1)
{
// Inserting even positioned elements
// in ascending order.
while (j >= 0 && temp >= arr[j])
{
arr[j + 2] = arr[j];
j -= 2;
}
arr[j + 2] = temp;
}
// sorting the even positioned.
else
{
// Inserting odd positioned elements
// in descending order.
while (j >= 0 && temp <= arr[j])
{
arr[j + 2] = arr[j];
j -= 2;
}
arr[j + 2] = temp;
}
}
}
// A utility function to print an array of size n
static void printArray( int []arr, int n)
{
for ( int i = 0; i < n; i++)
{
Console.Write( "{0} " , arr[i]);
}
Console.Write( "" );
}
/* Driver code */
public static void Main(String[] args)
{
int []arr = {12, 11, 13, 5, 6};
int n = arr.Length;
evenOddInsertionSort(arr, n);
printArray(arr, n);
}
}
// This code has been contributed by 29AjayKumar


Javascript

<script>
// JavaScript program to sort even positioned elements
// in ascending order and odd positioned
// elements in descending order.
// Function to calculate the given problem.
function evenOddInsertionSort(arr, n)
{
for (let i = 2; i < n; i++)
{
let j = i - 2;
let temp = arr[i];
/* checking whether the position is even
or odd. And after checking applying the
insertion sort to the given
positioned elements.*/
// checking for odd positioned.
if (((i + 1) & 1) == 1)
{
// Inserting even positioned elements
// in ascending order.
while (j >= 0 && temp >= arr[j])
{
arr[j + 2] = arr[j];
j -= 2;
}
arr[j + 2] = temp;
}
// sorting the even positioned.
else
{
// Inserting odd positioned elements
// in descending order.
while (j >= 0 && temp <= arr[j])
{
arr[j + 2] = arr[j];
j -= 2;
}
arr[j + 2] = temp;
}
}
}
// A utility function to print an array of size n
function printArray(arr, n)
{
for (let i = 0; i < n; i++)
{
document.write(arr[i] + " " );
}
document.write();
}
// Driver code
let arr = [12, 11, 13, 5, 6];
let n = arr.length;
evenOddInsertionSort(arr, n);
printArray(arr, n);
</script>


输出:

13 5 12 11 6 

时间复杂性: O(n) 2. )

辅助空间: O(1) 有更好的方法来解决这个问题,而无需插入排序。请参考 按递增顺序排列偶数元素,按递减顺序排列奇数元素 详细信息。

© 版权声明
THE END
喜欢就支持一下吧
点赞15 分享