19-JavaScript-基本语法-数组-冒泡-二分查找

蔚落 2022-09-18 06:50 21阅读 0赞

数组  
\- 一维数组  
\- 排序 查找  
\- 多维素组

# 1. 概念 #

使用单独的变量名来存储一系列的值。  
数组的类型: 引用类型/复杂类型/复合类型.

# 2. 注意 #

① JS中的数组,可以存放任意数据类型  
② 函数调用时, 传参时 传的是数组的引用

##  ③ 越界使用 ##

var arr = \[1, 2\];  
  
console.info( arr\[2\] ); // undefined

##  ④ 动态增长 ##

var arr = [1, 2];
    
        console.info( arr[2] ); // undefined
    
        arr[5] = 100;
    
        console.info( "length " + arr.length );
    
        for (var i = 0; i < arr.length; i++) {
            console.info( "arr[" + i + "] = " + arr[i] );
        }
        /*
        length 6
        arr[0] = 1
        arr[1] = 2
        arr[2] = undefined
        arr[3] = undefined
        arr[4] = undefined
        arr[5] = 100
        */

##  ⑤ 特殊遍历  ##

var arr = [];
    
        arr["a"] = 11;
        arr["b"] = 22;
        arr["c"] = 33;
    
        for ( var key in arr ) {
            console.info( key + " = " + arr[key]);
        }
    /*    
        a = 11 
        b = 22 
        c = 33
    */

# 3. 一维数组的创建与使用 #

##  3.1 定义 ##

var arr = \[1, "A", null, NaN, true\];

##  3.2 使用 ##

###  1) arrName\[index\] ###

var arr = \[1, "A", null, NaN, true\];  
  
for (var i = 0; i < arr.length; i++) \{  
console.info( arr\[i\] );  
\}

###  2) arrName.length ###

获得数组长度

###  3) stringObject.split(separator,howmany) ###

拆分,  
参看 http://www.w3school.com.cn/js/jsref\_split.asp  
  
var str = "how are you?";  
var arr = str.split(" ");  
for (var i = 0; i < arr.length; i++) \{  
console.info( "arr\[" + i + "\] = " + arr\[i\] );  
\}

# 4. 二维数组  #

##  1) 定义 ##

var arr0 = \["00", "01"\];  
var arr1 = \["10", "11", "12"\];  
  
var arr = \[arr0 , arr1\];

##  2) 使用 ##

var arr0 = ["00", "01"];
    var arr1 = ["10", "11", "12"];
    
    var arr = [arr0 , arr1];
     
    // console.info( arr[0][1] );
    
    for (var i = 0; i < arr.length; i++) {
        for (var j = 0; j < arr[i].length; j++) {
            console.info( "arr[" + i + "][" + j + "] = " + arr[i][j]  );
        }
    }

##  3) 举例- 转置(行列互换) ##

var arr0 = ["00", "01", "02"];
    var arr1 = ["10", "11", "12"];
    
    var arr = [arr0, arr1];
    
    for (var i = 0; i < arr.length; i++) {
        for (var j = 0; j < arr[i].length; j++) {
            document.writeln( arr[i][j] + " " );
        }
        document.writeln("<br/>");
    }
    
    document.writeln("<br/>");  
    
    for (var j = 0; j < arr[0].length; j++) {
        for (var i = 0; i < arr.length; i++) {
            document.writeln( arr[i][j] + " " );
        }
        document.writeln("<br/>");
    }
    
    /*
    00  01  02 
    10  11  12 
    
    00  10 
    01  11 
    02  12  
    */

# 5. 冒泡排序 bubbleSort #

function printArr(arr) {
        for (var i = 0; i < arr.length; i++) {
            document.writeln( arr[i] + " " );
        }
        document.writeln("<br/>");
    }
    
    function swap(arr, i, j) {
        var temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
    
    function bubble(arr) {
        for (var i = 0; i < arr.length - 1; i++) {
            for (var j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j+1]) {
                    swap(arr, j, j+1);
                }
            }
        }
    }
    
    var arr = [4, 1, 8, 3, 2, 7, 5, 9, 6];
    
    printArr(arr);
    
    bubble(arr)
    
    printArr(arr);

