js小练习1

1--冒泡排序

var arr=[5,0,-34,98,23];
var flag=false;
for(var i=0;i<arr.length-1;i++){  //遍历多少趟
    for(var j=0;j<arr.length;j++){ //每一趟遍历，从前往后，相邻两项之间进行比较，若前者大于后者进行交互位置
        if(arr[j]>arr[j+1]){
            var temp=arr[j];
            arr[j]=arr[j+1];
            arr[j+1]=temp;
            flag=true;
        }
    }
    if(flag){
        flag=false;
    }else{
        break;
    }
}
for(var i=0;i<arr.length;i++){
    console.log(arr[i]);
}
//-34 0 5 23 98

2--二分查找

//二分查找，找到中间数，和要寻找的数进行比较，若大于寻找数，则说明要寻找的数在左半部分，
//就把该数组二分，只从左边找，依次递归
var arr=[1,4,6,8,12,46];
function binarySearch(arr,findVal,leftIndex,rightIndex){  //传入数组、需查找的值、数组左边界下标、数组右边界下标四个参数
    if(leftIndex>rightIndex){ //左边界下标大于右边界下标的错误情况，排除
        console.log("找不到");
        return ;
    }
    var midIndex=Math.floor((leftIndex+rightIndex)/2); //计算数组中间边界下标
    var midVal=arr[midIndex];//计算数组中间值
    if(midVal>findVal){  //中间数大于需查找数，说明需查找的数在数组的左半部分
        binarySearch(arr,findVal,leftIndex,midIndex-1);
    }else if(midVal<findVal){//中间数小于需查找数，说明需查找的数在数组的右半部分
        binarySearch(arr,findVal,midIndex+1,rightIndex); 
    }else{      //上面两种情况都不满足，说明需查找的数就等于数组中间数
      console.log("找到了，其下标为："+midIndex); 
      return ;
   } 
} 
binarySearch(arr,9,0,arr.length-1);

3--快速排序

//采用递归方法，将数组中的数据依次分解成包含较小元素和较大元素的不同子序列中。首先，选准一个
//基准值，如以中间值为基准，然后对数组进行遍历，将所有小于基准值的元素都移到基准值的左边，对
//大于基准值的元素都移到基准值的右边，对基准值左边与右边元素，不断重复前面的步骤，直到所有子集
//只剩下一个元素为止。对较小的数组和较大的数组分别递归调用quickSort
function quickSort(arr){
    if(arr.length<=1){  //数组不存在的情况
        return arr;
    } 
    var left=[]; //定义空数组left用来存储小于基准值的数据
    var right=[];//定义空数组right用来存储大于基准值的数据
    var pivotIndex=Math.floor(arr.length/2);//选择数组中间值作为基准值，这里为其下标
    var pivot=arr.splice(pivotIndex,1)[0];//添加/删除元素方法splice，这里用来删除
    for(var i=0;i<arr.length;i++){//遍历
        if(arr[i]<pivot){  //小于基准值的元素放在left数组中
            left.push(arr[i]);
        }else{            //大于基准值的元素放在right数组中
            right.push(arr[i]);
        }
    }
    return quickSort(left).concat([pivot],quickSort(right));  //递归调用，并进行数组连接
}
var a=[];
for(var i=0;i<10;i++){   //随机产生10个1-100的数据
    a[i]=Math.floor(Math.random()*100+1);
}
console.log(a);
console.log(quickSort(a));//调用
//[ 76, 68, 80, 38, 26, 100, 55, 79, 33, 50 ]
// [ 26, 33, 38, 50, 55, 68, 76, 79, 80, 100 ]

　　

4--假设n为正整数，如：23123，n的位数不确定，分别求解下列问题：

（1）分别输出每个数，每个数中间用空格隔开。

（1）
function single(n){ 
    var nums=[];//定义空数组
    nums= n.toString();//将数字转换为字符，并存储于数组中
    var str="";  //定义空字符串
    for(var i=0;i<nums.length;i++){ //将数组中的字符元素正序输出，并存储于字符串中
        str+=nums[i]+" ";
    }
    return str; //返回字符串
}
console.log(single(23123));//2 3 1 2 3 

（2）求n的逆序数，如32132。

(2)
function converse(n){
    var arr=[];//定义空数组
    arr= n.toString();//数字转换为字符，并存储于数组中
    var str=" "; //定义空字符串
    for(var i=arr.length-1;i>=0;i--){//将数组中的字符元素逆序输出，并存储于字符串中
        str+=arr[i]+" ";
    }
    return str;//返回该字符串
}
console.log(converse(23123));//3 2 1 3 2

（3）求n的最小数，如12233。

