已知一个长度为2n的数组，int a[]={a1,a2,a3...an,b1,b2,b3...bn};设计算法将a变为{a1,b1,a2,b2,a3,b3...an,bn}。要求： (1)时间复杂度为0(n) (2)空间复杂度为0(1)
该问题被发起重新开启投票
投票剩余时间：
之前被关闭原因：
该问题被发起删除投票
投票剩余时间：
距离悬赏到期还有：
参与关闭投票者：
关闭原因：
该问题已经被锁定
锁定原因：（）
保护原因：避免来自新用户不合宜或无意义的致谢、跟帖答案。
该问题已成功删除，仅对您可见，其他人不能够查看。
这题难度蛮大的，刚才搜索了下，是个完美洗牌问题。
给个链接：/question/index.html#!questionId=278
也学习了！
观察两个数组我们可以看见a1,a2...an中每个元素依次后移了0,1,2，...，n-1;而b1,b2,...bn依次向前移动了n-1,n-2,...0;根据这个规律，我们可以设定一个指针来遍历a1,a2...an,b1,b2,...设置一个计数器和一个temp区域，先开始遍历数组，找到当前数组在修改后数组中应该的位置，对应位置元素存入temp区域，当前值填入指定区域，计数器值增一；如此循环直到计数器的值等于元素的个数；当然这个可能涉及到多次判定移位距离的问题，使得算法比较复杂；不过抛砖引玉，看其他高手有没有什么比较好的方法O(∩_∩)O哈哈~
int main(int argc, char* argv[]){
const int n=20;
int i,pre,//pre保存被替换的值，temp用于交换变量
int d[n]={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19};
i=1;pre=d[1];int count=0;//count记录循环的次数
if(i&n/2){
temp=d[2*i];
temp=d[2*(i-n/2)+1];
d[2*(i-n/2)+1]=
i=2*(i-n/2)+1;
for(i=0;i&20;i++)
cout&&d[i]&&" ";
cout&&endl&&"循环的次数："&&count&&
return 0;}
不知道可不可以？循环次数为18次，小于n(20),无法证明为O(n),不对20,30等可以巧合成功，问题很复杂，大家不要被上面的误导
我是看了给的博客链接然后搞出来的，原理就是每个符合2*m-1=3^j（m，j为任意正整数）的m子串以3的指数幂的下标开始一个个替换，这样便能遍历到所有元素。程序的过程就是找符合上述式子的2m长度的子串，然后在m+1位到m+n位之间循环移位m位，然后从3^0+1位开始以式子i=》（2i-1）mod（2n-1）开始替换，直到循环回来，然后再换3^1+1……直到3^(j-1)+1；然后在剩余的串中继续找符合条件的子串直到全部处理完毕。说得可能有点绕，接下来贴代码了：
#include &IOSTREAM&//递归轮换,start为3^i+1,length为2n.void Swap(int data[],int start,int length){
if(length!=2)//长度为2的数列不需要轮换
int temp_data,temp_data2;
temp_offset=(2*start-1)%(length-1);
if (temp_offset==0)
temp_offset=length-1;
temp_data=data[temp_offset-1];
data[temp_offset-1]=data[start-1];
while (temp_offset!=start)
temp_offset=(2*temp_offset-1)%(length-1);
if (temp_offset==0)
temp_offset=length-1;
temp_data2=data[temp_offset-1];
data[temp_offset-1]=temp_
temp_data=temp_data2;
}}//数组循环移位void Reverse(int data[],int length)//将数组顺序颠倒{
for(i=0;i&length/2;i++)
temp=data[i];
data[i]=data[length-i-1];
data[length-i-1]=
}}void Cyclic_ShiftN(int data[],int length,int n)//将数组循环移N位{
if(length!=1)
Reverse(data,length-n);
Reverse(&data[length-n],n);
Reverse(data,length);
}}//满足length=3^k+1的完美洗牌的实现void Special_Perfect_Shuffle(int data[],int length){
while (i&length-1)
Swap(data,i+1,length);
}}//查找最接近N的3^k+1(N至少为2)int Look_Up(int N){
while(i&=N-1)
return i+1;}void Perfect_Shuffle(int data[],int length){
int i,start_position=0;
while(start_position&length)
i=Look_Up(length-start_position);
Cyclic_ShiftN(&data[start_position+i/2],(length-start_position)/2,i/2);
Special_Perfect_Shuffle(&data[start_position],i);
start_position+=i;
}}#define MAX 100int main(){
int data[MAX]={0};
printf("Please input a number which should be not bigger than 100!\n");
int N,temp1=1;
scanf("%d",&N);
if (N%2!=0)
printf("Sorry,the number should be even not odd!");
for(int i=0;i&N;i++)
data[i]=temp1;
Perfect_Shuffle(data,N);
for(i=0;i&N;i++)
printf("%d\t",data[i]);
return 0;}
其实这个问题就是一个洗牌问题：平时洗牌是两打牌，交叉洗在一起.也就是开始 1 2 3 4 5 6 7 8第一次 1 5 2 6 3 7 4 8第二次 1 3 5 7 2 4 6 8。。。第k次 ...我们这里相当于是只洗一次牌。
解决方案：
首先寻找规律，有如下性质：
1& 最开始和最后的两张牌永远不变。
2& 中间有2N-2张牌，即一张牌最多可能有2N-2种位置，这2N-2张牌一定是全动，即不可能存在两个状态，它们的一部分相同，而另一部分不同。这条性质说明了洗牌会进入循环，并且循环节最大为2N-2。
3& 将除去1以后剩下的2N-1张牌看成是一个循环圈，就是说超出2N-1就从循环圈的开始数，那么，
第一次洗牌，2向后移动1个位置，3向后移动2个位置，……
第二次洗牌，2向后移动2个位置，3向后移动4个位置，……
第k次洗牌，2向后移动2^k - 1个位置，3向后移动2(2^k-1)个位置，4向后移动3(2^k-1)个位置……2N-1向后移动(2N-2)*(2^k-1)个位置。
给你一个数组a[2N]，要求在O(1)的空间复杂度内给a[2N]k次洗牌，代码如下：
#include &stdio.h&
// print a array
void PRline(unsigned int* s, int count)
unsigned int* end = s +
while(s & end) printf("%u\t",*s++);
printf("\n");
// (2^howmany - 1) can be divided by x
unsigned int CalLoop( unsigned int x )
unsigned int val = 2
unsigned int x1 = x + 1u;
unsigned int x2 = x - 1u;
for( unsigned int i = 1; i &= i ++, val&&=1 )
while( val &= x1 ) val -=
if( val == 1u )
if( val == x2 ) return i && 1;
// calc (1&&pow2)%x
unsigned int Mod( unsigned int pow2, unsigned int x )
unsigned int temp = 1u;
while( pow2-- )
if( temp &= x ) temp -=
void WashPoker( unsigned int N, unsigned int k )
unsigned int N2_1 = (N&&1) - 1u;
unsigned int *a = new unsigned int[ N2_1 + 1u ];
unsigned int i, j, spos, pos, temp, temp2;
for( i = 0; i &= N2_1; i++ ) a[i] = i+1u;
temp = CalLoop( N2_1 );
//找到长度为N2_1的循环圈洗多少次牌（temp次）是一个轮回。
if( temp ) k = k - k / temp *
//洗k次牌等效于洗k- k / temp * temp次（减去轮回）。
for( i = 1; i & N2_1; i++ )
if( a[i] == i + 1u )
//如果数组中的index与数组元素相等，代表这个元素还没有被放置到正确的位置，从这个元素开始新一轮的循环。
spos = pos =
temp = a[i];
Mod( k, N2_1 ) * pos % N2_1;
//计算新的应该放的位置[pos+pos*(2^k -1)]%N2_1；
if( pos == spos )
temp2 = a[pos];
temp = temp2;
PRline( a, N&&1 );
delete []a;
int main()
printf("please input Number(N, k): ");
unsigned int N,
scanf("%u %u", &N, &k);
if( N == 0)
WashPoker( N, k );
public class Test {
public static void main(String[] args){
int length = 5;
String a[] = new String[length*2];;
for(int i=1;i&=i++){
a[i-1] = "a"+i;
a[length+i-1] = "b"+i;
Test test = new Test();
test.showMethod(a);
a = test.testMethod(a);
test.showMethod(a);
public void showMethod(String[] list){
for(String str : list){
System.out.print(str+" ");
System.out.println();
public String[] testMethod(String[] list){
String[] result = new String[list.length];
for(int i=1;i&=list.length/2;i++){
result[i*2-2] = list[i-1];
result[i*2-1] = list[list.length/2+i-1];
}}结果：a1 a2 a3 a4 a5 b1 b2 b3 b4 b5 a1 b1 a2 b2 a3 b3 a4 b4 a5 b5
#include "stdio.h"void f1(int *a1,int n){
//从下标1开始
int y=sizeof(a1)/2+1; //取数组长度的一半 做为开始移动的下标
int z=a1[x]; //保存被替换的值
int z1=0; //保存被替换值的下一个值
a1[x]=a1[y+m]; //用b1替换a2
z1=a1[x+1]; //保存a3到z1
a1[x+1]=z;
if ( m==sizeof(a1)/2 )
}}int main(int argc, char* argv[]){
int a[]={1,2,3,10,20,30};
for (int i=0;i&6;i++)
printf("%d ",a[i]);
printf("\n");
return 0;}
输出结果：1 10 2 20 3 30
<dd style="float:cursor:" title="声誉值：1K
这样应该也不错~时间复杂度为O(n)
void Shuffle(int[] arr, int n){
int oriIndex = 1;
int destIndex = 1;
int tempValue = arr[destIndex];
//用于根据当前Index计算目的Index的算式
destIndex = (2 * destIndex - 2 * n + 1) * (destIndex / n) - 2 * destIndex * (destIndex / n - 1);
//交换tempValue和arr[destIndex]的值
tempValue = tempValue ^ arr[destIndex];
arr[destIndex] = tempValue ^ arr[destIndex];
tempValue = tempValue ^ arr[destIndex];
//判断结束
if (destIndex == oriIndex)
写了段伪代码 仅供参考N为数组的大小
乘4代表 它占了多少字节
占了多少个char
for(int j = 4;(N*4)/j != 0;j = j+4){for(int i = 0;i & (N*4)/j;i = i+(j/4)){swap(sab[i+1],sab[N/i+i+1],j);}}
sab 是那个数组
而N是数组大小swap 是交换函数
主要根据第三个参数j确定交换的大小
代表 1个int
4个char不过其中一种情况还在思考 就是 例如 a1 a2 a3 a4 b1 b2 b3
b4a1 b1 a3 b3 a2 b2 a4
b4a1 b1 a2 b2 a3 b3 a4
b4当然肯定还有没有想到的问题 望指教
不过如果 小n
不能被j整除的 话 还要 作一些处理 !这些留给你自己 吧 其实 我还是情愿 空间换时间
解释下 a1 a2 a3 a4 a5 a6 b1 b2 b3
b4 b5 b6a1 b1 a3 b3 a5 b5 a2 b2 a4
b4 a6 b6现在可以把ab看作连体儿
两个int的大小
数组就变成ab1 ab3 ab5 ab2
ab4 ab6ab1 ab2 ab4 ab3 ab5 ab6ab1ab2 ab4 ab3 ab5ab6ab1ab2ab3 ab4ab5ab6
首先观察数组，因为是偶数个的，所以除了首尾两个元素外其他的元素都是需要移动的。我的做法是创建3个存储，一个用来存储变量，一个用来存储位置,一个用来存储总大小。从第二个开始，第二个换到第三个位置，记录第三个变量和位置3，根据位置3算出他需要移动到位置5，于是换到位置5，记录第五个位置的变量和位置5，以此类推，直到最后一个元素位置已经正确不需移动为止。因为除了首尾两个元素外都是需要移动的，所以中间不会中断。
完善一下。
根据评论中我证明的，在一波循环之后需要对一组特殊例子进行处理。即位置为（2n+2）/3和(4n+1)/3的两个数需要互换。
从下标1开始，算出下标1应在的位置，然后把它放置到正确位置b，然后再计算被替换的那个位置b最终的正确位置c，用b原来的值替换c.这样每个数字都一次移动到了正确位置。
#include &stdlib.h&#include &stdio.h&#define swap(a,b) a^=b;b^=a;a^=bvoid sort(int * input, int size){
if(size & 1 == 1)
int n = size/2;
int cur = 1;
int tar = getFinalIndex(cur,n);
int pend = input[tar];
input[tar] = input[cur];
tar = getFinalIndex(tar,n);
int t = input[tar];
input[tar] =
}while(tar!=1);}int getFinalIndex(int i, int n){
if(i+1&=n){
return 2*i;
return (i-n)*2 + 1;}int main(){
int input[] = {1,3,5,2,4,6};
sort(input, sizeof(input)/sizeof(int));
for(i=0; i& sizeof(input)/4; i++){
printf("%d ", input[i]);
printf("\n");}
bool chek(int key,int n){
for(int i = key - 2;i &= 1;i -= 2)
int temp = (i - 1 )/ 2 +
while(temp != i)
if(temp % 2)
temp = (temp - 1 )/ 2 +
temp /= 2;
if (temp == key)
}}void find(int *list,int index,int value,int n,int& count,int& temp,int k){
int times = 0;
//首尾不需要移动
if(index == 0 || index == (2*n - 1))
//计算对应索引，对应索引同时也是下一步递归的原始索引
while( times++ != k)
if(value & n)
value *= 2 ;
value = 2*(value - n) + 1;
//刚好元素已经被移动到目标索引上了
if(value == index)
temp = list[value];
list[value] = list[index];
list[index] =
//递归被交换的元素
find(list,index,value,n,count,temp,k);}//偷懒复制的void PRline(int* s, int count)
int* end = s +
while(s & end) printf("%d\t",*s++);
printf("\n");
int main(){
printf("please input Number(N, k): ");
unsigned int N,
//洗牌次数，这里可以对原长度进行一次计算，减少多余的洗牌次数，网上的答案给出了的公式，我没做这一步优化
scanf("%u %u", &N, &k);
int *list = new int[N];
for ( int i = 0 ;i & N ;++i )
list[i] = 1 +
int temp = 0;
for(int i = 1; count & N - 2 && i & N; i += 2)
while(!chek(i,N/2))
find(list,i,i,N / 2,count,temp,k);
PRline(list, N);
return 0;}
修改了一下算法，确定新索引时回溯之前的索引，现在交换过程不依赖数组本身的值，但是相对的时间复杂度增加了，不稳定，时间复杂度变为稳定的交换时间复杂度O（N)加上不稳定的检查索引时间复杂度O（N^2)。可能这就是递归交换的局限性，数学公式还没找出来，先用暴力方法解决下，等待进一步修改。
#include &iostream.h&swap(int &a,int &b){
a=a-b;}swap(int a[],int n){
int i=n/2-1;
while(i&n-2)
swap(a[i],a[i+1]);
}}void main(){
int a[10]={1,2,3,4,5,6,7,8,9,10};
while (n&3)
swap(a,n);
for (int j=0;j&10;j++)
cout&&a[j]&&"
<dd style="float:cursor:" title="声誉值：1K
算法分析(置换)：
数组int a[]={a1,a2,a3...an,b1,b2,b3...bn}变为{a1,b1,a2,b2,a3,b3...an,bn}可以看做元素的置换（序列的顺序变换）。置换S表示： 即S（{a1,a2,a3...an,b1,b2,b3...bn}）={a1,b1,a2,b2,a3,b3...an,bn}更一般化的表示，将{1,2,3,4，...,n,n+1,n+2,n+3,n+4,...,2n}变为{1,n+1,2,n+2,...,n,2n}
置换的表示：（1）表示1-&1，表示第一个元素的位置不变
(1,2)表示1-&2,2-&1，即第1,2元素位置互换
(1,2,3)表示1-&2,2-&3,3-&1，即第1个元素变为第2个，第2个元素变为第3个，第3个元素变为第1个，同时(1,2,3)=(1,2)(2,3)(3,1)即可以通过三次元素互换得到。
（1,2,3，...,k）=(1,2)(2,3)...(k,1)
对于2n个元素的数组变换有如下规则： 2k-1 -& k,
所以S=(1)(2,n+1,...)....(i1,i2,i3,....)=(1)(2,n+1)(n+1,...)...(i1,i2)(i2,i3)(i3,...)...少于2n次元素互换得到，因为给定数组元素后只需要代码空间和两个元素交换的存储空间，算法的时间复杂度为0(n)，空间复杂度为0(1)
1.把数组前面一半的数据存放到指针temp1中，后半部分存放到temp2.2.同时遍历temp1和temp2的数据，并把一个temp1的数数据和temp的数据依次放在新的buf中就行了。
代码我就不写了， &雷电战机&这款游戏有没有玩过，里面有种回旋的炸弹可以类似这个算法。只申请一个变量缓存对象。
附加这个问题的公式：j= 2*(i%n) + i/n, (0 &=i,j&=n-1,).i是A元素的初始位置，j是结果位置
找个临时存储区,然后,n&1;an和bn-1交换位置,step等于2.
这题就是一次遍历中把a和b的数一次对应取一个，然后放到一个临时的数组里 最后把数组放到a里就可以了 既保证了空间为1 也保证了时间为nint b[]for(int i = 0;i & a.length / 2;i++){b[k] = a[i];b[k++] = a[a.length / 2 + i];}a =
敢不敢把它复制给2维的数组，然后再遍历这个2维数组，复制给一维数组
洗牌，初始位置到目标位置：
void Range(int* A, int n)
int pos = 1, value = A[1];
int target_pos = 2, target_value = A[2];
while(pos != target_pos){
A[target_pos] = // 移动到目标位置
pos = target_
value = target_ // 作为当前初始值，准备移动到目标位置
if (pos & n){
target_pos = pos * 2;
target_pos = (pos - n) * 2 + 1;
target_value = A[target_pos]; // 目标位置的原值缓存
int x=n,y=n;
//x和y表示下标位置for(int i=1;i&2*n;i++)
//从头向尾遍历每个位置偶数放a奇数放b{
if(i%2==0)
if(i%2==0)
int p=a[i];
a[i]=a[x];
if(i%2==1)
int p=a[i];
a[i]=a[y];
}}思想是：在y位置肯定是最小的b
当i！=x且x！=y时 x位置是最小的a
当x==y时 i位置是最小的a
不是您所需，查看更多相关问题与答案
德问是一个专业的编程问答社区，请
后再提交答案
关注该问题的人
共被浏览 (11364) 次js数组常见操作及数组与字符串相互转化实例详解
作者：xuewuzhijing10
字体：[ ] 类型：转载 时间：
这篇文章主要介绍了js数组常见操作及数组与字符串相互转化方法,以实例形式较为详细的分析并总结了JavaScript数组的常见使用技巧与转化方法,需要的朋友可以参考下
本文实例讲述了js数组常见操作及数组与字符串相互转化方法。分享给大家供大家参考，具体如下：
数组与字符串的相互转化
&script type="text/javascript"&
var obj="new1abcdefg".replace(/(.)(&#63;=[^$])/g,"$1,").split(",");
//字符串转化为数组
var obj2 = "new2abcdefg".split("");
//字符串转化为数组
alert(obj);
alert(obj.length);
alert(obj instanceof Array);
alert(obj.join("")); //数组转化为字符串
js数组的常见操作
1、数组的创建
var arrayObj = new Array();　//创建一个数组
var arrayObj = new Array([size]);　//创建一个数组并指定长度，注意不是上限，是长度
var arrayObj = new Array([element0[, element1[, ...[, elementN]]]]);　创建一个数组并赋值
要说明的是，虽然第二种方法创建数组指定了长度，但实际上所有情况下数组都是变长的，也就是说即使指定了长度为5，仍然可以将元素存储在规定长度以外的，注意：这时长度会随之改变。
2、数组的元素的访问
var testGetArrValue=arrayObj[1]; //获取数组的元素值
arrayObj[1]= "这是新值"; //给数组元素赋予新的值
3、数组元素的添加
arrayObj. push([item1 [item2 [. . . [itemN ]]]]);// 将一个或多个新元素添加到数组结尾，并返回数组新长度
arrayObj.unshift([item1 [item2 [. . . [itemN ]]]]);// 将一个或多个新元素添加到数组开始，数组中的元素自动后移，返回数组新长度
arrayObj.splice(insertPos,0,[item1[, item2[, . . . [,itemN]]]]);//将一个或多个新元素插入到数组的指定位置，插入位置的元素自动后移，返回""。
4、数组元素的删除
arrayObj.pop(); //移除最后一个元素并返回该元素值
arrayObj.shift(); //移除最前一个元素并返回该元素值，数组中元素自动前移
arrayObj.splice(deletePos,deleteCount); //删除从指定位置deletePos开始的指定数量deleteCount的元素，数组形式返回所移除的元素
5、数组的截取和合并
arrayObj.slice(start, [end]); //以数组的形式返回数组的一部分，注意不包括 end 对应的元素，如果省略 end 将复制
start 之后的所有元素
arrayObj.concat([item1[, item2[, . . . [,itemN]]]]); //将多个数组（也可以是字符串，或者是数组和字符串的混合）连接为一个数组，返回连接好的新的数组
6、数组的拷贝
arrayObj.slice(0); //返回数组的拷贝数组，注意是一个新的数组，不是指向
arrayObj.concat(); //返回数组的拷贝数组，注意是一个新的数组，不是指向
7、数组元素的排序
arrayObj.reverse(); //反转元素（最前的排到最后、最后的排到最前），返回数组地址
arrayObj.sort(); //对数组元素排序，返回数组地址
8、数组元素的字符串化
arrayObj.join(separator); //返回字符串，这个字符串将数组的每一个元素值连接在一起，中间用 separator 隔开。
toLocaleString 、toString 、valueOf：可以看作是join的特殊用法，不常用
二、数组对象的3个属性
1、length 属性
Length属性表示数组的长度，即其中元素的个数。因为数组的索引总是由0开始，所以一个数组的上下限分别是：0和length-1。和其他大多数语言不同的是，JavaScript数组的length属性是可变的，这一点需要特别注意。当length属性被设置得更大时，整个数组的状态事实上不会发生变化，仅仅是length属性变大；当length属性被设置得比原来小时，则原先数组中索引大于或等于length的元素的值全部被丢失。下面是演示改变length属性的例子：
var arr=[12,23,5,3,25,98,76,54,56,76];
//定义了一个包含10个数字的数组
alert(arr.length); //显示数组的长度10
arr.length=12; //增大数组的长度
alert(arr.length); //显示数组的长度已经变为12
alert(arr[8]); //显示第9个元素的值，为56
arr.length=5; //将数组的长度减少到5，索引等于或超过5的元素被丢弃
alert(arr[8]); //显示第9个元素已经变为"undefined"
arr.length=10; //将数组长度恢复为10
alert(arr[8]); //虽然长度被恢复为10，但第9个元素却无法收回，显示"undefined"
由上面的代码我们可以清楚的看到length属性的性质。但length对象不仅可以显式的设置，它也有可能被隐式修改。
JavaScript中可以使用一个未声明过的变量，同样，也可以使用一个未定义的数组元素（指索引超过或等于length的元素），这时，length属性的值将被设置为所使用元素索引的值加1。例如下面的代码：
var arr=[12,23,5,3,25,98,76,54,56,76];
alert(arr.length);
arr[15]=34;
alert(arr.length);
代码中同样是先定义了一个包含10个数字的数组，通过alert语句可以看出其长度为10。随后使用了索引为15的元素，将其赋值为15，即 arr[15]=34，这时再用alert语句输出数组的长度，得到的是16。无论如何，对于习惯于强类型编程的开发人员来说，这是一个很令人惊讶的特性。事实上，使用new Array()形式创建的数组，其初始长度就是为0，正是对其中未定义元素的操作，才使数组的长度发生变化。
由上面的介绍可以看到，length属性是如此的神奇，利用它可以方便的增加或者减少数组的容量。因此对length属性的深入了解，有助于在开发过程中灵活运用。
2、prototype 属性
返回对象类型原型的引用。prototype 属性是 object 共有的。
objectName.prototype
objectName 参数是object对象的名称。
说明：用 prototype 属性提供对象的类的一组基本功能。 对象的新实例“继承”赋予该对象原型的操作。
对于数组对象，以以下例子说明prototype 属性的用途。
给数组对象添加返回数组中最大元素值的方法。要完成这一点，声明一个函数，将它加入 Array.prototype， 并使用它。
function array_max( )
var i, max = this[0];
for (i = 1; i & this. i++)
if (max & this[i])
max = this[i];
Array.prototype.max = array_
var x = new Array(1, 2, 3, 4, 5, 6);
var y = x.max( );
该代码执行后，y 保存数组 x 中的最大值，或说 6。
3、constructor 属性
表示创建对象的函数。
object.constructor //object是对象或函数的名称。
说明：constructor 属性是所有具有 prototype 的对象的成员。它们包括除 Global 和 Math 对象以外的所有 JScript 固有对象。constructor 属性保存了对构造特定对象实例的函数的引用。
x = new String("Hi");
if (x.constructor == String) // 进行处理（条件为真）。
function MyFunc {
// 函数体。
y = new MyF
if (y.constructor == MyFunc) // 进行处理（条件为真）。
对于数组来说：
y = new Array();
var a=new Array("cctv","sxtv","tytv");
var a=new Array(3);
var a=new Array();
a[0]="cctv";
a[1]="sxtv";
a[2]="tytv";
a[3]="xzy";
for(i=0;i&a.i++)
document.writeln(a[i]);
&#61692; 多维数组
var rows= new Array();
rows[0]=new Array(5);
rows[1]=new Array(5);
rows[0][0]="你好";
rows[0][1]="邢志云";
if(rows[0][0]!=null)
alert(rows[0][0]);
可以像上边那样简单的依次赋值,也可以像下边的这样:
var xzy=new Array();
xzy=[1,2,3,4,5,"邢志云","嘿嘿"];//给数组xzy赋值
for(var i=0;i&xzy.i++)
alert(xzy[i]);
也可以直接赋值成多维数组
var s=["你好",["中国","太原","邢志云"],[3,3333],[4,4444],[5,5555],["0",["a","b","c"]],"cc"];
alert(s);//你好,中国,太原,邢志云,3,4,5,5555
alert(s[1]);//中国,太原,邢志云
alert(s[1][2]);//邢志云
alert(s[2][0]);//3
alert(s[2][1]);//3333
alert(s[5][1][0]);//a
alert(s[5][1][2]);//c
alert(s[6]);//cc
push:数据可以向最后的追加元素
var arr=new Array()
arr[0]="xbc1";
arr[1]="bcx2";
arr[2]="cctv3";
arr[3]="xctv4";
arr.push("邢志云");//向最后追加,也可以同时push多个
arr.push("0123");
for(i=0;i&arr.i++)
if(arr[i]!=null)
document.writeln(arr[i]);
pop:弹出最后一个元素,后进先出
var arr=new Array();
arr[0]="a1";
arr[1]="a2";
arr[2]="a3";
arr[3]="a4";
s=arr.pop();//弹出最后一个元素,把值付给s,并删除最后一个元素
for(i=0;i&arr.i++)
document.writeln(arr[i]);
//显示: a1 a2 a3
unshift:插入到第一个之前,
var arr=new Array();
arr[0]="a1";
arr[1]="a2";
arr[2]="a3";
arr[3]="a4";
arr.unshift("第一","第二");//插到第一个元素之前,后面的整体后移
for(i=0;i&arr.i++)
document.write(arr[i]+":");
//显示: 第一:第二:a1:a2:a3:a4:
shift:弹出第一个元素,先进先出
var arr=new Array();
arr[0]="a1";
arr[1]="a2";
arr[2]="a3";
arr[3]="a4";
s=arr.shift();//弹出第一个元素,把值付给s,并删除第一个元素
for(i=0;i&arr.i++)
document.writeln(arr[i]);
//显示: a2 a3 a4
join:利用数组的join方法,连接所有的数组内容
数组的join(string val)可以将数组元素连接起来,并且用中间插入val,当在网页上交互显示下拉框内容的时候可以将内容加载到数组内,再利用innerHTML将内容显示在出来
var a=new Array("cctv","sxtv","tytv");
var a=new Array(3);
var a=new Array();
a[0]="cctv";
a[1]="sxtv";
a[2]="tytv";
a[3]="xzy";
document.writeln(a.join('&br&'));//如果直接用a.join(),则默认会用,分割
用这种方式连接字符串要比 s=s+”ddd”快的多
sort:数组排序 (从小到大)
var arr=new Array(1000)
arr[0]="xbc1";
arr[1]="bcx2";
arr[2]="cctv3";
arr[5]="xctv4";
arr.sort();
for(i=0;i&arr.i++)
if(arr[i]!=null)
document.writeln(arr[i]);
reverse:数组反向,和sort配合使用能实现从大到小排序
var arr=new Array()
arr[0]="a1";
arr[1]="a2";
arr[2]="a3";
arr[3]="a4";
arr.push("邢志云");
arr.push("0123");
//arr.sort();
arr.reverse();//数组反向排列
for(i=0;i&arr.i++)
document.writeln(arr[i]);
//显示: 0123 邢志云 a4 a3 a2 a1
slice:数组截断后赋值给另外一个数组(不改变原始数组)
var xzy1=new Array();
xzy1=["a","b","c","hello","usa","eng"];
var xzy2=xzy1.slice(2,4);//从数组xzy1的2号元素开始到4号元素停止的值结束转成一个数组
for(var i=0;i&xzy2.i++)
document.write(xzy2[i]+":");//显示c hello
也可以这么写
var xzy1=new Array();
xzy1=["a","b","c","hello","usa","eng"];
var xzy2=Array.prototype.slice.call(xzy1,2,4);//从数组xzy1的2号元素开始到4号元素停止的值结束转成一个数组
for(var i=0;i&xzy2.i++)
alert(xzy2[i]);//显示c hello
splice:数组截断或清空(改变原始数组)
var arr=new Array();
arr[0]="a1";
arr[1]="a2";
arr[2]="a3";
arr[3]="a4";
arr[4]="a5";
arr[5]="a6";
var arr2=arr.splice(3,2,"x1","x2");//从3号开始的2个元素,用x1和x2替换,并把替换下的值重新赋给数组arr2
//如果没有参数"x1","x2",则对应的2个元素会从arr中删除,后面的前推
for(i=0;i&arr.i++)
document.write(arr[i]+":");//显示: a1:a2:a3:x1:x2:a6:
document.write("&br/&");
for(i=0;i&arr2.i++)
document.write(arr2[i]+":");//显示: a4:a5:
利用splice来清空数组
var arr=new Array();
arr[0]="a1";
arr[1]="a2";
arr[2]="a3";
arr[3]="a4";
arr[4]="a5";
arr[5]="a6";
alert(arr.length);//显示6
arr.splice(0,);//可以理解为把arr数组清空,又回到初始状态
alert(arr.length);//显示0
concat:数组连接
var arr=new Array();
arr[0]="a1";
arr[1]="a2";
arr[2]="a3";
arr[3]="a4";
arr[4]="a5";
arr[5]="a6";
var arr2=["b1","b2","b3"];
var arr3=arr.concat(arr2);
for(i=0;i&arr3.i++)
document.write(arr3[i]+":");//显示: a1:a2:a3:a4:a5:a6:b1:b2:b3:
var map = {};
map["张三"] = "";
map["李四"] = "5";
map["王五"] = "";
alert(map["李四"]);
用map={}就可以把map清空;
var map = new Array();
map["张三"] = "";
map["李四"] = "5";
map["王五"] = "";
alert(map["李四"]);//显示:5
alert(map.length);//这里map.length显示为0
map[0] = "";
map[1] = "";
map[2] = "";
alert(map.length);//这里map.length显示为3
for(var i=0;i&map.i++)
document.write(map[i]);
alert(map["李四"]);//显示:5
var map={"姓名":"邢志云","性别":"男","年龄":34}
map.婚否="已婚";//可以动态添加
eval("map.国籍='中华'");//但map.后面的标识符只能是以字符开头的,并且不能有-所以全球标识符不宜用在这里
alert(map.国籍);
//alert(map.姓名);//邢志云
//alert(map.年龄);//34
map["民族"]="汉族";//也可以像第一条中那样赋值,但这种可以用任意串做键,如: map["1-2"]="汉族";alert(map.姓名
+":"+map["1-2"]);//也能正常显示
alert(map.姓名+":"+map.民族);
for(var colname in map)
alert(colname );//姓名 性别 年龄 婚否
for(var colname in map)
alert(map[colname]);//邢志云 男 34 已婚
还可以这样
var s="'姓名':'邢志云','性别':'男',35:'年龄'";
eval("var map={"+s+"}");
alert(map["姓名"]);
var s="姓名:'邢志云',性别:'男',35:'年龄'";
eval("var map={"+s+"}");
alert(map["姓名"]);
还可以嵌套
var map={"人员":{"张三":"男","赵六":"女"},
"车辆":{"桑塔纳":"6万","别克":"10万"},
"年龄":34}
alert(map.人员.赵六);//女
alert(map.车辆.桑塔纳);//6万
使用自定义的属性的数组
var a=new Array();
a[0].姓名="邢志云";
a[0].年龄=32;
a[1].姓名="李四";
a[1].年龄=28;
for(var i=0;i&a.i++)
alert(a[i].姓名+":"+a[i].年龄);
希望本文所述对大家JavaScript程序设计有所帮助。
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具