写在前面：
本人自学前端不久，博客的【学习笔记】既不算原创也不算转载，都是自己通过各个网站、博客、书籍、视频课程等学习的笔记，以及做的一些测试。
下面的代码是在sublime text3上编辑在nodejs上运行过的。
//利用object对数组去重
var a=[1,2,3,4],
b=[3,4,5,6],
c=a.concat(b),
obj={},
arr=[];
c.map(function(item){
obj[item]=null;
})
for(var key in obj){
arr.push(Number(key));
}
console.log(arr);//[ 1, 2, 3, 4, 5, 6 ]
console.log('--------------------------------');//在数组中间添加数组
var nums = [1,2,3,4,5,6,7];
var newElements = ['a',100];
nums.splice(Math.floor(nums.length / 2),0,newElements);
console.log(nums);//[ 1, 2, 3, [ 'a', 100 ], 4, 5, 6, 7 ]
var nums = [1,2,3,4,5,6,7];
nums.splice(Math.floor(nums.length / 2),0,'a',100);
console.log(nums);//[ 1, 2, 3, 'a', 100, 4, 5, 6, 7 ]
var nums = [1,2,3,4,5,6,7];
var newElements = ['a',100];
nums.splice.apply(nums, [Math.floor(nums.length)/2, 0].concat(newElements))
console.log(nums);//[ 1, 2, 3, 'a', 100, 4, 5, 6, 7 ]
console.log('--------------------------------');
//找出给定字符串中出现次数最多的字母
function findMaxChar(str){
if(str.length<=1){
return str;
}
var obj={},char,count=1;
for (var i = 0; i < str.length; i++) {
if(!obj[str.charAt(i)]){
obj[str.charAt(i)]=1;
}else{
obj[str.charAt(i)]+=1;
}
}
for(var key in obj){
if(obj[key]>=count){
count=obj[key];
char=key;
}
}
return char;
}
console.log(findMaxChar('fafdfdfaaakkkkkkkkklepoepwkkk'));//k
console.log('--------------------------------');//杨辉三角
var row=8,
array=new Array();//[]
for (var i = 0; i < row; i++) {
var arrays=[];
for (var j = 0; j < i+1; j++) {
if(i==0||j==0||j==i){
arrays.push(1);
}else{
arrays.push(array[i-1][j-1]+array[i-1][j]);
}
}
console.log(arrays);
array.push(arrays);
}
/**
[ 1 ]
[ 1, 1 ]
[ 1, 2, 1 ]
[ 1, 3, 3, 1 ]
[ 1, 4, 6, 4, 1 ]
[ 1, 5, 10, 10, 5, 1 ]
[ 1, 6, 15, 20, 15, 6, 1 ]
[ 1, 7, 21, 35, 35, 21, 7, 1 ]
*/
console.log('--------------------------------');
//二分算法
//只能对已排好序的数组进行查找
var arr=[0,1,2,35,46,57,68,79];
function getIndex(array,value){
var a=0,b=array.length-1;
while(a<=b){
var m=Math.floor((a+b)/2);
if(value==array[m]){
return m;
}else if(value>array[m]){
a=m+1;
}else{
b=m-1;
}
}
return -1;//没有找到元素返回-1
}
console.log(getIndex(arr,68));//6
console.log(getIndex(arr,11));//-1
console.log('--------------------------------');var arr=[324,42,3,-5,27,99,0];
console.log(arr.sort(function(a,b){return a-b;}));//[ -5, 0, 3, 27, 42, 99, 324 ]
console.log(arr);//[ -5, 0, 3, 27, 42, 99, 324 ] sort改变原数组
console.log(arr.sort(function(a,b){return b-a;}));//[ 324, 99, 42, 27, 3, 0, -5 ]
console.log('--------------------------------');
//冒泡排序
//时间复杂度O(n^2)，是稳定的算法
//稳定的含义是：稳定排序算法会让原本有相等键值的纪录维持相对次序
//
//从小到大排：（从大到小换成把小的往后扔就可以了）
//依次比较相邻元素，保证较大的在后面
//一次遍历后，最大的数在最后面
//除去已扔到最后面的最大的数，对前面的元素重复上述步骤
//每次遍历后，需要比较的数少一个，重复直到没有元素可以比较
function bubbleSort(array){
if(array.length<=1){
return array;
}
for (var i = 0; i < array.length; i++) {
for (var j = 0; j < array.length-1-i; j++) {
if(array[j]>array[j+1]){
var temp = array[j+1];
array[j+1] = array[j];
array[j] = temp;
}
}
}
return array;
}
var arr=[324,42,3,-5,27,99,0];
console.log('bubbleSort: '+bubbleSort(arr));//bubbleSort: -5,0,3,27,42,99,324
console.log('--------------------------------');
//快速排序：
//时间复杂度 O（nlogn），不稳定的排序
//
//通过与一个中介元素比较，将要排序的数据分割成独立的3部分，
//一部分所有数据都比中介小，另外一部分的所有数据都比中介大，中介自成一部分，
//对非中介的两部分重复上述步骤，每次结束将三部分按顺序连接，
//直到整个数组变成有序序列
function quickSort(array){
if(array.length<=1){
return array;
}
var m=array.splice(Math.floor(array.length/2),1)[0];
var left=[],right=[];
for (var i = 0; i < array.length; i++) {
if(array[i]<m){
left.push(array[i]);
}else{
right.push(array[i]);
}
}
return quickSort(left).concat(m,quickSort(right));
}
var nums = [324,42,3,-5,27,99,0];
console.log('quickSort: '+quickSort(nums));//quickSort: -5,0,3,27,42,99,324
console.log('--------------------------------');
//选择排序
//O(n^2),不稳定
//每次遍历找到最小的数，从前往后放
function selectionSort(array){
if(array.length<=1){
return array;
}
for (var i = 0; i < array.length; i++) {
var index=i;
for(var j=i+1;j<array.length;j++){
//找到最小数的下标赋值给index
if(array[j]<array[index])
index=j;
}
var temp=array[i];
array[i]=array[index];
array[index]=temp;
}
return array;
}
var arr=[324,42,3,-5,27,99,0];
console.log('selectionSort: '+selectionSort(arr));//selectionSort: -5,0,3,27,42,99,324
console.log('--------------------------------');
//插入排序
//O(n^2),稳定
//把数组分为已排序和未排序两个部分
//对未排序数据在已排序序列中从后向前扫描插入
function insertionSort(arr){
if(arr.length<=1){
return arr;
}
for (var i = 1; i < arr.length; i++) {
//已排序序列中只有arr[0]
var temp=arr[i];//保存待插入数据
for(var j=i-1;j>=0 && arr[j]>temp;j--){
//在已排序序列中从后往前扫面，遇见比待排序数据大的则逐个往后移
arr[j+1]=arr[j];
}
arr[j+1]=temp;
}
return arr;
}
var arr=[324,42,3,-5,27,99,0]
console.log('insertionSort: '+insertionSort(arr));//insertionSort: -5,0,3,27,42,99,324
console.log('--------------------------------');
//希尔排序(增量排序)
//复杂度O(nlog2n)，不稳定
//由多次插入排序完成
//根据指定步长对元素进行分组
//如步长为3时，11个元素的数组分组结果为：
//\0 3 6 9 \ 1 4 7 10 \ 2 5 8 \
//减少步长直到1，进行最后一次插入排序
function shellSort(arr){
if(arr.length<=1){
return arr;
}
var gap=Math.floor(arr.length/2);
for(;gap>0;gap=Math.floor(gap/2)){
for (var i = 0; i < gap; i++) {
//分组进行插入排序
for (var j = i; j < arr.length; j+=gap) {
var temp=arr[j];
for(var k=j-1;k>=0 && arr[k]>temp;k--){
arr[k+1]=arr[k];
}
arr[k+1]=temp;
}
}
}
return arr;
}
var arr=[324,42,3,-5,27,99,0]
console.log('shellSort: '+shellSort(arr));//shellSort: -5,0,3,27,42,99,324
console.log('--------------------------------');
//归并排序
//O(nlogn)，稳定
//建立在归并操作上
function merge(arr1,arr2){
var temp=[],i=0,j=0;
while(i<arr1.length && j<arr2.length){
if(arr1[i]<=arr2[j]){
temp.push(arr1[i]);
i++;
}else{
temp.push(arr2[j]);
j++;
}
}//end while
return temp.concat(arr1.slice(i)).concat(arr2.slice(j));
}
function mergeSort(arr){
if(arr.length<=1){
return arr;
}
var m=Math.floor(arr.length/2);
var arr1=arr.slice(0, m);
var arr2=arr.slice(m);
return merge(mergeSort(arr1), mergeSort(arr2));
}
var arr=[324,42,3,-5,27,99,0]
console.log('mergeSort: '+mergeSort(arr));//mergeSort: -5,0,3,27,42,99,324
console.log('--------------------------------');