arr

day1: 1.主流浏览器及其内核 IE Trident chorme Webkit,Blink safari Webkit firfox Gecko opera Presto 2.在js中，任意数据类型 + 字符串都 = 字符串 day2: 1.substring() & slice():前者是截取string中某一部分，后者是截取array中的某一部分 2.indexof():用于判断string或array中某个元素是否存在，若存在，返回该元素下标，若不存在返回-1。indexof总是返回第一个元素的下标位置！ 3.push() & pop():前者用于向array末尾添加元素，后者用于删除array末尾元素 4.unshift() & shift:前者用于向array头部添加元素，后者用于删除array头部元素 5.sort() & reverse():按照默认排序、倒序 6. splice() 方法是修改 Array 的“万能方法”，它可以从指定的索引开始删除若干元素，然后再从该位置添加若干元素 var arr = ['Microsoft', 'Apple', 'Yahoo', 'AOL', 'Excite', 'Oracle']; // 从索引2开始删除3个元素,然后再添加两个元素: arr.splice(2, 3, 'Google', 'Facebook'); //

测试例子： # include < stdio . h > void print ( char * arr ) { printf ( "%#x %#x %#x\n" , & arr , arr , arr [ 0 ] ) ; } int main ( ) { char arr [ 5 ] = "abcd" ; printf ( "%#x %#x %#x\n" , & arr , arr , arr [ 0 ] ) ; print ( arr ) ; return 0 ; } 输出： 0xbf849b8b 0xbf849b8b 0x61 0xbf849b70 0xbf849b8b 0x61 对于第2，3个输出，很多人都能理解，但对第1个输出为什么不同，很多人还没有理解，认为是函数指针作为参数，进行地址传递，&arr也应该是一样的，这样想是因为对函数参数传递的实质还没有认识清楚。 不论是指传递还是地址传递，机制都是一样的，形参接收到实参传递过来的值进行使用。 当为值传递时： 实参a ----> 形参b： b接受了a值，对b的修改，不会影响到a。 当为地址传递时： 实参*a ---> 形参*b： b接受了a的值，此时a，b两个指针变量指向同一内存单元。对b的修改，不会影响到a，但对b指向的内存单元的修改，会导致a指向的内存单元也发生变化（因二者指向同一个内存单元）。 地址传递误区：

3 月，跳不动了？>>> 1、思路 对每一对相邻的元素进行比较，比如第一个元素和第二个元素比较，若第一个大，则交换；然后第二个元素和第三次元素比较.......每次比较最大的元素都会放到后面。从而达到排序效果。 2、时间复杂度 最好 O(n) ，最坏 O(n^2) ，平均 O(n^2) 3、代码实现 public class BubbleSort { public static void bubbleSort(int[] arr){ if(arr.length == 0 ||arr == null) return; int n = arr.length; for(int i=0;i<n;i++){ for(int j=0;j<n-i-1;j++){ if(arr[j+1] < arr[j]){ int temp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = temp; } } } } public static void main(String[] args){ int[] arr = {50,10,90,30,70,40,80,60,20}; bubbleSort(arr); for(int a:arr){ System.out.printf(a + " "); } } } 来源： oschina 链接： https://my.oschina

