某个数组,通过交换使所有奇数都在前半所有偶数都在后半,复杂度O(N)。

function swaping3(A, i, j){
    if((i === j) || (i === j + 1)){//  if(i >= j){
        return;
    }
    //debugger;
    if(A[i]%2 === 1){
        if(A[j]%2 === 1){
            swaping3(A, ++i, j);
        }else{
            swaping3(A, ++i, --j);
        }
    }else{
        if(A[j]%2 === 1){
            var temp;
            temp = A[i];
            A[i] = A[j];
            A[j] = temp;
            swaping3(A, ++i, --j);
        }else{
            swaping3(A, i, --j);
        }
    }
//    return A;
}

function ARR(num, max){
    if(arguments.length < 2){
        alert("Not enough parameter ~");
        return;
    }

    var AA = [];
    for(var i = 0; i<num; i++){
        AA.push(    Math.ceil(Math.random() * max)    );
    }

    return AA;

//    var i = 0, j = num - 1;
//    swaping(this.AA, i, j);
//    return("Swap finished ~")
}

var OO = new Object();
OO.A = ARR(30, 100);
swaping3.call(OO, OO.A, 0, 29);

上面是代码,十分简单,下面是执行结果:

OO.A = ARR(30, 100);
[85, 70, 44, 100, 37, 81, 97, 89, 67, 7, 73, 5, 83, 41, 33, 96, 80, 93, 73, 59, 89, 42, 27, 15, 49, 26, 81, 10, 62, 95]
swaping3.call(OO, OO.A, 0, 29);
undefined
OO.A
[85, 95, 81, 49, 37, 81, 97, 89, 67, 7, 73, 5, 83, 41, 33, 15, 27, 93, 73, 59, 89, 42, 80, 96, 100, 26, 44, 10, 62, 70]
OO.A = ARR(50, 10000);
[2124, 5000, 5082, 5998, 7476, 962, 5368, 9555, 3593, 5932, 2321, 8518, 2118, 186, 1496, 5914, 1605, 4569, 162, 7487, 4689, 2445, 3122, 8395, 8659, 2368, 1123, 2680, 673, 5098, 3679, 858, 9779, 50, 6818, 823, 8880, 8461, 1496, 942, 2316, 6356, 4691, 2397, 3756, 9451, 3103, 9179, 3108, 9892]
swaping3.call(OO, OO.A, 0, 49);
undefined
OO.A
[9179, 3103, 9451, 2397, 4691, 8461, 823, 9555, 3593, 9779, 2321, 3679, 673, 1123, 8659, 8395, 1605, 4569, 2445, 7487, 4689, 162, 3122, 5914, 1496, 2368, 186, 2680, 2118, 5098, 8518, 858, 5932, 50, 6818, 5368, 8880, 962, 1496, 942, 2316, 6356, 7476, 5998, 3756, 5082, 5000, 2124, 3108, 9892]

功能正常~复杂度也满足O(N)~

时间: 2024-08-30 10:40:34

某个数组,通过交换使所有奇数都在前半所有偶数都在后半,复杂度O(N)。的相关文章

有这样一个数组A,大小为n,相邻元素差的绝对值都是1。

有这样一个数组A,大小为n,相邻元素差的绝对值都是1.如:A={4,5,6,5,6,7,8,9,10,9}.现在,给定A和目标整数t,请找到t在A中的位置.除了依次遍历,还有更好的方法么? 思路:数组第一个数为array[0], 要找的数为y,设t = abs(y - array[0]).由于每个相邻的数字之差的绝对值为1.故第t个位置之前的数肯定都比y小.因此直接定位到array[t],重新计算t,t = abs(y – array[t]),再重复上述步骤即可.这种算法主要利用了当前位置的数与

24、输入一个整数数组,实现一个函数来调整该数组中数字的顺序,使得所有的奇数位于数组的前半部分,所有的偶数位于位于数组的后半部分,并保证奇数和奇数,偶数和偶数之间的相对位置不变。

