算法：奇偶排序

最新推荐文章于 2024-03-21 15:13:16 发布
最新推荐文章于 2024-03-21 15:13:16 发布
阅读量3.5k 收藏 13
点赞数 5
分类专栏： 算法与数据结构 文章标签： 算法 排序算法 数据结构
原文链接：https://www.cnblogs.com/huangxincheng/p/3570553.html
版权

奇偶排序实际上在多处理器的环境中很有用，处理器可以分别同时处理每一个奇数对，然后又同时处理偶数对。因为奇数对是彼此独立的，每一刻都可以用不同的处理器比较和交换。这样可以非常快速的排序

算法步骤

  • 选取所有奇数列的元素与其右侧相邻的元素进行比较，将较小的元素排序在前面；
  • 选取所有偶数列的元素与其右侧相邻的元素进行比较，将较小的元素排序在前面；
  • 重复前面两步，直到所有序列有序为止。

举例

例子1：

目标：无序数组----> 从小到大排序

  • 待排序数组： 初始化一个flag = true，表示还需要循环排序
    在这里插入图片描述

因为flag为true，进入循环：

  • 假定已经排序完了：flag = false

  • 比较奇数列，奇数列和它最右边相邻的元素比较：基准轴为6，4，5----》 6和2比较，4和1比较，5和9比较。
    因为发生了交换：表示还没有比较完成，因此flag = true，仍然需要循环
    在这里插入图片描述

  • 比较偶数列，偶数类和它最右边相邻的元素比较：基准轴为6，4，9—》6和1比较，5和5比较，9无需比较
    因为发生了交换，令flag = true，仍然需要循环

在这里插入图片描述

判断是否还需要比较：因为flag = true，表示发生了交换，仍然需要循环，因此进入循环

  • 进入循环之后，就令flag = false，表示已经不需要循环了
  • 进入奇数位比较，奇数列与相邻右侧比较，发生了交换，因此flag = true
    在这里插入图片描述
  • 比较偶数列，偶数类与相邻右侧比较，没有发生交换，什么也不干
    在这里插入图片描述

判断是否还需要循环：因为flag = true，表示上次比较发生了交换，因此进入循环：

  • 进入循环后，令flag = false，期望经过这一次循环之后就不需要循环了
  • 比较奇数列，发现没有发生交换，什么也不干
    在这里插入图片描述
  • 比较偶数类，发现没有发生交换，什么也不干
    在这里插入图片描述

判断是否需要跳出循环：发现flag = false，表示当前数组已经整体有序，因此跳出循环

为什么说奇偶排序是并行算法

从示例中，可看出整个比较交换分为独立的奇阶段或偶阶段。在每个阶段内，所有的比较和交换是没有数据相关性。因此，每一次比较和交换都可独立执行，也就可以并行化了。比如，第一次奇阶段排序中，100个元素可以分为4个CPU执行，第一个排序1-25，第二个排序26-50，第三个排序51-75，第四个排序76-100。

代码实现

java

package com.oceanstar;

import java.util.*;

public class TreeNode {
    // 从最后一个非叶子节点开始调整，调整为一个大根堆
    private static void OddEventSort(int[]arr){
        if (arr == null || arr.length < 2){
            return;
        }
        boolean flag = true; //
        while (flag){
            //先默认已经排序完了
            flag = false;


            //先进行 奇数位 排序
            for (int i = 0; i < arr.length ; i = i + 2){
                //如果 前者 大于 后者，则需要进行交换操作,也要防止边界
                if ((i + 1) < arr.length && arr[i] > arr[i+1]){
                    swap(arr, i, i+1);
                    //说明存在过排序，还没有排序完
                    flag = true;
                }
            }

            //再进行 偶数位 排序
            for (int i = 1; i < arr.length; i = i + 2){
                //如果 前者 大于 后者，则需要进行交换操作，也要防止边界
                if ((i + 1) < arr.length && arr[i] > arr[i+1]){
                    swap(arr, i, i+1);
                    //说明存在过排序，还没有排序完
                    flag = true;
                }
            }
        }
    }


    private static void swap(int []arr, int i, int j){
        int t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }

    public static void main(String[] args) {
        int[] arr = new int[]{23,19,81,79,89,83,17,48,55,26};
        OddEventSort(arr);

        System.out.println(Arrays.toString(arr));
    }
}

golang

package main

import (
	"fmt"
)