（3）
function min(n){
    var arr=[];
    var i=0;
    for(;i<10;i++){   //开辟一个内存为10的数组，初始为0
        arr[i]=0;
    }
    while(n){
        arr[n%10]++;//利用hash将每一位数分别映射到地址为0-9的数组中
        n=parseInt(n/10); //将元素从末尾去掉一位
    }
    var str=" ";
    for(var i=0;i<10;i++){  //遍历hash表
        while(arr[i]--){ //对应hash地址中存在数据的地址，正序依次输出其hash地址，即将数据按顺序由小到大排序并输出了
            str+=i;
        }
    }
    return str;
}
console.log(min(23123));// 12233　　

（4）求n的最大数，如33221。

（4）
function max(n)  
    var arr=[];
    var i=0;
    for(;i<10;i++){//开辟一个内存为10的数组，初始为0
        arr[i]=0;
    }
    while(n){
        arr[n%10]++;
        n=parseInt(n/10);
    }
    var str=" ";
    for(var i=9;i>=0;i--){ //逆序遍历，对于hash地址存在数据的地方，依次逆序将其地址输出，即相应地进行逆序排列，由大到小
        while(arr[i]--){
            str+=i;
        }
    }
    return str;
}
console.log(max(23123));// 33221　　

（5）求n中每个奇数组成的数，顺序不变，如313。

（5）
function single(n){
    var arr=[];
    arr=n.toString();
    var str1=" ";
    for(var i=0;i<arr.length;i++){
        if(arr[i]%2!=0){ //取出数组中的奇数，并按其位置依次输出
            str1+=arr[i];
        }
    }
    return str1;
}
console.log(single(23123));//313

（6）求n中每个奇数组成的最大数，如331。

（6）
function single(n){
    var arr=[];
    arr=n.toString();
    var str1=" ";
    for(var i=0;i<=arr.length-1;i++){
        if(arr[i]%2!=0){  //选择数组中的奇数，并按其位置依次输出
            str1+=arr[i];
        }
    }
    return str1;
}
function max(n){  //对取出的奇数数据再进行排序
    var arr=[];
    var i=0;
    for(;i<10;i++){
        arr[i]=0;
    }
    while(n){
        arr[n%10]++; //借助hash地址进行存储
        n=parseInt(n/10);
    }
    var str=" ";
    for(i=9;i>=0;i--){ //hash地址中存值的地址逆序输出
        while(arr[i]--){
            str+=i;
        }
    }
    return str;
}
console.log(max(single(23123)));//313　

5--对一个整数x：定义rev（x）将x按位反过来，并去掉前导0，如123=>rev（x）=321；100=>rev（x）=1.给出整数x，y，求reev（rev（x）+rev（y））

function rev(m){
    var n=0;
    while(m){
        n=10*n+m%10;//从后往前计算相应位置上的数字
        m=parseInt(m/10);//求取一位，数据相应缩小10倍
    }
    return n;
}
var x=123;
var y=100;
console.log(rev(x));//321
console.log(rev(y));//1
console.log(rev((rev(x)+rev(y))));//223　

6--查找元素并输出其下标

function indexOf(arr,item){
    var count=-1;
    for(var v in arr){  //遍历
        if(arr[v]==item){
            count=v;
            break;
        }
    }
    return count;
}
var arr=[1,4,5,6,8];
var item=8;
console.log(indexOf(arr,item));//4

　　

 7--数组去重

