精华内容
下载资源
问答
  • 简单讲解奇偶排序算法及在Java数组中的实现奇偶排序是一个比较有个性的排序,基本思路是奇数列排一趟序,偶数列排一趟序,再奇数排,再偶数排,直到全部有序举例吧,待排数组[6 2 4 1 5 9]第一次比较奇数列,奇数列与它的...

    简单讲解奇偶排序算法及在Java数组中的实现

    奇偶排序是一个比较有个性的排序,基本思路是奇数列排一趟序,偶数列排一趟序,再奇数排,再偶数排,直到全部有序

    举例吧,

    待排数组

    [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和5比

    [2 6 1 4 5 9]

    交换后变成

    [2 1 6 4 5 9]

    第三趟又是奇数列,选择的是2,6,5分别与它们的邻居列比较

    [2 1 6 4 5 9]

    交换后

    [1 2 4 6 5 9]

    第四趟偶数列

    [1 2 4 6 5 9]

    一次交换

    [1 2 4 5 6 9]

    Java实现:

    static void oddEvensort(int[] ary) {

    //奇偶排序

    boolean flag = true;

    while (flag) {

    boolean odd = false, even = false;

    for (int i = 0; i < ary.length - 1; i+=2) {

    if (ary[i] > ary[i + 1]) {

    ary[i] = ary[i + 1] + 0 * (ary[i + 1] = ary[i]);

    odd = true;

    }

    }

    for (int i = 1; i < ary.length - 1; i+=2) {

    if (ary[i] > ary[i + 1]) {

    ary[i] = ary[i + 1] + 0 * (ary[i + 1] = ary[i]);

    even = true;

    }

    }

    flag = odd || even; //若为false,表示不论奇偶序列,一个符合条件的比较都没有

    }

    }

    上面的 flag = odd || even;    有一个为true,表示还在交换, 那么最后只有 都为 false时,flag才为false。

    改写成 flag = odd && even;    有一个为false,则不再整体循环了。跟冒泡排序一样,可以减少最后一次内层循环。

    时间: 2016-04-19

    本例输入为两个任意尺寸的矩阵m * n, n * m,输出为两个矩阵的乘积.计算任意尺寸矩阵相乘时,使用了Strassen算法.程序为自编,经过测试,请放心使用.基本算法是: 1.对于方阵(正方形矩阵),找到最大的l, 使得l = 2 ^ k, k为整数并且l < m.边长为l的方形矩阵则采用Strassen算法,其余部分以及方形矩阵中遗漏的部分用蛮力法. 2.对于非方阵,依照行列相应添加0使其成为方阵. StrassenMethodTest.java package matrixalgorit

    6b5aa0751a6f1e6a9d0b665a02cc1f46.gif

    一. 算法描述     选择排序:比如在一个长度为N的无序数组中,在第一趟遍历N个数据,找出其中最小的数值与第一个元素交换,第二趟遍历剩下的N-1个数据,找出其中最小的数值与第二个元素交换......第N-1趟遍历剩下的2个数据,找出其中最小的数值与第N-1个元素交换,至此选择排序完成. 以下面5个无序的数据为例: 56 12 80 91 20(文中仅细化了第一趟的选择过程) 第1趟:12 56 80 91 20 第2趟:12 20 80 91 56 第3趟:12 20 56 91 80 第4趟

    本文实例讲述了java数据结构与算法之双向循环队列的数组实现方法.分享给大家供大家参考,具体如下: 需要说明的是此算法我并没有测试过,这里给出的相当于伪代码的算法思想,所以只能用来作为参考! package source; public class Deque { private int maxSize; private int left; private int right; private int nItems; private long[] myDeque; //constructor p

    6b5aa0751a6f1e6a9d0b665a02cc1f46.gif

    本文实例讲述了java实现的n*n矩阵求值及求逆矩阵算法.分享给大家供大家参考,具体如下: 先来看看运行结果: java版的写出来了,用的跟c语言相同的算法,然后看看能不能以后加个框做成程序: import java.math.*; import java.util.*; import java.text.*; public class matrix { static int map1[][]=new int [110][110]; static int just[][]=new int [11

    本文实例讲述了java字符串相似度算法.分享给大家供大家参考.具体实现方法如下: 复制代码 代码如下: public class Levenshtein {     private int compare(String str, String target) {         int d[][]; // 矩阵         int n = str.length();         int m = target.length();         int i; // 遍历str的

    6b5aa0751a6f1e6a9d0b665a02cc1f46.gif

    本文实例讲述了Java实现的求逆矩阵算法.分享给大家供大家参考,具体如下: package demo; public class MatrixInverse { public static double Det(double [][]Matrix,int N)//计算n阶行列式(N=n-1) { int T0; int T1; int T2; double Num; int Cha; double [][] B; if(N>0) { Cha=0; B=new double[N][N]; Num=

    一.概述 有序数组中常常用到二分查找,能提高查找的速度.今天,我们用顺序查找和二分查找实现数组的增删改查. 二.有序数组的优缺点 优点:查找速度比无序数组快多了 缺点:插入时要按排序方式把后面的数据进行移动 三.有序数组和无序数组共同优缺点 删除数据时必须把后面的数据向前移动来填补删除项的漏洞 四.代码实现 public class OrderArray { private int nElemes; //记录数组长度 private long[] a; /** * 构造函数里面初始化数组 赋值默

    java 矩阵乘法的mapreduce程序实现 map函数:对于矩阵M中的每个元素m(ij),产生一系列的key-value对 其中k=1,2.....知道矩阵N的总列数;对于矩阵N中的每个元素n(jk),产生一系列的key-value对, 其中i=1,2.......直到i=1,2.......直到矩阵M的总列数. map package com.cb.matrix; import stati

    公平算法,打乱数组 这是前几天面试的时候遇见的一道题目,看到这个题首先想到了洗牌程序: 方法一:洗牌程序原理 在java.util包中的Collections类中的 shuffle方法,现在手工实现以下代码如下: package test.ms; import java.util.Random; public class Redistribute2 { public static void main(String[] args) { //define the array int[] s = {1

    6b5aa0751a6f1e6a9d0b665a02cc1f46.gif

    这篇文章主要介绍了Java如何实现八个常用的排序算法:插入排序.冒泡排序.选择排序.希尔排序 .快速排序.归并排序.堆排序和LST基数排序,分享给大家一起学习. 分类 1)插入排序(直接插入排序.希尔排序) 2)交换排序(冒泡排序.快速排序) 3)选择排序(直接选择排序.堆排序) 4)归并排序 5)分配排序(基数排序) 所需辅助空间最多:归并排序 所需辅助空间最少:堆排序 平均速度最快:快速排序 不稳定:快速排序,希尔排序,堆排序. 先来看看8种排序之间的关系: 1.直接插入排序 (1)基本思想

    复制代码 代码如下: public interface IMatrixMultiple {     public int[][] mmltiple(int[][]a ,int [][]b); } ?public class MatrixMultiple implements IMatrixMultiple { @Override    public int[][] mmltiple(int[][] a, int[][] b) {         int [][] result = new int

    一维数组: int[] a={1,2,3}; for(int i:a) { System.out.print(i+" "); } 输出:1 2 3 二维数组: import java.util.Scanner; public class tet { public static void main(String[] args) { //int[][] b={{1,2,3},{4,5,6}};行 int[][] a=new int[5][];//必须明确行数 for(int i=0;i&l

    本文实例讲述了java实现二维数组转json的方法.分享给大家供大家参考,具体如下: package Tsets; public class erweiTojson { public static void main(String[] args) { String[][] blogList = { {"2008/07/07", "NetBeans New and Cool", "Tim Boudreau"}, {"2008/07/07&

    本文实例讲述了Java二维数组简单定义与使用方法.分享给大家供大家参考,具体如下: Java的二维数组是先创建一个一维数组,然后该数组的元素再引用另外一个一维数组.在使用二维数组的时候,通过两个中括号[]来访问每一层维度的引用,直到访问到最终的数据. public class MultiDimArray{ /** * @param args */ public static void main(String[] args) { int[][] arr = new int[3][]; arr[0]

    Java二维数组 Java 语言中提供的数组是用来存储固定大小的同类型元素. 1.二维数组初始化和声明 数组变量的声明,和创建数组可以用一条语句完成,如下所示: int a[][] = new int[2][3]; int[][] arr = {{1,2,3},{4,5,6},{7,8,9}}; 2.二维数组遍历 //遍历二维数组 public class Traverse_a_two_dimensional_array { public static void main(String[] ar

    php 二维数组快速排序算法的实现代码 二维数组排序算法与一维数组排序算法基本理论都是一样,都是通过比较把小的值放在左变的数组里,大的值放在右边的数组里在分别递归. 实例代码: <?php class Bubble { private function __construct() { } private static function sortt($data) { if (count ( $data ) <= 1) { return $data; } $tem = $data [0]['sco

    本文实例讲述了PHP按指定键值对二维数组进行排序的方法.分享给大家供大家参考,具体如下: 问题: 有数组: 复制代码 代码如下: array(0=>array('id'=>1,'price'=>50),1=>array('id'=>2,'price'=>60)); 要求根据数组的price这个字段进行排序. 实现代码如下: <?php $array[] = array('id'=>1,'price'=>50); $array[] = array('id

    本文实例讲述了php实现搜索一维数组元素并删除二维数组对应元素的方法.分享给大家供大家参考.具体如下: 定义一个一维数组一个二维数组如下 $fruit=array('apple','orange'); $products = array( array('name'=>'apple','price'=>23.4), array('name'=>'orange','price'=>45.3), array('name'=>'biscuit','number'=>5,'pri

    在JavaScript中可以通过内置的 Math.max() 的最大值,但是要从多重数组中取出最大值,还是有一定的难度. 问题描述 假设你有一个数组,而且这个数组中包含了数字的子数组,而我们要做的是从数组中的每个子数组中返回其最大的那个最大数. 基本解决方案 function largestOfFour(arr) { var results = []; // 创建一个results变量来存储 // 创建一个外层循环,遍历外层数组 for (var n = 0; n < arr.length; n

    C++ 二维数组参数传递的实现方法 int a[2][2]={ {4, 6}, {9, 11} }; 我定义了这样一个数组,我想把这个数组作为参数,传递到一个函数中,并要在函数中能引用该二维数组的元素,我该怎么做? 第一种方式是直接传递二维数组,但是必须标明第二维的值,因为如果只是传递a[][],编译器无法分配这样的数组,所以要这样传int a[][3] 第二种方法是传递指针数组方式,即int (*a)[3] 第三种是传递指针方法. 具体实施见代码: 方法1:传递数组,注意第二维必须标明 //二

    展开全文
  • 数组奇偶排序

    数组奇偶排序

    题目描述

    给一个数组进行奇偶排序,奇数在前,偶数在后,原奇数,偶数之间的相对位置不能发生变化O(1)的空间复杂度实现

    思路

    使用插入排序的思想,左侧维护一个奇数区, l e f t left left变量指向奇数区的右边界(包括右边界)

    代码实现

    private static void oddEvenSort(int[] nums) {
        int n = nums.length;
        // 奇数区右边界 (包括)
        int left = -1;
        int i = 0;
        while (i < n) {
            if (nums[i] % 2 == 0) {
                i++;
            } else {
                int p = nums[i];
                for (int j = i - 1; j > left; j--) {
                    nums[j + 1] = nums[j];
                }
                // 奇数区扩大
                nums[++left] = p;
                i++;
            }
        }
    }
    

    由于没有找到合适的oj平台,可以测试这道题,所以使用对数器测试自己写的代码。

    import java.util.Arrays;
    
    public class Main {
        public static void main(String[] args) {
            int testTime = 500;
            int maxSize = 100;
            int maxValue = 100;
            boolean succeed = true;
            for (int i = 0; i < testTime; i++) {
                int[] arr1 = generateRandomArray(maxSize, maxValue);
                int[] arr2 = copyArray(arr1);
                oddEvenSort(arr1);
                comparator(arr2);
                if (!isEqual(arr1, arr2)) {
                    succeed = false;
                    System.out.println("i = " + i);
                    printArray(arr2);
                    break;
                }
            }
            System.out.println(succeed ? "Nice!" : "Fucking fucked!");
    
        }
    
        private static void oddEvenSort(int[] nums) {
            int n = nums.length;
            // 奇数区右边界 (包括)
            int left = -1;
            int i = 0;
            while (i < n) {
                if (nums[i] % 2 == 0) {
                    i++;
                } else {
                    int p = nums[i];
                    for (int j = i - 1; j > left; j--) {
                        nums[j + 1] = nums[j];
                    }
                    // 奇数区扩大
                    nums[++left] = p;
                    i++;
                }
            }
        }
    
        private static void comparator(int[] nums) {
            int n = nums.length;
            int[] res = new int[n];
            int idx = 0;
            for (int i = 0; i < n; i++) {
                if (nums[i] % 2 == 1) {
                    res[idx++] = nums[i];
                }
            }
            for (int i = 0; i < n; i++) {
                if (nums[i] % 2 == 0) {
                    res[idx++] = nums[i];
                }
            }
    
            for (int i = 0; i < n; i++) {
                nums[i] = res[i];
            }
        }
    
        public static int[] generateRandomArray(int maxSize, int maxValue) {
            int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
            for (int i = 0; i < arr.length; i++) {
                arr[i] = (int) (Math.random() * maxValue) + 1;
            }
            return arr;
        }
    
        public static int[] copyArray(int[] arr) {
            if (arr == null) {
                return null;
            }
            int[] res = new int[arr.length];
            for (int i = 0; i < arr.length; i++) {
                res[i] = arr[i];
            }
            return res;
        }
    
        public static boolean isEqual(int[] arr1, int[] arr2) {
            if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
                return false;
            }
            if (arr1 == null && arr2 == null) {
                return true;
            }
            if (arr1.length != arr2.length) {
                return false;
            }
            for (int i = 0; i < arr1.length; i++) {
                if (arr1[i] != arr2[i]) {
                    return false;
                }
            }
            return true;
        }
    
        public static void printArray(int[] arr) {
            if (arr == null) {
                return;
            }
            for (int i = 0; i < arr.length; i++) {
                System.out.print(arr[i] + " ");
            }
            System.out.println();
        }
    
    }
    

    全文完。

    展开全文
  • 题目 思路 //偶数从头排,奇数从尾排 class Solution { public int[] sortArrayByParity(int[] A) { int[] arr=new int[A.length]; int start=0; int end=A.length-1; for(int i=0;...A.l...

    题目
    在这里插入图片描述
    思路

    //偶数从头排,奇数从尾排

    class Solution {
        public int[] sortArrayByParity(int[] A) {
            int[] arr=new int[A.length];
            int start=0;
            int end=A.length-1;
            for(int i=0;i<A.length;i++) {
            	if(A[i]%2==0) {
            		arr[start++]=A[i];
            	}else {
            		arr[end--]=A[i];
            	}
            }
            return arr;
        }
    }
    

    测试结果
    在这里插入图片描述

    展开全文
  • 将一个数组中的偶数放在奇数前面. 解决思路 设置两个指针, 一个指针从前往后遍历找奇数, 另一个指针从后往前遍历找偶数. 进行交换. 当两个指针相遇时, 循环结束. 源代码 class Solution { public int[] sortArray...
    1. 问题描述
      将一个数组中的偶数放在奇数前面.
    2. 解决思路
      设置两个指针, 一个指针从前往后遍历找奇数, 另一个指针从后往前遍历找偶数. 进行交换.
      当两个指针相遇时, 循环结束.
    3. 源代码
    class Solution {
        public int[] sortArrayByParity(int[] A) {
            int i = 0;
            int j = A.length - 1;
            while (i < j) {
                while (i < j && A[i] % 2 ==0) {
                    i++;
                }
                while (i < j && A[j] % 2 != 0) {
                    j--;
                }
                if (i < j) {
                    int temp = A[i];
                    A[i] = A[j];
                    A[j] = temp;
                }
            }
            return A;
        }
    }
    
    展开全文
  • 12.数组奇偶排序

    2019-12-17 15:45:02
    package java2019; //输入一个数组,要求奇数放在最前面,偶数放在最后面,且相对位置不变 public class Demo12 { public static void ReOrderArray(int[] array){ int temp = 0; for(int i=0;i<array....
  • 奇偶排序

    2021-02-25 19:29:57
    在《java高并发程序设计》一书中看到关于一种并行算法排序方法:奇偶排序。结合书上与网上的各项资料,在这里按自己的理解做下梳理。介绍冒泡排序:是串行算法,在每次迭代过程中,对于每个元素可能与前面元素交换,...
  • 00905 按奇偶排序数组题目描述给定一个非负整数数组 A,返回一个数组,在该数组中A 的所有偶数元素之后跟着所有奇数元素。你可以返回满足此条件的任何数组作为答案。示例:输入:[3,1,2,4]输出:[2,4,3,1]输出 [4,2,...
  • 给定一个非负整数数组 A,返回一个数组,在该数组中, A 的所有偶数元素之后跟着所有奇数元素。 你可以返回满足此条件的任何数组作为答案。 示例: 输入:[3,1,2,4] 输出:[2,4,3,1] 输出 [4,2,3,1],[2,4,1,3] 和 ...
  • java实现奇偶排序算法

    千次阅读 2018-09-15 16:30:14
    前面我们讲解了奇偶排序算法,现在我们用java代码来实现下,直接上代码 package ttt; public class OddEvenSort { public static int[] oddEvenSort(int[] theArray) { boolean oddFlag = false; boolean ...
  • 数组进行排序,以便A[i]为奇数时,i也是奇数,当A[i]为偶数时,i也是偶数。 偶数和奇数均按照从小到大的顺序排列 输入格式: 第一行输入一个数N,代表输入的数的个数(N%2==0) 第二行输入N个非负整数 输出格式: ...
  • Integer[] arr={1,5,2,3,9,8}; List list=Stream.of(arr).collect(Collectors.toList());; List s1=(List) list.stream().filter(temp->(int)temp%2!=0).sorted().collect(Collectors.to...
  • 本文实例讲述了java交换排序之奇偶排序实现方法。分享给大家供大家参考。具体如下:奇偶排序,或奇偶换位排序,或砖排序,是一种相对简单的排序算法,最初发明用于有本地互连的并行计算。这是与冒泡排序特点类似的一...
  • 数组进行排序,以便当 A[i] 为奇数时,i 也是奇数;当 A[i] 为偶数时, i 也是偶数。 你可以返回任何满足上述条件的数组作为答案。 示例: 输入:[4,2,5,7] 输出:[4,5,2,7] 解释:[4,7,2,5],[2,5,4,7],[2,7,4,5...
  • 整数奇偶排序

    2021-03-01 06:28:03
    } 编辑于 2020-04-02 18:23:33 回复(0) 3 发现输出的数组具有很好的对称性,哦~ 先用sort排好序,再借用p、q这两个小指针,一个从前往后,一个从后往前重新放数在另一个数组中 #include #include #include using...
  • 算法:奇偶排序

    2019-07-14 16:57:55
    奇偶排序实际上再多处理器的环境中很有用,处理器可以分别同时处理每一个奇数对,然后又同时处理偶数对。因为奇数对是彼此独立的,每一刻都可以用不同的处理器比较和交换。这样可以非常快速的排序 算法步骤 选取...
  • Java实现奇偶数排序

    万次阅读 多人点赞 2019-07-21 21:58:10
    给定一个整数数组,请调整 数组中数的顺序,使得所有奇数位于数组的前半部分,所有偶数位于数组的后半部分。要求时间复杂度为O(n)。 2 解决方案 2.1 一头一尾指针往中间扫描法 package com.liuzhen.array_2; public...
  • 思路: 它的思路是在数组中重复两趟扫描。 第一趟扫描选择所有的数据项对,a[j]和a[j+1],j是奇数(j=1,3,5,……)。 如果它们的关键字的值次序颠倒,就交换它们。...重复进行这样两趟 的排序直到数组全部有序
  • 905.按奇偶排序数组 一、题目 给定一个非负整数数组 A,返回一个数组,在该数组中, A 的所有偶数元素之后跟着所有奇数元素。 你可以返回满足此条件的任何数组作为答案。 示例: 输入:[3,1,2,4] 输出:[2,4,3,1] ...
  • 给定一个非负整数数组 A,返回一个数组,在该数组中, A 的所有偶数元素之后跟着所有奇数元素。 你可以返回满足此条件的任何数组作为答案。 输入:[3,1,2,4] 输出:[2,4,3,1] 输出 [4,2,3,1],[2,4,1,3] 和 [4,2,1...
  • 本文实例讲述了java数据结构与算法之奇偶排序算法。分享给大家供大家参考,具体如下:算法思想:基本思路是奇数列排一趟序,偶数列排一趟序,再奇数排,再偶数排,直到全部有序举例吧,待排数组[6 2 4 1 5 9]第一次比较...
  • 给定一个非负整数数组 A,返回一个数组,在该数组中,A 的所有偶数元素之后跟着所有奇数元素。 你可以返回满足此条件的任何数组作为答案。 示例: 输入:[3,1,2,4] 输出:[2,4,3,1] 输出 [4,2,3,1],[2,4,1,3] 和...
  • 奇偶排序数组

    2019-12-06 19:09:05
    给定一个非负整数数组 A,返回一个数组,在该数组中,A 的所有偶数元素之后跟着所有奇数元素。 输入:[3,1,2,4] 输出:[2,4,3,1] 输出 [4,2,3,1]或[2,4,1,3] 或[4,2,1,3] import java.util.Arrays; import java...
  • 数组进行排序,以便当 A[i] 为奇数时,i 也是奇数;当 A[i] 为偶数时, i 也是偶数。 你可以返回任何满足上述条件的数组作为答案。 示例: 输入:[4,2,5,7] 输出:[4,5,2,7] 解释:[4,7,2,5],[2,5,4,7],[2,7,4,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,816
精华内容 1,126
关键字:

java数组奇偶排序

java 订阅