func OddEventSort(arr [] int)[]int{
	length := len(arr)
	 if length <= 1 {
		return arr
	}else{
		 flag := true
		 for flag  {
		 	 flag = false
			 for i := 0; i + 1 < length ; i = i + 2 {   //先进行 奇数位 排序.  因为是与右侧相邻的元素比较，所以i + 1 必须小于length
				 if arr[i] > arr[i + 1] {
				 	arr[i], arr[i + 1] = arr[i + 1], arr[i]
				 	flag = true
				 }
			 }

			 for i := 1; i + 1 < length ; i = i + 2 {   //进行 偶数位 排序.  因为是与右侧相邻的元素比较，所以i + 1 必须小于length
				 if arr[i] > arr[i + 1] {
					 arr[i], arr[i + 1] = arr[i + 1], arr[i]
					 flag = true
				 }
			 }
		 }

		 return arr;
	}
}



func main() {
	arr:=[]int {1,9,2,8,3,7,4,6,5,10, -1}
	fmt.Println(OddEventSort(arr))
	fmt.Println(arr)
}

C++

#include <iostream>
#include <list>
#include <vector>
#include <map>


template<typename T>
std::ostream& print(std::ostream &out,T const &val) {
    return (out << val << " ");
}

template<typename T1,typename T2>
std::ostream& print(std::ostream &out,std::pair<T1,T2> const &val) {
    return (out << "{" << val.first << " " << val.second << "} ");
}

template<template<typename,typename...> class TT,typename... Args>
std::ostream& operator<<(std::ostream &out,TT<Args...> const &cont) {
    for(auto&& elem : cont) print(out,elem);
    out << "\n";
    return out;
}


void swap(int & i, int &j){
    int t = i;
    i = j;
    j = t;
}


void OddEventSort(std::vector<int> &vec){
    if(vec.empty() || vec.size() == 1){
        return;
    }
    
    bool flag = true;
    while (flag){
        flag = false;
        for(int i = 0; i  + 1 < vec.size(); i += 2){
            if(vec[i] < vec[i +1]){
                swap(vec[i], vec[i+1]);
                flag = true;
            }

        }

        for(int i = 1; i  + 1 < vec.size(); i += 2){
            if(vec[i] < vec[i +1]){
                swap(vec[i], vec[i+1]);
                flag = true;
            }
        }
    }
}



int main() {
    std::vector<int> vec = {1,9,2,8,3,7,4,6,5,10, -1};
    OddEventSort(vec);
    std::cout << vec;
    return 0;
}

实现过程

#include <iostream>
#include <list>
#include <vector>
#include <map>


template<typename T>
std::ostream& print(std::ostream &out,T const &val) {
    return (out << val << " ");
}

template<typename T1,typename T2>
std::ostream& print(std::ostream &out,std::pair<T1,T2> const &val) {
    return (out << "{" << val.first << " " << val.second << "} ");
}

template<template<typename,typename...> class TT,typename... Args>
std::ostream& operator<<(std::ostream &out,TT<Args...> const &cont) {
    for(auto&& elem : cont) print(out,elem);
    out << "\n";
    return out;
}


void swap(int & i, int &j){
    int t = i;
    i = j;
    j = t;
}


void OddEventSort11(std::vector<int> &vec){
    if(vec.empty() || vec.size() == 1){
        return;
    }

    if(vec[0] < vec[1]){
        swap(vec[0], vec[1]);
    }

    if(vec[2] < vec[3]){
        swap(vec[2], vec[3]);
    }

    if(vec[4] < vec[5]){
        swap(vec[4], vec[5]);
    }

    if(vec[6] < vec[7]){
        swap(vec[6], vec[7]);
    }

    if(vec[8] < vec[9]){
        swap(vec[8], vec[9]);
    }

    // 10
    // -------------------------
    if(vec[1] < vec[2]){
        swap(vec[1], vec[2]);
    }

    if(vec[3] < vec[4]){
        swap(vec[3], vec[4]);
    }

    if(vec[5] < vec[6]){
        swap(vec[5], vec[6]);
    }


    if(vec[7] < vec[8]){
        swap(vec[7], vec[8]);
    }

    if(vec[9] < vec[10]){
        swap(vec[9], vec[10]);
    }
}


void OddEventSort123(std::vector<int> &vec){
    if(vec.empty() || vec.size() == 1){
        return;
    }

    for(int i = 0; i + 1 < vec.size(); i += 2){
        if(vec[i] < vec[i+1]){
            swap(vec[i], vec[i+1]);
        }
    }


    for(int i = 1; i + 1 <  vec.size(); i += 2){
        if(vec[i] < vec[i+1]){
            swap(vec[i], vec[i+1]);
        }
    }

    // 10   // 1+ 1 > 10
    // ---
    if(vec.empty() || vec.size() == 1){
        return;
    }

    if(vec[0] < vec[1]){
        swap(vec[0], vec[1]);
    }

    if(vec[2] < vec[3]){
        swap(vec[2], vec[3]);
    }

    if(vec[4] < vec[5]){
        swap(vec[4], vec[5]);
    }

    if(vec[6] < vec[7]){
        swap(vec[6], vec[7]);
    }

    if(vec[8] < vec[9]){
        swap(vec[8], vec[9]);
    }

    // 10
    // -------------------------
    if(vec[1] < vec[2]){
        swap(vec[1], vec[2]);
    }

    if(vec[3] < vec[4]){
        swap(vec[3], vec[4]);
    }

    if(vec[5] < vec[6]){
        swap(vec[5], vec[6]);
    }


    if(vec[7] < vec[8]){
        swap(vec[7], vec[8]);
    }

    if(vec[9] < vec[10]){
        swap(vec[9], vec[10]);
    }

}

