精华内容
下载资源
问答
  • 冒泡排序冒泡排序是最慢排序算法之一,数据值会像起跑一样从数组一端漂浮到另一端动画演示js实现var CArray = function () { this.dataStore = [9,5,6,8,2,7,3,4,1] //定义数组 this.swap = swap; //数值交换...

    冒泡排序

    冒泡排序是最慢的排序算法之一,数据值会像起跑一样从数组的一端漂浮到另一端

    动画演示


    js实现

    var CArray = function () {
      this.dataStore = [9,5,6,8,2,7,3,4,1]   //定义数组
      this.swap = swap;      //数值交换位置
      this.bubbleSort = bubbleSort  //冒泡排序
    }
    function swap(arr, index1, index2) {
      var temp = arr[index1]
      arr[index1] = arr[index2]
      arr[index2] = temp
    }
    function bubbleSort() {
      var data = this.dataStore
      var numlength = data.length
      for(var outer = numlength; outer>=2; --outer) {
        for(var inner = 0; inner<=outer -1;inner ++) {
          if(data[inner] > data[inner + 1]){
            this.swap(this.dataStore, inner, inner+1)
          }
        }
      }
    }
    var aa= new CArray()
    aa.bubbleSort()
    console.log(aa.dataStore)复制代码

    选择排序

    从数组的开头开始,将第一个元素和其他元素相比,最小的元素放在第一个位置,再从第二个位置开始

    动画演示


    js实现

    var CArray = function () {
      this.dataStore = [9,5,6,8,2,7,3,4,1]   //定义数组
      this.swap = swap;      //数值交换位置
      this.selectSort = selectSort  //选择排序
    }
    function swap(arr, index1, index2) {
      var temp = arr[index1]
      arr[index1] = arr[index2]
      arr[index2] = temp
    }
    function selectSort() {
      var min
      for(var outer = 0; outer < this.dataStore.length -2; ++outer) {
        min = outer
        for(var inner = outer +1; inner <= this.dataStore.length -1;  ++inner) {
          if(this.dataStore[inner] < this.dataStore[min]){
            min = inner
          }
        }
        this.swap(this.dataStore, outer,  min)
      }
    }
    var aa= new CArray()
    aa.selectSort()
    console.log(aa.dataStore)复制代码

    插入排序

    类似人们按数字或字母顺序对数据进行排序,后面的要为前面的腾位置

    动画演示


    js实现

    var CArray = function () {
      this.dataStore = [9,5,6,8,2,7,3,4,1]   //定义数组
      this.insertSort = insertSort  //插入排序
    }
    function insertSort() {
      var temp, inner
      for(var outer = 1; outer < this.dataStore.length; ++outer) {
        temp = this.dataStore[outer]
        inner = outer
        while(inner>0 && (this.dataStore[inner -1]) >= temp){
          this.dataStore[inner] = this.dataStore[inner -1]
          // console.log('inner->',this.dataStore)
          inner --
        }
        this.dataStore[inner] = temp
        // console.log('outer->',this.dataStore)
      }
    }
    var aa= new CArray()
    aa.insertSort()
    console.log(aa.dataStore)复制代码

    希尔排序

    它会首先比较较远的元素而非相邻的元素,让元素尽快回到正确的位置。

    通过定义一个间隔序列来表示在排序过程中进行的元素间隔。

    公开的间隔序列是701,301,132,57,23,10,4,1

    动画演示


    js实现

    var CArray = function () {
      this.dataStore = [99,5,6,8,2,7,3,4,1,23,12,67,43,89]   //定义数组
      this.shellSort = shellSort  //希尔排序
      this.gaps = [5,3,1]  //希尔间隔
      this.dynamiSort = dynamiSort //动态的希尔排序
      this.swap = swap;      //数值交换位置
    }
    function shellSort() {
      for(var g = 0; g < this.gaps.length; ++g) {
        for(var i = this.gaps[g]; i < this.dataStore.length; ++i) {
          var temp = this.dataStore[i]
          for(var j = i; j>=this.gaps[g] && this.dataStore[j - this.gaps[g]] > temp; j-=this.gaps[g]) {
            this.dataStore[j] = this.dataStore[j - this.gaps[g]]
          }
          this.dataStore[j] = temp
        }
        console.log('调换后-》', this.dataStore)
      }
    }
    //动态的希尔排序
    function dynamiSort() {
      var N = this.dataStore.length
      var h = 1
      while(h < N/3) {
        h = h*3+1
      }
      while(h>=1) {
        for(var i = h; i < N; ++i) {
          for(var j = i; j>=h && this.dataStore[j] < this.dataStore[j - h] ; j-=h) {
            console.log(j)
            this.swap(this.dataStore, j,  j-h)
          }
        }
        console.log('调整后-》',this.dataStore)
        h = (h-1) / 3
      }
    }
    function swap(arr, index1, index2) {
      var temp = arr[index1]
      arr[index1] = arr[index2]
      arr[index2] = temp
    }
    var aa= new CArray()
    // aa.shellSort()
     aa.dynamiSort()
    console.log(aa.dataStore)复制代码

    归并排序

    把一系列排好序的子序列合并成为一个大的完整有序序列


    动画演示

                     

    js实现

    // 归并排序
    function mergeSort(arr) {
      var len = arr.length;
      if(len < 2) {
        return arr;
      }
      var middle = Math.floor(len / 2)
       var left = arr.slice(0, middle)
        var right = arr.slice(middle)
      return mergeArray(mergeSort(left), mergeSort(right));
    }
    //融合两个有序数组
    function mergeArray(left, right) {
      var arr = []
      while(left.length && right.length) {
        if(left[0] > right[0]) {
          arr.push(right.shift())
        } else {
          arr.push(left.shift())
        }
      }
      return arr.concat(left, right)
    }
    
    var arr = [2,3,4,12,324,34,5,89,7654,8,9]
    
    console.log(mergeSort(arr))复制代码

    快速排序

    在列表中选择一个元素为基准值,排序围绕这个基准值进行,将列表中小于基准值得放底部,大于的放顶部

    动画演示


    js实现

    // 快速排序
    function qSort(list) {
      if( list.length === 0) return []
      var pivot = list[0]
      var lesser = []
      var greater = []
      for(var i = 1; i < list.length; i++) {
        if(list[i] < pivot) {
          lesser.push(list[i])
        } else {
          greater.push(list[i])
        }
      }
      return qSort(lesser).concat(pivot, qSort(greater))
    }
    
    var arr = [4,3,5,2]
    console.log(qSort(arr))复制代码


    展开全文
  • 本文实例讲述了JavaScript定义及输出螺旋矩阵方法。分享给大家供大家参考,具体如下: 昨晚无意看到这样一个算法题目,然后就想着用js来实现。 昨晚草草写完后感觉代码很丑,很臭,于是今晚又花点时间重构了一下,...
  • Levenshtein算法 Levenshtein算法定义及算法原理见这篇文章:一个快速、高效Levenshtein算法实现 JavaScript实现 function levenshteinDistance(s,t){ if(s.length>t.length){ var temp=s; s=t; ...

    Levenshtein算法

    Levenshtein算法定义及算法原理见这篇文章:一个快速、高效的Levenshtein算法实现

    JavaScript实现

    function levenshteinDistance(s,t){
        if(s.length>t.length){
            var temp=s;
            s=t;
            t=temp;
            delete temp;
        }
        var n=s.length;
        var m=t.length;
        if(m==0){
            return n;
        }
        else if(n==0){
            return m;
        }
        var v0=[];
        for(var i=0;i<=m;i++){
            v0[i]=i;
        }
        var v1=new Array(n+1);
        var cost=0;
        for(var i=1;i<=n;i++){
            if(i>1){
                v0=v1.slice(0);
            }
            v1[0]=i;
            for(var j=1;j<=m;j++){
                if(s[i-1].toLowerCase()==t[j-1].toLowerCase()){
                    cost=0;
                }
                else{
                    cost=1;
                }
                v1[j]=Math.min.call(null,v1[j-1]+1,v0[j]+1,v0[j-1]+cost);
            }
        }
        return v1.pop();
    }
    
    //Test
    levenshteinDistance("gUMBO","GAMBOL");//output 2

    本文转自Artwl博客园博客,原文链接:http://www.cnblogs.com/artwl/,如需转载请自行联系原作者

    展开全文
  • 在本部分将主要学习常用排序和搜索算法: 如:冒泡排序、选择排序、插入排序、归并排序、 快速排序和堆排序等以及:顺序搜索和二分搜索算法。 //1、在开始排序算法之前,先创建一个数组(列表)来表示待排序和搜索...

    前言

    在本部分将主要学习常用的排序和搜索算法: 如:冒泡排序、选择排序、插入排序、归并排序、 快速排序和堆排序等以及:顺序搜索和二分搜索算法。

    //1、在开始排序算法之前,先创建一个数组(列表)来表示待排序和搜索的数据结构。

    function ArrayList() {
        var array = []; //1.1定义一个数组来存放数据
        this.insert = function (item) {  //1.2定义一个插入方法来向数据结构中添加元素
            array.push(item);
        };
        this.toString = function () { //使用js原生的join方法,来拼接数组中的所有元素
            return array.join('-');
        };
     //未改进时的冒泡排序:
        /***
         * 冒泡排序比较任何两个相邻的项,如果第一个比第二个大,则交换它们。
         *  时间复杂度为 O(n^2)
         */
        this.bubbleSort = function () {
            var length = array.length;
            for (var i = 0; i < length; i++) { //控制循环次数
                for (var j = 0; j < length - 1; j++) { //不断比较交换相邻位置的数据
                    if (array[j] > array[j + 1]) {
                        swap(array, j, j + 1);
                    }
                }
            }
        };
        //改进后的冒泡排序
        /**
         *  如果从内循环减去外循环中已经跑过的次数,就可以避免内循环中所有不必要的比较
         * */
        this.modifiedBubbleSort = function () {
            var length = array.length;
            for (var i = 0; i < length; i++) {
                for (var j = 0; j < length - 1 - i; j++) {
                    if (array[j] > array[i]) {
                        swap(j, j + 1);
                    }
                }
            }
        };
    
    
        /**
         * 选择排序:选择排序算法是一种原址比较排序算法。选择排序大致的思路是找到数据结构中最小值并将其放在第一位,
         * 接着找到第二小的值并将其放在第二位,以此类推。
         *  其时间复杂度也为O(n^2)
         *
         * */
        //选择排序算法的源代码:
        this.selectionSort = function () {
            var length = array.length;
            var indexMin;
            for (var i = 0; i < length - 1; i++) {//外循环迭代数组,并控制迭代轮次(数组的第n个值====下一个最小值)
                indexMin = i; //假设本轮迭代的最小值
                for (var j = i; j < length; j++) {
                    //从当前的i值开始至数组结束,比较是否位置j的值比当前最小值小,如果是
                    if (array[indexMin] > array[j]) {
                        indexMin = j;//则改变最小值至新最小值
                    }
                }//当内循环结束,得出数组第n小的值
    
                if (i !== indexMin) {//如果该最小值和原最小值不同,则交换其值
                    [array[i], array[indexMin]] = [array[indexMin], array[i]];
                }
            }
        };
    
        /**
         * 插入排序:插入排序每次排一个整数项,以此构建最后的排序数组。
         *
         * */
        this.insertionSort = function () {
            var length = array.length;
            var j, temp;
            for (var i = 1; i < length; i++) {//迭代数组来给第i项找到正确的位置
                j = i;
                temp = array[i];//用i的值来初始化一个辅助变量并将其值亦存储于--临时变量
                while (j > 0 && array[j - 1] > temp) {//查找正确的位置插入
                    array[j] = array[j - 1];//如果数组中前面的值比待比较的值大,把前面的值移到当前位置,J--
                    j--;
                }
                array[j] = temp;  //直到前面的值部不大于temp时,把temp放入当前的位置中。然后迭代下一项继续排序
            }
        };
    
        /**
         * 归并排序:归并排序是第一个可以被实际使用的算法
         *前面几个算法的性能不好,归并排序不错,其复杂度为
         * 时间复杂度:O(nlog^n)
         * 归并排序是一种分治算法。其思想是将原始数组切分成较小的数组
         * 直到每个小数组只有一个位置,接着小数组归并成较大的数组,直到最后只有一个排序完毕的大数组
         * */
         this.mergeSort = function(){
             array = mergeSortRec(array);
         };
    
    
         /**
          *  快速排序:最常用的算法,它的复杂度为O(nlog^n)
          * (1)首先,从数组中选择中间一项作为主元。
          * (2)创建两个指针,左边一个指向数组第一项,右边一个指向数组最后一项。
          * 移动左指针直到我们找到一个比主元大的元素,接着,移动右指针直到找到一个比主元小的元素。
          * 然后交换它们,重复这个过程,直到左指针超过了右指针。
          * 这个过程使得比主元小的值都排在主元之前,而比主元大的值都排在主元之后
          *(3)接着,算法对划分后的小数组(较主元小的值组成的子数组,以及较主元大的值组成的子数组)
          * 重复之前的两个步骤,直至数组已经完全排序。
          **/
         this.quickSort = function(){
             quick(array, 0, array.length - 1);
         };
    
        //搜索算法
        /**
         *  顺序搜索:顺序或线醒搜索是最基本的搜索算法。它的机制是:
         *  将每一个数据结构中的元素和我们要找的元素做比较。顺序搜索是最低效的
         *  一种搜索算法。
         * */
        this.sequentialSearch = function(item){
            for(var i=0;i<array.length;i++){
                if(item === array[i]){
                    return i;//true或者array[i]
                }
            }
            return -1;
        }
    
        /**
         *  二分搜索:该算法要求被搜索的数据结构已经排序
         *  步骤:
         *  (1)选择数组的中间值
         *  (2)如果选中值是待搜索值,那么算法执行完毕
         *  (3)如果待搜索值比选中值要小,则返回步骤1并在选中值左边的子数组中寻找
         *  (4)如果待搜索值比选中值要大,则返回步骤1并在选中值右边的子数组中寻找
         */
    
        this.binarySeach = function(item){
            this.quickSort();  //在查找之前对数组进行排序
            var low = 0;
            var high = array.length -1;
            var mid,element;
            while(low<= high){
                mid = Math.floor((low + high) /2);
                element = array[mid];
                if(element <item)
                {
                    low = mid +1;
                } else if(element >item){
                    high = mid -1;
                }else{
                    return mid;  //返回的是索引
                }
            }
            return -1;
        };
    
    }
    
       //快速排序划分过程:
        var partition = function(array,left,right){
           var pivot = array[Math.floor((right + left)/2)];//选择中间项作为主元
            var i= left; //初始化为数组第一个元素
            var j = right; //初始化为数组最后一个元素
            while(i<= j){
                while(array[i] < pivot){ //移动指针直到找到一个元素比主元大
                    i++;
                }
                while(array[j] > pivot){ //对于right指针做同样的事,移动找到比主元小的
                    j--;
                }
                if(i<= j){ //当左指针指向的元素比主元大且右指针指向的元素比主元小,且此时左指针索引没有右指针索引大,则交换它们
                    swap(array,i,j);
                    i++;
                    j--;
                }
            }
            return i;
        };
    
          // 声明方法来调用递归函数,传递待排序数组,以及索引0及其最末的位置作为参数。
        var quick = function(array,left,right){
            var index;  //定义该变量,帮助我们将子数组分离为较小的数组和较大的数组
            if(array.length >1){
                index = partition(array,left,right);
                if(left < index -1){
                    quick(array,left,index-1);
                }
                if(index < right){
                    quick(array,index,right);
                }
            }
        };
    
    
    
        //以下为归并排序
       // 实际被执行的辅助函数
        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));
        };
        //定义merge函数,负责合并和排序小数组来产生大数组
        //直到回到原始数组并已经排序完成。
        var merge = function(left,right){
            var result = [];
            var iL = 0;
            var iR = 0;
            while(iL < left.length && ir < right.length) { // {8}
                if (left[iL] < right[iR]) {
                    result.push(left[iL++]); // {9}
                } else {
                    result.push(right[iR++]);
                }
            }
            while(iL <left.length){
                result.push(left[iL++]);
            }
            while(iR <right.length){
                result.push(right[iR++]);
            }
            return result;
        };
    
    
    
        //交换方法
        var swap= function(array,index1,index2){
           /* var aux = array[index1];
             array[index1]= array[index2];
             array[index2]=aux;*/
        //可以利用es6中的方式来交换
           [array[index1],array[index2]]=[array[index2],array[index1]];
       };
    
    
    

    测试:


    
    
    //测试冒泡排序算法
    //定义一个函数自动地创建一个未排序的数组,数组的长度由函数的参数指定
    function createNonSortedArray(size){
        var array = new ArrayList();
        for(var i = size;i>0;i--){
           array.insert(i);
        }
        return array;
    }
    //测试冒泡结果
    var array = createNonSortedArray(5);
    console.log("冒泡排序前:",array.toString());
    array.bubbleSort();
    console.log("冒泡排序后:",array.toString());
    
    //测试选择排序算法
    var selectionArry = createNonSortedArray(5);
    console.log("选择排序前:",selectionArry.toString());
    selectionArry.selectionSort();
    console.log("选择排序后:",selectionArry.toString());
    
    
    //测试插入排序算法
    var  insertArry = createNonSortedArray(5);
    console.log("插入排序前:",insertArry.toString());
    insertArry.selectionSort();
    console.log("插入排序后:",insertArry.toString());
    
    console.log("二分查找后的数据",insertArry.binarySeach(3));

    执行结果

    展开全文
  • 1. 栈的定义 栈(stack)又名堆栈,它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶,相对地,把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈,它是把新元素放...

    1. 栈的定义

    栈(stack)又名堆栈,它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶,相对地,把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈,它是把新元素放到栈顶元素的上面,使之成为新的栈顶元素;从一个栈删除元素又称作出栈或退栈,它是把栈顶元素删除掉,使其相邻的元素成为新的栈顶元素。
    在这里插入图片描述

    2. 上代码

    function Stack() {
    	var	items	= [];		//	使⽤数组存储数据
    	//	push⽅法向栈⾥压⼊⼀个元素
    	this.push = function(item){
    		items.push(item);
    	};
    	//	pop⽅法把栈顶的元素弹出
    	this.pop = function(){
    		return	items.pop();
    	};
    	//	top	⽅法返回栈顶元素
    	this.top = function(){
    					return	items[items.length	- 1];
    	};
    	//	isEmpty返回栈是否为空
    	this.isEmpty = function(){
    					return	items.length	== 0;
    	};
    	//	size⽅法返回栈的⼤⼩
    	this.size = function(){
    					return	items.length;
    	};
    	//	clear	清空栈
    	this.clear = function(){
    					items	= []
    	}
    }
    

    3 练习题 盗用习题

    注: 练习题自找哈

    1. 下方字符串中包含小括号,请编写一个函数判断字符串中的括号是否合法,所谓合法就是小括号成对出现
    sdf(ds(ew(we)rw)rwqq)qwewe			合法
    (sd(qwqw)sd(sd))	合法
    ()()sd()(sd()fw))(	不合法
    

    解题代码:

    function is_leagl_brackets(string){
    	var	stack	= new Stack();
    	for(var	i=0;i<string.length;i++ ){
    		var	item = string[i];
    		if(item	== "("){
    			//	将左括号压⼊栈
    			stack.push(item);
    		}else if (item==")"){
    			//	如果为空,就说明没有左括号与之抵消
    			if(stack.isEmpty()){
    				return false;
    			}else{
    				//	将栈顶的元素弹出
    				stack.pop();
    			}
    		}
    	}
    	return	stack.size() == 0;
    };
    console.log(is_leagl_brackets("()()))"));
    console.log(is_leagl_brackets("sdf(ds(ew(we)rw)rwqq)qwewe"));
    console.log(is_leagl_brackets("()()sd()(sd()fw))("));
    
    展开全文
  • 阶乘之算法

    2013-02-13 13:42:00
    一、定义阶乘Factorial:一个正整数阶乘是所有小于等于该数正整数积,并且有0阶乘为1,自然数n阶乘写作n!二、算法思想0阶乘是1;任何数阶乘都是此数乘以比此数小1阶乘。三、具体实现 1、非...
  • app中rem算法

    2017-07-24 09:56:00
    下面贴出 rem 的算法及使用方法 在自定义js中定义函数 export default { install: function(Vue, options) { Vue.fontSize = function(){ (function(doc, win) { var docEl = doc.documentElemen...
  • 一、二叉树算法及代码实现1、Javascript和数据结构程序=算法+数据结构单步调试:2、二叉树定义的原理说明排序二叉树:左孩子值小于父亲结点值,右孩子值大于父亲结点值。代码实现:&lt;script&gt; ...
  • 一、数组 什么是数组 ... //定义了一个不包含元素数组 var arr2=[11,12,13]; //定义了一个包含三个元素数组 var arr3=new Array(2); //定义了一个包含两个元素哦数组,下标为0,1 ...
  • 一、数组 什么是数组 程序=数据+算法 ... //定义了一个不包含元素数组 var arr2=[11,12,13]; //定义了一个包含三个元素数组 var arr3=new Array(2); //定义了一个包含两个元素哦数组,下标为0,1 ...
  • 首先先看看普通病毒的定义及特点: 普通病毒的特点暂定为随处游走,那我们就得就得为他创造一个随机点算法: /// <summary> /// 得到一个随机位置 /// </summary> /// <returns></returns>...
  • 2.补充知识:variant数据是一种特殊数据类型,除了定长string数据用户定义类型外,可以包含任何种类数据。使用vartype函数或者typename函数来决定如何处理variant中数据。二、冒泡排序法1.定义变量时如...
  • 2.补充知识:variant数据是一种特殊数据类型,除了定长string数据用户定义类型外,可以包含任何种类数据。使用vartype函数或者typename函数来决定如何处理variant中数据。二、冒泡排序法1.定义变量时如...
  • 为保证存储于区块链中的信息的安全与完整,区块区块链的定义和构造中使用了包含密码哈希函数和椭圆曲线公钥密码技术在内的大量的现代密码学技术,同时,这些密码学技术也被用于设计基于工作量证明的共识算法并识别...
  • (IE,IP) 针对 AT89C52 单片机,头文件 AT89x52.h 给出了 SFR 特殊功能寄存器所有端口的定义。 C 语言编程基础: 1. 2. 3. 4. 十六进制表示字节 0x5a:二进制为 01011010B;0x6E 为 01101110。 如果将一个 16 位二...
  • swift数据结构:链表

    2019-05-11 12:55:41
    swift实现链表链表相关特性,最后附上两道算法题 一、链表基本操作实现 1、定义链表节点 class ListNode{ var val : Int! var next : ListNode! init(_ val : Int) { self.val = val self.next = ...
  • 但是你需要知道是在es5更低版本js里,无法完美继承数组</strong>,主要原因是Array.call(this)时,Array根本不是像一般构造函数那样对你传进去this进行改造,而是直接返回一个新...
  • scala

    2019-11-12 20:58:15
    scala数据结构常用操作 一、数组 定义:定长:new Array 变长:new ArrayBuffer 遍历:for(i <- array) println(i) array.foreach(println(_)) 转换:map更好用 filter过滤 常用算法:arr.sum arr.max arr....
  • 《数据结构 1800题》

    热门讨论 2012-12-27 16:52:03
    5.抽象数据类型的定义仅取决于它的一组__(1)_,而与_(2)_无关,即不论其内部结构如何变化,只要它的_(3)_不变,都不影响其外部使用。【山东大学 2001 三、3(2分)】 6.数据结构中评价算法的两个重要指标是...
  • delphi 开发经验技巧宝典源码

    热门讨论 2010-08-12 16:47:23
    0038 强类型的定义及使用 25 2.2 类、函数、重载 25 0039 在函数的定义中正确使用var 25 0040 如何实现类的转形 26 0041 如何实现数据加密与解密算法 27 0042 如何继承父类的方法 27 0043 如何实现函数...
  • 0038 强类型的定义及使用 25 2.2 类、函数、重载 25 0039 在函数的定义中正确使用var 25 0040 如何实现类的转形 26 0041 如何实现数据加密与解密算法 27 0042 如何继承父类的方法 27 0043 如何实现函数...
  • 0038 强类型的定义及使用 25 2.2 类、函数、重载 25 0039 在函数的定义中正确使用var 25 0040 如何实现类的转形 26 0041 如何实现数据加密与解密算法 27 0042 如何继承父类的方法 27 0043 如何实现函数...
  • 0038 强类型的定义及使用 25 2.2 类、函数、重载 25 0039 在函数的定义中正确使用var 25 0040 如何实现类的转形 26 0041 如何实现数据加密与解密算法 27 0042 如何继承父类的方法 27 0043 如何实现函数...
  • 0038 强类型的定义及使用 25 2.2 类、函数、重载 25 0039 在函数的定义中正确使用var 25 0040 如何实现类的转形 26 0041 如何实现数据加密与解密算法 27 0042 如何继承父类的方法 27 0043 如何实现函数...
  • 0038 强类型的定义及使用 25 2.2 类、函数、重载 25 0039 在函数的定义中正确使用var 25 0040 如何实现类的转形 26 0041 如何实现数据加密与解密算法 27 0042 如何继承父类的方法 27 0043 如何实现函数...
  • 实例029 经典算法之歌德巴赫猜想的算法 55 实例030 经典问题之约瑟夫环问题(使用数组解决) 57 实例031 数组与算法之冒泡排序 58 实例032 冒泡排序改进——快速排序算法 60 实例033 较高级数组与算法——二分法...

空空如也

空空如也

1 2 3
收藏数 42
精华内容 16
关键字:

var的定义及算法