3 月，跳不动了？>>> 1、思想 也是分治思想，利用递归和分治技术将数据序列划分为越来越小的半子集，对半子集排序，再用递归方法将排好序的半子集合并为大的有序序列。 2、时间复杂度 最好 O(nlogn) ，最坏 O(nlogn)，平均O(nlogn)。 3、代码实现 public class mergeSort { public static void MergeSort(int[] arr){ Sort(arr, 0, arr.length-1); } private static void Sort(int[] arr, int left, int right) { if(left < right){ int mid = (left + right)/2; Sort(arr, left, mid); Sort(arr, mid+1,right); Merge(arr, left, mid, right); } } private static void Merge(int[] arr, int left, int mid, int right) { int[] temparr = new int[arr.length]; int thrif = left; int center = mid+1; int temp = left; while (left <= mid &&

3 月，跳不动了？>>> 1、思想 每次选出一个基准，然后将数组剩下的元素分为两部分，一部分小于基准放到左边，一部分大于基准放到右边。然后对基准左右两部分分别做同样处理，分治思想。 2、时间复杂度 最快 O(nlogn) ，最坏 O (n^2) ，平均 O(nlogn) 。 3、代码实现 //常规版 public class quickSort { public static void QuickSort(int[] arr){ QSort(arr, 0, arr.length-1); } private static void QSort(int[] arr, int low, int hight) { int pivot; if(low < hight){ pivot = Partition(arr, low, hight); QSort(arr, low, pivot-1); QSort(arr, pivot+1, hight); } } private static int Partition(int[] arr, int low, int hight) { if(arr == null || low < 0 || hight >= arr.length){ new Exception(); } int pivotkey = arr[low]; while(low <

栈是一种遵从后进先出（LIFO）原则的有序集合。新添加的或待删除的元素都保存在栈的同一端，称作栈顶，另一端就叫栈底。在栈里，新元素都靠近栈顶，旧元素都接近栈底。栈就好像是一个底部密封的盒子，我们往里面放东西，最先放进去的东西只能再最上面的东西都取出来之后才能取出，也就是所谓的先进后出。 一、采用构造函数法创建栈 function Stack(){ let items = []; //需要一种数据结构来保存栈里的元素，可以采用数组。 this.push = function (value){//向栈里添加数据 items.push(value); }; this.pop = function(value){//向栈里删除数据 items.pop(value); }; this.peek = function(){//查看栈顶元素 return items[items.length - 1] }; this.isEmpty = function(){ //检查栈是否为空 return items.length == 0; }; this.size = function(){ //查看栈内元素个数 return items.length; }; this.clear = function(){ //清空栈 items = []; }; this.print = function(){ /

arguments的用法 1 function sum(){ 2 var result = 0; 3 for(var i=0;i<arguments.length;i++) 4 { 5 result += argument[i]; 6 } 7 return result; 8 } 9 alert(sum(2,3,4)); //10 数组的定义 var a = [1,2,3] 或者 var a = new Array(1,2,3); 数组的属性 -length 既可以获取，也可以设置 var arr = [0,1,2,3] arr.length = 3 ; alert(arr); //0,1,2 数组的添加和删除 -push 在数组末尾添加一个元素 var arr = [0,1,2]; arr.push(3); alert(arr); //0,1,2,3 -pop 在数组末尾删除一个元素 var arr = [0,1,2]; arr.pop(); alert(arr); //0,1 -shift 在数组头部删除一个元素 var arr = [0,1,2]; arr.shift(); alert(arr); //1,2 -unshift 在数组头部添加一个元素 var arr = [0,1,2]; arr.unshift(3); alert(arr); //3,0,1,2

相关代码 二分法查找 //二分查找(折半查找) //要求数组是个有序数组 public class BinarySearch { public static void main(String[] args) { int[] arr={1,2,5,7,8,9,10,10,18,20}; int left=0; int right=arr.length-1; int res=binarySearch(arr, 10,right,left); if(res==-1){ System.out.println("没找到!"); }else{ System.out.println("找到了，下标是"+res); } } public static int binarySearch(int[] arr,int value,int right,int left){ if(right return -1; } int mid=(right+left)/2; if(arr[mid]>value){ return binarySearch(arr,value,mid-1,left); }else if(arr[mid] return binarySearch(arr,value,right,mid+1); }else{ return mid; } } } 这个数组第6位是10，第7位也是10

相关代码 二分法查找 //二分查找(折半查找) //要求数组是个有序数组 public class BinarySearch { public static void main(String[] args) { int[] arr={1,2,5,7,8,9,10,10,18,20}; int left=0; int right=arr.length-1; int res=binarySearch(arr, 10,right,left); if(res==-1){ System.out.println("没找到!"); }else{ System.out.println("找到了，下标是"+res); } } public static int binarySearch(int[] arr,int value,int right,int left){ if(right return -1; } int mid=(right+left)/2; if(arr[mid]>value){ return binarySearch(arr,value,mid-1,left); }else if(arr[mid] return binarySearch(arr,value,right,mid+1); }else{ return mid; } } } 这个数组第6位是10，第7位也是10

3 月，跳不动了？>>> 如何将 std::vector<double> 转换为 double array[] ？ #1楼 vector<double> thevector; //... double *thearray = &thevector[0]; 按照标准可以保证可以使用此 thearray ，但是有一些警告：特别要注意，只有在 thevector 处于范围内时才使用 thearray 。 #2楼 有一个相当简单的技巧，因为此规范现在 保证 向量可以连续存储其元素： std::vector<double> v; double* a = &v[0]; #3楼 向量实际上是皮肤下的数组。 如果具有功能： void f( double a[]); 您可以这样称呼它： vector <double> v; v.push_back( 1.23 ) f( &v[0] ); 您永远不需要将向量转换为实际的数组实例。 #4楼 做什么的？ 您需要澄清：您是否需要指向数组第一个元素或数组的指针？ 如果要调用期望使用前者的API函数，则可以执行 do_something(&v[0], v.size()) ，其中 v 是 double s的向量。 向量的元素是连续的。 否则，您只需要复制每个元素： double arr[100]; std::copy(v.begin(), v.end(), arr