void OddEventSortnnn(std::vector<int> &vec){
    if(vec.empty() || vec.size() == 1){
        return;
    }

    for(int i = 0; i + 1 < vec.size(); i += 2){
        if(vec[i] < vec[i+1]){
            swap(vec[i], vec[i+1]);
        }
    }


    for(int i = 1; i + 1 <  vec.size(); i += 2){
        if(vec[i] < vec[i+1]){
            swap(vec[i], vec[i+1]);
        }
    }

    // 10   // 1+ 1 > 10
    // ---
    for(int i = 0; i + 1 < vec.size(); i += 2){
        if(vec[i] < vec[i+1]){
            swap(vec[i], vec[i+1]);
        }
    }


    for(int i = 1; i + 1 <  vec.size(); i += 2){
        if(vec[i] < vec[i+1]){
            swap(vec[i], vec[i+1]);
        }
    }



    // ----

    for(int i = 0; i + 1 < vec.size(); i += 2){
        if(vec[i] < vec[i+1]){
            swap(vec[i], vec[i+1]);
        }
    }


    for(int i = 1; i + 1 <  vec.size(); i += 2){
        if(vec[i] < vec[i+1]){
            swap(vec[i], vec[i+1]);
        }
    }

}



void OddEventSort1233(std::vector<int> &vec){
    if(vec.empty() || vec.size() == 1){
        return;
    }

    while (true){
        for(int i = 0; i + 1 < vec.size(); i += 2){
            if(vec[i] < vec[i+1]){
                swap(vec[i], vec[i+1]);
            }
        }


        for(int i = 1; i + 1 <  vec.size(); i += 2){
            if(vec[i] < vec[i+1]){
                swap(vec[i], vec[i+1]);
            }
        }
    }
}


void OddEventSort(std::vector<int> &vec){
    if(vec.empty() || vec.size() == 1){
        return;
    }

    bool flag = false;
    while (true){
       // flag = false;
        for(int i = 0; i + 1 < vec.size(); i += 2){
            if(vec[i] < vec[i+1]){
                swap(vec[i], vec[i+1]);
                flag = true;
            }
        }


        for(int i = 1; i + 1 <  vec.size(); i += 2){
            if(vec[i] < vec[i+1]){
                swap(vec[i], vec[i+1]);
                flag = true;
            }
        }


        if(flag == false){
            break;
        }

        flag = false;
    }
}
int main() {
    std::vector<int> vec = {1,9,2,8,3,7,4,6,5,10, -1};
    OddEventSort(vec);
    std::cout << vec;
    return 0;
}

算法复杂度分析

在这里插入图片描述

参考

经典算法题每日演练——第二十二题 奇偶排序
排序算法系列：奇偶排序算法

