国产xxxx99真实实拍_久久不雅视频_高清韩国a级特黄毛片_嗯老师别我我受不了了小说

資訊專欄INFORMATION COLUMN

JS數(shù)組和數(shù)據(jù)結(jié)構(gòu)的理解

mdluo / 1708人閱讀

摘要:創(chuàng)建數(shù)組的方法有兩種也可以創(chuàng)建指定長度的數(shù)組,默認(rèn)值都是輸出數(shù)組多少個(gè)元素有兩種方法向數(shù)組里添加元素刪除和增加元素在最前和最后位置輸出數(shù)組元素的個(gè)數(shù),在數(shù)組后面添加元素輸出數(shù)組元素的個(gè)數(shù),在數(shù)組前面添加元素輸出刪除掉的元素,刪除最后面

創(chuàng)建數(shù)組的方法有兩種;

var  arr1 = new Array();        //也可以創(chuàng)建指定長度的數(shù)組,默認(rèn)值都是undefined;
        arr1[0] = "this is first ele";
        arr1[1] = 1;
        
var arr2 = ["this is first ele",12];

arr1.length   //輸出數(shù)組多少個(gè)元素

有兩種方法向數(shù)組里添加元素

var arr = [1,2,3,4,5,6];

//刪除和增加元素在最前和最后位置
arr.push(7)          //->7輸出數(shù)組元素的個(gè)數(shù),在數(shù)組后面添加元素
arr.unshift(0)        //->8輸出數(shù)組元素的個(gè)數(shù),在數(shù)組前面添加元素

arr.pop()                 //->7  輸出刪除掉的元素,刪除最后面的元素
arr.shift()                 //->0 輸出刪除掉的元素,刪除最前面的元素

//增加或者刪除指定位置的元素

arr.splice(arg1,arg2,arg3,...)        //arg1開始的位置(不包含),arg2要?jiǎng)h除的個(gè)數(shù),是0的話不刪除,
//arg3及后面是要替換的元素

arr.splice(1,2,"first","second");         //->[2,3]輸出刪除的元素,同時(shí)替換元素

數(shù)組一些常用的方法

var  number = [1,2,3,4,5,6];
var str = ["a","b","c","d","e"];

//連接兩個(gè)數(shù)組,返回新的數(shù)組  ->concat();
number.concat(str)            // [1, 2, 3, 4, 5, 6, "a", "b", "c", "d", "e"]

//和字符串類似的方法 ->slice(start,end),indexOf(),lastIndexOf()都是返回新的數(shù)組;

number.slice(1,3);                    //[2,3]如果參數(shù)是負(fù)數(shù),則和長度加轉(zhuǎn)為正數(shù),但兩個(gè)參數(shù)不會(huì)按照
//大小調(diào)換位置
number.indexOf(3);                //2
number.lastIndexOf(3);             //2

//數(shù)組轉(zhuǎn)成字符串,toString(),join();注意是把整個(gè)數(shù)組轉(zhuǎn)為一個(gè)新字符串,同時(shí)忽略所有的引號(hào),
//null也會(huì)忽略,

str.toString() ===str.join();  //true "a,b,c,d,e"
join()        //參數(shù)不是空的話,就把參數(shù)取代數(shù)字的分隔符" , ";

//可以通過字符串方法split(",")重新生成數(shù)組;
var s = str.toString();
s.split(",") == str;    //true

ES5新的方法
1,Array.forEach(callback,[this.obj]),對數(shù)組的每個(gè)元素都執(zhí)行函數(shù)

在CHROME中輸出如上,函數(shù)默認(rèn)有三個(gè)參數(shù)
1,數(shù)組元素
2,元素索引
3,整個(gè)數(shù)組

var names = ["Biden","Cheney","Gore"];
var presdent = {
    names : ["obama","bush","cliton"],
    read : function(name){if(this.names[0] == "obama"){console.log(name);}},
    job : function(name){alert(name);}
}

presdent.names.forEach(presdent.read);        //undefined;
presdent.names.forEach(presdent.read,presdent);        //obama,bush,cliton

forEach(callback,[object])的第二個(gè)參數(shù)可以指定要執(zhí)行的上下文,比如this的指向問題,還有個(gè)小問題,如果數(shù)組中已經(jīng)刪除的元素是不會(huì)在執(zhí)行函數(shù)的,雖然在數(shù)組中顯示undefined(注意這個(gè)值和
直接賦值的undefined是不一樣的,類似于 “” 和undefined 的區(qū)別)