function unique(arr){
  for(var i=0;i<arr.length;i++){
   for(var j=i+1;j<arr.length;j++){
     if(arr[i]==arr[j]{ //两个数据进行比较，存在相等的情况则删除一个
         arr.splice(j,1);
       }
      }
   }
       return arr;
  }
  var arr=[‘a’,’’s,’d’,’a’,’d’];
  console.log(unique(arr));

 8--数组转置

var arr=[[2,5,6,8],[8,5,6,9],[9,6,2,1]];
var arrNew=new Array(arr[0].length);  //开辟内存
for( var i = 0; i< arr[0].length; i++){
    arrNew[i] = new Array(arr.length)  //开辟内存
}
for(var i=0;i<arr.length;i++){  //行列对换
    for(var j=0;j<arr[0].length;j++){
        arrNew[j][i]=arr[i][j];

    }
}
for(var i=0;i<arrNew.length;i++) {  //遍历新数组
    for (var j = 0; j < arrNew[0].length; j++) {
        document.writeln(arrNew[i][j] + ' ');
    }
    document.writeln("<br/>");
}

9--对一个整数x：定义rev（x）将x按位反过来，并去掉前导0，如123=>rev（x）=321；100=>rev（x）=1.给出整数x，y，求rev（rev（x）+rev（y））

function rev(m){
    var n=0;
    while(m){
        n=10*n+m%10; // 依次求取末尾值
        m=parseInt(m/10);//对数据大小进行调整
    }
    return n;
}
var x=123;
var y=100;
console.log(rev(x));//321
console.log(rev(y));//1
console.log(rev((rev(x)+rev(y))));//223

10--

function add(m){
    return function b(n){
        return n+m++;
    }
}
var add1=add(070);  //56
var add2=add(050);  //40
console.log(add1(010));//64
console.log(add2(010));//48

11--

function syb(a){
    return a-"010";//“010”当成10
}
console.log(syb(020));//6

12--n是一个4位数，其9倍恰好是其反序数，求n

function test()
{
   for( var n=1000; n< 10000; ++n){
       var  q = parseInt(n/1000); //千位数字
       var  b = parseInt(n%1000/100);//百位数字
       var  s = parseInt(n%100/10);//十位数字
       var  g = parseInt(n%10);//个位数字
       if(n*9 == 1000*g+s*100+b*10+q){
           console.log(n)
       }
   }
}
test()//1089

13--

function cc(i){
    if(i==3){i+=2}
    if(i==5){i--}
    if(i==4){i-=2}
    return i;
}
for(var i=2;i<6;i++){
    console.log(cc(i))
}
//2
//2
//2
//2
ps：三条条件都要看，满足即执行

14--

var arr1 = "john".split('');   //j o h n
var arr2 = arr1.reverse();    //n h o j
var arr3 = "jones".split('');  // j o n e s
arr2.push(arr3);

console.log(arr1);
console.log(arr2);
console.log(arr3);

console.log("array 1: length=" + arr1.length + " last=" + arr1.slice(-1)); 
console.log("array 2: length=" + arr2.length + " last=" + arr2.slice(-1));
 //array 1: length=5 last=j,o,n,e,s 
//array 2: length=5 last=j,o,n,e,s 
//[ 'n', 'h', 'o', 'j', [ 'j', 'o', 'n', 'e', 's' ] ]
 //[ 'n', 'h', 'o', 'j', [ 'j', 'o', 'n', 'e', 's' ] ]
 //[ 'j', 'o', 'n', 'e', 's' ] 
//array 1: length=5 last=j,o,n,e,s 
//array 2: length=5 last=j,o,n,e,s 
ps:reverse() 方法用于颠倒数组中元素的顺序。该方法会改变原来的数组，而不会创建新的数组。

15--

var a={},
    b={key:'b'},
    c={key:'c'};
console.log(a);      //{}
a[b]=123;
console.log(a);       //{ '[object Object]': 123 }
a[c]=456;
console.log(a);          //{ '[object Object]': 456 }
console.log(b);         //{ key: 'b' }
console.log(c);           //{ key: 'c' }
console.log(a[b]);          //456

16--用js实现随机选取10--100之间的10个数字，存入一个数组，并排序。

var iArray = [];
function getRandom(istart, iend){
    var iChoice = iend - istart +1;
    return Math.floor(Math.random() * iChoice) + istart;  //随机产生istart到iend间的数据
}
for(var i=0; i<10; i++){  //调用，产生10个
    iArray.push(getRandom(10,100));
}
console.log(iArray.sort()); 

17--判断一个字符串中出现次数最多的字符，统计这个次数

//判断一个字符串中出现次数最多的字符，统计这个次数
function selectmaxchar(str)
{
    var mp ={};  //定义空对象，可以理解为map容器
    for(var i = 0; i< str.length; i++){
        if( !mp[str[i]]) {     //判断mp里是否有该元素，没有的话，将该元素放入map，并设置其个数为1
            mp[str[i]] = 1
        }else{      //mp里已有该元素，则将对应键的值加1
            mp[str[i]]++
        }
    }
    console.log(mp);//{ d: 3, s: 3, h: 3, f: 4, k: 2, z: 18 }
    var maxVal = 0;
    var maxChar;
    for(var key in mp){  //遍历mp，其中为相应元素及其出现个数的键值对，选取值最大的键值对
        if( maxVal < mp[key]){
            maxVal = mp[key];
            maxChar = key;
        }
    }
    console.log(maxChar, mp[maxChar])//z 18
    return maxChar,mp[maxChar]
}
console.log(selectmaxchar("dshdffshfkhsdkfzzzzzzzzzzzzzzzzzz"));//18

18--验证字符串的组成规则，第一个须为数字，后面可以是字母、数字、下划线，总长度为5-20位

/^(d){1}[w]{4,19}$/            
ps：w 匹配任意字符、数字、下划线 

19--有一个数组a=[8,10,30,55,78,90,1]，新建一个数组b，b从a中一次随机取一个元素，取完为止

function select(arr){
    var arrNew=[];
    var len = arr.length
    for(var i=0;i<len;i++){
        var index = parseInt(Math.random()*arr.length);  //随机产生arr数组中的下标
        arrNew.push(arr[index]); //将该下标对应的值放进新的数组
        arr.splice(index, 1);//并在原数组中删除已经选择出去的元素
    }
    return arrNew
}
var arr = [1,32,31,10,8,9,66];
console.log(select(arr))