输入一个整数数组,实现一个函数来调整该数组中数字的顺序,使得所有的奇数位于数组的前半部分,所有的偶数位于位于数组的后半部分,并保证奇数和奇数,偶数和偶数之间的相对位置不变.  思路:新建一个数组先把原数组中的奇数push进去再把偶数push进去,然后用新数组数据覆盖原数组即可 复杂度O(n),用空间换时间 class Solution { public:     void reOrderArray(vector<int> &array) {         vector<int&

java实现原数组根据下标分隔成两个子数组并且在原数组中交换两个子数组的位置

此类实现:输出一行数组数据,根据输入的下标,以下标位置为结束,将原数组分割成两组子数组.并交换两个子数组的位置,保持子数组中的元素序号不变.如:原数组为7,9,8,5,3,2 以下标3为分割点,分割为子数组一:7,9,8,5.和子数组二:3,2.经过交换算法后的结果应为:3,2,7,9,8,5 有两种交换算法<1>前插法:将子数组3,2另存在一个临时数组中,将原数组7,9,8,5,3,2每一位向后移两个位置  再将子数组3,2插入到移动好元素位置的原数组中.<2>逆置法:将原数组7

不引入新的数组,实现数组元素交换位置函数

近期遇到一道C++的面试题.要求不引入新的数组,实现数组元素交换位置函数,看似挺简单的,却还是花费了我不少时间.这里记录下来.给大家一个简单的思路.题目的具体要求是: 不引入新的数组.实现数组元素交换位置函数:void swap(int a[], int m, int n);比方.设m为3,n为4.a中的数据为:1 2 3 4 5 6 7.函数运行后,a中的数据为:4 5 6 7 1 2 3. 这里的关键是不引入新的数组,并且尽量使用较少的额外变量.我的思路是採用"倒叙追踪法",利用一

数组中的元素为奇数的平均值求出来

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-cn"> <head> <met

js 实现数组元素交换位置

/** * 数组元素交换位置 * @param {array} arr 数组 * @param {number} index1 添加项目的位置 * @param {number} index2 删除项目的位置 * index1和index2分别是两个数组的索引值,即是两个要交换元素位置的索引值,如1,5就是数组中下标为1和5的两个元素交换位置 */function swapArray(arr, index1, index2) {   arr[index1] = arr.splice(index2

练习1:将一个6*6数组的第一行,第六行,主对角线和副对角线上的元素都存1,其他元素都存成-1,不需使用初始化,尽量少使用循环

暂时只想到最简单的两层循环实现,留待后看,慢慢优化: 1 #include <iostream> 2 using namespace std; 3 int main() 4 { 5 int arr[6][6] = {0}; 6 7 for (int i = 0; i < 6; i++) 8 { 9 for (int j = 0; j < 6; j++) 10 { 11 if (i == 0 || i == 5) 12 { 13 arr[i][j] = 1; 14 } 15 else

证明不小于6的偶数都是两个素数之和

所谓哥德巴赫猜想,是指哥德巴赫在教学中发现,每个不小于6的偶数都是两个素数之和.大家都相信这个猜想是正确的,但不能证明. 对于哥德巴赫猜想的验证,算法很简单,其基本思路是:设n为大于等于6的一个偶数,可将其分解为n1和n2两个数,分别检查n1和n2是否为素数,如都是,则在该数得到验证.若n1不是素数,就不必再检查n2是否素数.先从n1=2开始,检验n1和n2(n2=n-n1)是否素数.然后使n1+2再检验n1.n2是否素数……,直到n1=n/2为止. int PrimeNum(int i) //

验证哥德巴赫猜想,每个大于等于4的偶数都可以表示成2个素数之和

验证哥德巴赫猜想,每个大于等于4的偶数都可以表示成2个素数之和. 1 #define _CRT_SECURE_NO_WARNINGS 2 3 #include<stdio.h> 4 #include<stdlib.h> 5 6 int isou(int num)//1代表偶数,0代表奇数 7 { 8 if (num % 2 == 0) 9 { 10 return 1; 11 } 12 else 13 { 14 return 0; 15 } 16 } 17 18 int sushu(