2,Array.every(callback,[this.obj])Array.some(callback,[this.obj])
返回 true / false;

var number = [2,4,5,6];
var newnum = 3;
function a(arg){
    if(arg>newnum){
        return true;
    }
}
function b1(arg){
    if(number.some(a)){
        console.log("All BIGGER");
    }else{
        console.log("there" at least one small")
    }
}
//All BIGGER
function b2(arg){
    if(number.ervey(a)){
        console.log("All BIGGER");
    }else{
        console.log("there" at least one small")
    }
}
//there" at least one small

從例子中我們可以知道,some方法如果有一個(gè)真就返回true,every方法全部真,才返回true;

3,Array.map(callback,[this.obj])Array.filter(callback,[this.obj]);
返回新的數(shù)組

var number = [1,3,5,7,8];

function a(arg){
    if(arg>4){
        return "this number is >4: "+ arg;
    }{
        return "this number is<4: "+arg ;
    }
}
number.map(a);    //返回執(zhí)行后的結(jié)果數(shù)組,如果函數(shù)沒有返回值則數(shù)組都是undefined;
//["this number is<4: 1", "this number is<4: 3", "this number is >4: 5", 
//"this number is >4: 7", "this number is >4: 8"];

number.filter(a) //返回執(zhí)行函數(shù)后為true的原數(shù)組元素,如果函數(shù)返回值不是true/false則返回全部
//注意函數(shù)的返回值只要松散相等即可如: 0 == false;
// [1, 3, 5, 7, 8]

4,Array.reduce(callback[, initialValue])Array.reduceRight(callback[, initialValue])
返回callback的返回值;

//callback(pre,cur,index,array)有四個(gè)參數(shù),其中index 和array和之前的一樣,pre和cur代表
//前一個(gè)元素和當(dāng)前的元素(pre后面一個(gè)元素);
//如果 initialValue沒有省略,則pre =  initialValue,cur為數(shù)組第一個(gè)元素;
// initialValue省略的話,pre默認(rèn)為數(shù)組第一個(gè)元素,cur為第二個(gè)
var arr  = [1,3,5,7,9];
function sum(pre,cur,index,array){var add = pre + cur;return add};
arr.reduce(sum,11)
//結(jié)果如下
initialValue = pre = 11;  cur = arr[0];
//第一次
add1= pre + arr[0]; cur = arr[1];
//第二次
add2 = add1 +arr[1]
//第 三次
add3 = add2 + arr[2];
//第四次
add4 = add3 + arr[3];
//最后一次
add5 = add4 + arr[4];
//36
arr.reduce(sum)    //25
add.reduceRight(sum)    //25
//和rudece一樣區(qū)別是index從最后往前;

JS的數(shù)據(jù)結(jié)構(gòu)

1. 棧 -—后進(jìn)先出的有序集合;

function Stack(){
    var items = [];
    this.push = function(ele){ items.push(ele);};
    this.pop = function(ele){ return items.pop(ele);};
    this.isEmpty = function(){ return items.length == 0;};
    this.size = function(){return items.length;};
    this.clear = function(){itmes = [];};
    this.show = function(){console.log( items.toString())};
}
//轉(zhuǎn)化進(jìn)制
function to2(number){
    var tem = new Stack();
    var rem;
    var distNumber = "";
    while(number > 0){
        rem = number%2;
        tem.push(rem);
        number = Math.floor(number/2);
    }
    while(!tem.isEmpty()){
        distNumber += tem.pop().toString();
    }
    return distNumber;
}

2,隊(duì)列 ——先進(jìn)先出的有序集合(區(qū)分堆棧)

function Queue(){
    var items = [];
    this.front = function(ele){ items.unshift(ele);};
    this.first = function(){return items[0];};
    this.dequeue = function(ele){ return items.shift();}
    this.enqueue = function(ele){ return items.push();}
    this.isEmpty = function(){ return items.length == 0;};
    this.size = function(){return items.length;};
    this.clear = function(){itmes = [];};
    this.show = function(){console.log( items.toString())};
}
//優(yōu)先隊(duì)列

3,鏈表——有序元素組合,但不是連續(xù)存放,每節(jié)點(diǎn)包含自身和下一個(gè)節(jié)點(diǎn)的指針

function LinkedList(){
    var Node = function (ele){
        this.element = ele;
        this.next = null;
    };
    var head = null;        //始終是第一個(gè)元素節(jié)點(diǎn);
    var length =0;
    this.append = function(ele){
        var node = new Node(ele);
        var current;
        if(head ===null){
            head = node;        //如果沒有元素,就直接放在對象里,且屬性的next永遠(yuǎn)是null;
        }else{
            current = head;   //如果不是空的對象,就循環(huán)對象的元素,直最后的元素是next 是null;
            while(current.next){
                current = current.next;
                }
              current.next = node;
            }
             length++;
     };
     //這種方法只能從頭開始一個(gè)一個(gè)添加;
    this.insert = function(position,ele){
        if(position>= 0&& position <= length{
            var node = new Node(),
            current =head,
            previous ,
            index = 0;
            if(position ===0){
                previous = current;
                head = node;
            }else{
                while(index++ < positon){
                    previous = current;
                    current = current.next;
                }
                length++;
                return true;
            }else{
                return false;
            }
      };
    this.removeAt = function(position){ 
        if(position > -1 && position < length){
            var current = head,
            previous,
            index = 0;
            if(position == 0){
                head = current.next;
            }else{
                while(index++

4,集合——無序且唯一的項(xiàng)組成的(數(shù)學(xué)概念的有限集合不重復(fù))值-值存儲(chǔ),區(qū)分對象

function Set(){
    var items = {};
    this.has = function(value){
        return items.hasOwnProperty(value);
    };
    this.add =function(value){
        if(!this.has(value)){
            items[value] = value;
            return true;
        }
        return false;
    };
    this.remove = function(){
        if(items.has(value)){
            delete items[value];
            return true;
        }
        return false;
    };
    this.clear = function(){
        items = {};
    };
    this.size = function(){
        return Object.keys(items).length;
    };
    this.values = function (){
        return Object.keys(items);
    };
    this.union = function(otherset){        //合并兩個(gè)集合,返回新的集合,合集;
        var unionset = new Set();
        var values = this.values();
        for(var i=0;iotherset.size()){
            return false;
        }else{
            var values = this.values();
             for(var i =0;i

5,字典——不重復(fù)的存儲(chǔ),鍵-值保存;

function Dictionary(){
    var items = {};
    this.has = function(key){
        return key in items;
    };
     this.set = function(key,value){
            items[key] = value;
     };
     this.remove = function(key){
         if(this.has(key)){
             delete items[key];
             return true;
         }
         return false;
     };
     this.get = function(key){
         return this.has(key)?items[key]:undefined;
     };
     this.values = function(){
         var values  = [];
         for(var k in items){
             if(this.has(k)){
                 values.push(itmes[k]);
             }
         };
         return values;
     };
     this.getItems = function(){
         return items;
     };
      this.clear = function(){
        items = {};
    };
    this.size = function(){
        return Object.keys(items).length;
    };
    this.values = function (){
        return Object.keys(items);
    };
}

6,散列表——通過函數(shù)計(jì)算出鍵的位置,也就是說保存的鍵值不是我們提供的原始鍵;

function HashTable(){
    var table = [];
    var loseHashCode = function(key){        //散列函數(shù)
        var hash = 0;
        for(var i = 0;i

7,樹——非順尋數(shù)據(jù)結(jié)構(gòu)

function BinarySearchTree(){
    var Node = function(key){
        this.key = key;
        this.left = null;
        this.right = null;
    };
    var root =null;
    var insertNode = function(node,newNode){
        if(newNode.key < node.key){
            if(node.left === null){
                node.left = newNode;
            }else{
                insertNode(node.left,newNode);
            }
        }else{
            if(node.right ===null){
                node.right = newNode;
            }else{
                insertNode(node.right,newNode);
            }
        }
    };
    this.insert = function(key){
        var newNode  = new Node(key);
        if(root ===null){
            root = newNode;
        }else{
            insertNode(root,newNode)
        }
    };
    var inOrderTraverseNode =function(node,callback){        //中序遍歷
        if(node !== null){
            inOrderTraverseNode (node.left,callback);
            callback(node.key);
            inOrderTraverseNode(node.right,callback);
        }
    };
    this.inOrderTraverse = function(callback){
        inOrderTraverseNode (root,callback)
    };
    var printNode = function(value){        //回掉函數(shù)
        console.log(value);
    };
    this.preOrderTraverse = function(callback){
        preOrderTraverseNode(root,callback);
    };
    var preOrderTraverseNode = function(node,callback){    //先序遍歷
        if(node !== null){
            callback(node.key);
            preOrderTraverseNode(node.left,callback);
            preOrderTraverseNode(node.right,callbck)
        };
    };
      this.postOrderTraverse = function(callback){
        postOrderTraverseNode(root,callback);
    };
    var postOrderTraverseNode = function(node,callback){    //后序遍歷
        if(node !== null){
            preOrderTraverseNode(node.left,callback);
            preOrderTraverseNode(node.right,callbck);
               callback(node.key);
        };
    };
    this.min = function(){
        return minNode(root)
    };
    var minNode = function(node){
        if(node){
            while(node && node.left !=null){
                node = node.left;
            }
            return node.key;
        }
        return null;
    };
     this.max= function(){
        return maxNode(root)
    };
    var maxNode = function(node){
        if(node){
            while(node && node.right !=null){
                node = node.right;
            }
            return node.key;
        }
        return null;
    };
    this.search = function(key){
        return searchNode(root,key);
    };
    var searchNode = function(node,key){
        if(node === null){return false;}
        if(keynode.key){return searchNode(node.right,key)}
        else{return true;}
    };
    this.remove = function(key){
        root = removeNode(root,node);
    };
    var removeNode = function(node,key){
        if(node ===null){ return null; };
        if(key < node.key){ 
            node.left = removeNode(node.left,key);
            return node;
        }else if(key>node.key){
            node.right = removeNode(node.right,key)
        }else{
            if(node.left ===null && node.right ===null){
                node =null;
                return node;
            }
            if(node.left ===null){
                node = node.right;
                return node;
            }else if(node.right ===null){
                node = node.left;
                return node;
            };
            var aux = findMinNode(node.right);
            node.key = aux.key;
            node.right = removeNode(node.right,aux.key);
            return node;
        }
    }
    
}

8,圖——G = (V ,E)由邊和頂點(diǎn)組成

function Graph(){
    var  vertices = [];
    var adjList = new Dictonary();
    this.addVertex = function(v){
        vertices.push(v);
        adjList.set(v,[]);
    };
    this.addEdge = function(v,w){
        adjList.get(v).push(w);
        adjList.get(w).push(v);
    };
    this.toString = function(){
        var s = "";
        for(var i=0;i";
            var neighbors = adjList.get(vertices[i]);
            for(var j =0;j

數(shù)組排序的方法

function ArrayList(){
    var array = [];
    this.insert = function(item){array.push(item)};
    this.toString = function(){return array.join()};
    var swap = function(index1,index2){        //交換數(shù)組位置的方法
        var temp = array[index1];
        array[index1] = array[index2];
        array[index2] = temp;
    };
    this.bubbleSort = function(){        //冒泡排序從小到大
        var length = array.length;
        for(var i =0;iarray[j+1]){
                    swap(j,j+1);
                }
            }
        }
    };
    this.selectionSort = function(){        //選擇排序,選擇最小值放在前面;
        var length = array.length;
        var indexMin;
        for(var i= 0;i array[j]){
                    indexMin = j;
                }
            }
            if(i ! = indexMin){
                swap(i,indexMin)
            }
        }
    }
    this.insertionSort = function(){        //插入排序;
        var length= array.length;
        var j,temp;
        for(var i = 0;i0 && array[j-1] >temp){
                array[j] ==array[j-1];
                j--;
            }
            array[j] = temp;
        }
    }
    this.mergeSort = function(){
        array = mergeSortRec(array)
    };
    var mergeSortRec = function(array){
        var length = array.length;
        if(length ===1){
            return array;
        }
        var mid = Math.floor(length/2);
        var left = array.slice(0,mid);
        var right = array.slice(mid,length);
        return merge(mergeSortRec(left),mergeSortRec(right))
    };
    var merge = function(left,right){
    var result = [];
    var il = 0,ir = 0;
    while(il 1){
        index = partition(array,left,right);
        if(left           
               
                                           
                       
                 

文章版權(quán)歸作者所有,未經(jīng)允許請勿轉(zhuǎn)載,若此文章存在違規(guī)行為,您可以聯(lián)系管理員刪除。

轉(zhuǎn)載請注明本文地址:http://specialneedsforspecialkids.com/yun/91868.html

相關(guān)文章

  • JSON:如果你愿意一層一層剝開我心,你會(huì)發(fā)現(xiàn)...這里水很深——深入理解JSON

    摘要:說句玩笑話,如果是基于的,可能就叫了,形式可能就是這樣的了,如果這樣,那么可能現(xiàn)在是和比較密切了。此外,還有一個(gè)函數(shù),我們較少看到,但是它會(huì)影響。 我們先來看一個(gè)JS中常見的JS對象序列化成JSON字符串的問題,請問,以下JS對象通過JSON.stringify后的字符串是怎樣的?先不要急著復(fù)制粘貼到控制臺(tái),先自己打開一個(gè)代碼編輯器或者紙,寫寫看,寫完再去仔細(xì)對比你的控制臺(tái)輸出,如果有...

    Baaaan 評論0 收藏0
  • JS程序

    摘要:設(shè)計(jì)模式是以面向?qū)ο缶幊虨榛A(chǔ)的,的面向?qū)ο缶幊毯蛡鹘y(tǒng)的的面向?qū)ο缶幊逃行┎顒e,這讓我一開始接觸的時(shí)候感到十分痛苦,但是這只能靠自己慢慢積累慢慢思考。想繼續(xù)了解設(shè)計(jì)模式必須要先搞懂面向?qū)ο缶幊蹋駝t只會(huì)讓你自己更痛苦。 JavaScript 中的構(gòu)造函數(shù) 學(xué)習(xí)總結(jié)。知識(shí)只有分享才有存在的意義。 是時(shí)候替換你的 for 循環(huán)大法了~ 《小分享》JavaScript中數(shù)組的那些迭代方法~ ...

    melody_lql 評論0 收藏0
  • JavaScript知識(shí)點(diǎn)總結(jié)

    摘要:參與任何數(shù)值計(jì)算的結(jié)構(gòu)都是,而且。。面向人類的理性事物,而不是機(jī)器信號(hào)。達(dá)到無刷新效果。的工作原理總是指向一個(gè)對象,具體是運(yùn)行時(shí)基于函數(shù)的執(zhí)行環(huán)境動(dòng)態(tài)綁定的,而非函數(shù)被聲明時(shí)的環(huán)境。原型對象上有一個(gè)屬性,該屬性指向的就是構(gòu)造函數(shù)。 1.JS面向?qū)ο蟮睦斫?面向?qū)ο蟮娜筇攸c(diǎn):繼承、封裝、多態(tài) 1、JS中通過prototype實(shí)現(xiàn)原型繼承 2、JS對象可以通過對象冒充,實(shí)現(xiàn)多重繼承, 3...

    sean 評論0 收藏0
  • 對類型化數(shù)組(Typed Array)與ArrayBuffer理解

    摘要:類型化數(shù)組也是中新引入的。用一句話解釋類型化數(shù)組就是它是操作二進(jìn)制數(shù)據(jù)的接口。類型化數(shù)組類型化數(shù)組的應(yīng)用二進(jìn)制數(shù)據(jù)的接口主要應(yīng)用于文件,在中涉及文件處理的幾乎都可以應(yīng)用,主要是,,。 類型化數(shù)組(Typed Array)也是HTML5中新引入的API。用一句話解釋類型化數(shù)組就是:它是JS操作二進(jìn)制數(shù)據(jù)的接口。 眾所周知,直接操作二進(jìn)制數(shù)據(jù)可以使程序更為高效, 盡管JS對常規(guī)數(shù)組做了很多...

    Worktile 評論0 收藏0
  • 深入探究immutable.js實(shí)現(xiàn)機(jī)制(一)

    摘要:本文會(huì)集合多方資料以及我自己的一些理解,深入一些探究實(shí)現(xiàn)機(jī)制。位分區(qū)實(shí)際上是數(shù)字分區(qū)的一個(gè)子集,所有以的整數(shù)次冪,,,,為基數(shù)的數(shù)字分區(qū)前綴樹,都可以轉(zhuǎn)為位分區(qū)。其實(shí)舉個(gè)例子最好理解比如數(shù)字的二進(jìn)制形式是,這是一個(gè)位的二進(jìn)制數(shù)。 Immutable.js 采用了持久化數(shù)據(jù)結(jié)構(gòu)和結(jié)構(gòu)共享,保證每一個(gè)對象都是不可變的,任何添加、修改、刪除等操作都會(huì)生成一個(gè)新的對象,且通過結(jié)構(gòu)共享等方式大幅...

    zhangfaliang 評論0 收藏0

發(fā)表評論

0條評論

最新活動(dòng)
閱讀需要支付1元查看
<