OceanStar的学习笔记
关注
专栏目录
奇偶排序算法
weixin_34417200的博客
10-08 1892
奇偶排序，或奇偶换位排序，或砖排序，是一种相对简单的排序算法，最初发明用于有本地互连的并行计算。这是与冒泡排序特点类似的一种比较排序。该算法中，通过比较数组中相邻的（奇-偶）位置数字对，如果该奇偶对是错误的顺序（第一个大于第二个），则交换。下一步重复该操作，但针对所有的（偶-奇）位置数字对。如此交替进行下去。 使用奇偶排序法对一列随机数字进行排序的过程 本文地址：http://www.cn...
排序算法之奇偶排序
彼岸
11-23 2625
排序算法之奇偶排序     奇偶排序的基本思想就是先对奇数列进行一趟排序，比较奇数列和其相邻的偶数列的元素，如果逆序则交换。再对偶数列进行一趟排序，比较偶数列和其相邻的奇数列的元素，如果逆序则交换。接着对奇数列进行排序，再对偶数列进行排序，重复进行这样的过程，直到奇数列排序和偶数列排序都没有进行交换操作为止。      例如：待排序序列{6, 2, 4, 1, 5,7}      对奇数列和其相
经典排序算法 - 奇偶排序Odd-even sort
weixin_33980459的博客
11-23 448
经典排序算法 - 奇偶排序Odd-even sort 又一个比较性质的排序,基本思路是奇数列排一趟序,偶数列排一趟序,再奇数排,再偶数排,直到全部有序 举例吧, 待排数组[6 2 4 1 5 9] 第一次比较奇数列,奇数列与它的邻居偶数列比较,如6和2比,4和1比,5和9比 [6 2 4 1 5 9] 交换后变成 [2 6 1 4 5 9]   第二次比较偶数列,即6和1比,5和...
【基础排序】奇偶排序
Life Coding
08-30 1058
奇偶排序，或奇偶换位排序，或砖排序，是一种相对简单的排序算法，最初发明用于有本地互连的并行计算。这是与冒泡排序特点类似的一种比较排序。   该算法中，通过比较数组中相邻的（奇-偶）位置数字对，如果该奇偶对是错误的顺序（第一个大于第二个），则交换。下一步重复该操作，但针对所有的（偶-奇）位置数字对。如此交替进行下去。   在并行计算排序中，每个处理器对应处理一个值，并仅有与左右邻居的本地互连
排序算法系列：奇偶排序算法
weixin_30660027的博客
02-01 1662
概述 　　在上一篇中我们说到了冒泡排序的原理及实现详解。冒泡排序是一种交换排序，本文还是接着上一讲，说说另一种交换排序算法——奇偶排序。 版权说明 本文链接：http://blog.csdn.net/lemon_tree12138/article/details/50605563 – Coding-Naga 　　　　　　　　　　　　　　　　　　 　　　　　　　...
奇偶排序
huashetianzu的专栏
05-31 240
题目：输入一个整数数组，调整数组中数字的顺序，使得所有奇数位于数组的前半部分， 所有偶数位于数组的后半部分。要求时间复杂度为O(n)。 针对这个题目，我们可以维护两个指针，一个指针指向数组的第一个数字，向后移动；一个指针指向最后一个数字，向前移动。分四种情况： 1.如果后一个指针指向奇数而前一个指针指向偶数，则交换两个数；之后，前一个指针继续向后移动，后一个指针继续向前移动； 2.如果后一...
整数奇偶排序（信息学奥赛一本通-T1181）.rar
09-16
其次，为了实现奇偶排序，我们需要了解两种基本的排序算法：插入排序和快速排序。插入排序对于小规模数据或部分有序的数据有很好的表现，而快速排序则适用于大规模数据，平均时间复杂度为O(n log n)。在这个问题中，...
c语言实现奇偶排序算法
01-20
=====第2题：奇偶排序（一）===== 总时间限制:1000ms内存限制:65536kB描述输入十个整数，将十个整数按升序排列输出，并且奇数在前，偶数在后。输入输入十个整数输出按照奇偶排序好的十个整数 代码如下:#include #...
C语言 奇偶排序算法详解及实例代码
01-21
C语言奇偶排序算法 奇偶排序，或奇偶换位排序，或砖排序，是一种相对简单的排序算法，最初发明用于有本地互连的并行计算。这是与冒泡排序特点类似的一种比较排序。该算法中，通过比较数组中相邻的（奇-偶）位置数字...
奇偶排序算法的并行实现
09-09
利用mpi进行奇偶排序的实现，有较好的性能和可扩展性
奇偶排序（Odd-Even Sort）
最新发布
qq_55880505的博客
03-21 684
奇偶排序
奇偶数排序
保持热爱，持续学习
12-22 443
题目：给定一个整数数组，调整数组中数的顺序，使得所有奇数位于数组的前半部分，所有 偶数位于数组的后半部分。 思路一： 使用两个指针，从两边向中间遍历，发现条件不满足，交换 bool IsOddNumber(int data) { return (data&amp;1==1); } void OddEvenSort(int data[],int length) { if(data == NULL...
算法 - 奇偶排序（Odd Even_Sort）
曾铎的博客
06-14 1120
思路：在数组元素和元素个数已经给定的前提下，定义i和j这两个整型值，使用for循环让i从数组开始的数值从前向后进行扫描，让j从数组最后的元素从后向前进行扫描，并且i在扫描的过程中，只要当i所经过的数值对2进行取余不等于零的情况下（此数值是奇数）对i进行累加；j在扫描的过程中，经过的数值对2取余为零的情况下（此数值是偶数）对j进行累加。且扫描的大前提就是i和j是不重合的。首先要明确的问题是：如何在给定数组元素已经存在的前提下对数组进行奇数在前偶数在后排序？
奇偶数排序（调序）
那年聪聪
05-27 1655
奇偶数排序（调序）
奇偶排序算法：顺序表操作与复杂度分析
"奇偶排序算法的实现及分析" 在计算机科学中，奇偶排序是一种特殊的排序算法，它旨在将序列中的奇数移到序列的前半部分，偶数移到后半部分，而保持原有的顺序。这里我们将探讨如何使用C++编程语言实现一个基于顺序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值