# 6. 二分查找 binarySearch #

## 1) 普通方式 ##

function binarySearch(arr, val) {
        var low = 0;
        var high = arr.length - 1;
        var mid = Math.floor( (low + high) / 2 );
    
        while( low < high) {
            if ( arr[mid] > val ) { 
                // 往左边找, mid-1 是因为 arr[mid] 比 val大
                mid = Math.floor( (low + mid-1) / 2 );
            } else if ( arr[mid] < val ) { // 右边找
                mid = Math.floor( (mid+1 + high) / 2 );
            } else {
                return mid;
            }
        }
    
        return -1; // 没有
    
    }

## 2) 递归 ##

function binarySearch_2(arr, val, low, high) {
    
        if (low > high) {
            return -1;
        }
    
        var mid = Math.floor( (low + high) / 2 );
    
        if ( arr[mid] > val ) { 
        // 往左边找
            return binarySearch_2(arr, val, low, mid - 1);
        } else if ( arr[mid] < val ) { 
        // 右边找
            return binarySearch_2(arr, val, mid + 1, high);
        } else {
            return mid;
        }    
    
    }

发表评论取消回复

表情：

评论列表（有 0 条评论，21人围观）

还没有评论，来说两句吧...

相关阅读

相关关于二分查找与冒泡排序

一.关于二分查找 ①二分查找的两种不同的代码实现二分查找：在有序数组中将数组筛选的范围不断进行缩减，从而达到提高效率和查找到有效数据的目的第一种： publ

本是古典何须时尚/ 2024年04月08日 09:15/ 0 赞/ 164 阅读

相关 Java--冒泡、选择排序，二分查找

一、冒泡排序，选择排序，二分查找 package com.cat.stringbuffer; public class BubbleSort {

╰+哭是因爲堅強的太久メ/ 2023年10月17日 10:59/ 0 赞/ 112 阅读

相关数组——704. 二分查找

1 题目描述 1. 二分查找给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 targe

雨点打透心脏的1/2处/ 2023年10月08日 16:03/ 0 赞/ 143 阅读

相关 Java基本查找算法--二分查找

`一、二分法查找` > 又称为折半查找。要求线性表示`有序`表，即表中记录按关键字有序。二分查找的基本思想是:设R\[low…high\]是当前查找区间，首先确定该区间的

淩亂°似流年/ 2023年10月06日 11:05/ 0 赞/ 140 阅读

相关【2019.10.19】JavaWeb(二) JavaScript基本语法、基本对象（ECMAScript）

JavaScript 概念：一门可短短脚本语言运行在客户端浏览器中的。每一个浏览器都有JavaScript的解析引擎脚本语

ゞ浴缸里的玫瑰/ 2023年06月09日 07:56/ 0 赞/ 31 阅读

相关数组查找算法：线性查找、二分查找

1，线性查找 1.1，线性查找基本介绍线性查找就是基本的循环查找，遍历每一个元素进行比对，返回匹配结果 1.2，线性查找代码实现 packa

亦凉/ 2023年02月28日 01:22/ 0 赞/ 102 阅读

相关 19-JavaScript-基本语法-数组-冒泡-二分查找

数组 \- 一维数组 \- 排序查找 \- 多维素组 1. 概念使用单独的变量名来存储一系列的值。数组的类型: 引用类型/复杂类

蔚落/ 2022年09月18日 06:50/ 0 赞/ 22 阅读

相关冒泡排序`交换排序·二分查找

public class ArrayTest \{ public static void main(String\[\] args) \{ int\[\] a = ne

雨点打透心脏的1/2处/ 2022年08月08日 12:51/ 0 赞/ 278 阅读

相关冒泡排序与二分查找

冒泡排序：冒泡排序的核心思想是用第一个数依次与以后的数比较，如果有比它大或者比它小的就与它交换位置，那么第一个得到的数就是最大或者最小的；同理用第二个数再执行依次，，，依次

Bertha 。/ 2022年05月18日 11:10/ 0 赞/ 248 阅读

相关冒泡排序和二分查找

有序数组二分查找实现： public class BinarySearch{ / int midArray = (righ

深碍√TFBOYSˉ_/ 2022年01月27日 07:35/ 0 赞/ 316 阅读