JavaScript 算法基础练习

 

 

 

// 1.生成数据，后一个数是前两个的和
// function fibonacci(n){
//     const fib=[0,1]
//     for(let i=2;i<n;i++){
//         fib[i]=fib[i-1]+fib[i-2]
//     }
//     return fib
// }

// console.log(fibonacci(3))



// 2.数的阶乘
// function fibonacci(n){
//     let result=1
//     for(let i=2;i<=n;i++){
//         result=result *i
//     }
//     return result
// }

// console.log(fibonacci(3))


// 3.4一样的,二的幂
// function isPowerOfTwo(n){
//     if(n<1){
//         return false
//     }
//     while(n>1){
//         if(n%2 !==0){
//             return false
//         }
//         n=n/2
//     }
//     return true
// }
// console.log(isPowerOfTwo(1)) //true



// 3.4
// function isPowerOfTwoBitWise(n){
//     if(n<1){
//         return false
//     }
//     return (n & (n-1))===0
// }
// console.log(isPowerOfTwoBitWise(1)) //true




// 5.递归斐波那契序列
// function recursiveFibonacci(n){
//     if(n<2){
//         return n
//     }
//     return recursiveFibonacci(n-1) + recursiveFibonacci(n-2)
// }

// console.log(recursiveFibonacci(0))
// console.log(recursiveFibonacci(1))
// console.log(recursiveFibonacci(2))
// console.log(recursiveFibonacci(3))
// console.log(recursiveFibonacci(4))
// console.log(recursiveFibonacci(5))
// console.log(recursiveFibonacci(6))
// console.log(recursiveFibonacci(7))
// console.log(recursiveFibonacci(8))


// 6.递归整数的阶乘
// function recursiveFibonacci(n){
//     if(n===0){
//         return 1
//     }
//     return n*recursiveFibonacci(n-1)
// }
// console.log(recursiveFibonacci(0))//1
// console.log(recursiveFibonacci(1))//1
// console.log(recursiveFibonacci(5))//120
//Big-O O(n)



// 7.搜索算法
// function linearSearch(arr,target){
//     for(let i=0;i<arr.length;i++){
//         if(arr[i]===target){
//             return i
//         }
//     }
//     return -1
// }

// console.log(linearSearch([-5,2,10,4,6],10))//2


// 8.二分查找法
// function BinarySearch(arr,target){
//     let leftIndex=0
//     let rightIndex=arr.length -1

//     while(leftIndex <= rightIndex){
//         let middleIndex=Math.floor((leftIndex + rightIndex) /2) 
//         if(target===arr[middleIndex]){
//             return middleIndex
//         }
//         if(target < arr[middleIndex]){
//             rightIndex = middleIndex -1
//         }else{
//             leftIndex = middleIndex+1
//         }
//     }
//     return -1
// }
// console.log(BinarySearch([-5,2,4,6,10],10))//4



// 9.递归二分查找法   Big-O O(logn)
// function recursiveBinarySearch(arr,target){
//     return search(arr,target,0,arr.length)
// }
// function search(arr,target,leftIndex,rightIndex){
//     if(leftIndex > rightIndex){
//         return -1
//     }

//     let middleIndex = Math.floor((leftIndex + rightIndex) /2)
//     if(target === arr[middleIndex]){
//         return middleIndex
//     }

//     if(target < arr[middleIndex]){
//         return search(arr,target,leftIndex,middleIndex-1)
//     }else{
//         return search(arr,target,middleIndex+1,rightIndex)
//     }
// }
// console.log(recursiveBinarySearch([-5,2,4,6,10],10))//4



// 10.数组排序（冒泡排序） (O^2)
// function bubbleSort(arr){
//     let swapped
//     do{
//         swapped=false
//         for(let i=0;i<arr.length-1;i++){
//             if(arr[i]>arr[i+1]){
//                 let temp = arr[i]
//                 arr[i]=arr[i+1]
//                 arr[i+1]=temp
//                 swapped=true
//             }
//         }
//     }while(swapped)
// }

// const arr=[0,20,-2,4,-6]
// bubbleSort(arr)
// console.log(arr)//[-6,-2,4,8,20]




//11.插入排序 O（n^2）
// function insertionSort(arr){
//     for(let i=0;i<arr.length;i++){
//         let numberToInsert=arr[i]
//         let j=i-1;
//         while(j>=0 && arr[j] > numberToInsert){
//             arr[j+1]=arr[j]
//             j=j-1
//         }
//         arr[j+1]=numberToInsert
//     }
// }

// const arr=[8,20,22,-2,4,-6]
// insertionSort(arr)
// console.log(arr)//[-6,-2,4,8,20]



//12.快速排序  Worst case O(n^2),Avg case - O(nlogn)
// function quickSort(arr){
//     if(arr.length<2){
//         return arr
//     }
//  let pivot=arr[arr.length-1]
//  let left=[]
//  let right = []
//  for(let i =0; i <arr.length-1;i++){
//     if(arr[i]<pivot){
//         left.push(arr[i])
//     }else{
//         right.push(arr[i])
//     }
//  }
//  return [...quickSort(left),pivot,...quickSort(right)]
    
// }
// const arr=[8,20,22,-2,4,-6,1]
// console.log(quickSort(arr))//[-6,-2,4,8,20]



// 13. 合并排序   O（nlogn）
// function mergeSort(arr){
//     if(arr.length<2){
//         return arr
//     }
//     const mid=Math.floor(arr.length / 2)
//     const leftArr=arr.slice(0,mid)
//     const rightArr=arr.slice(mid)
//     return merge(mergeSort(leftArr),mergeSort(rightArr))
// }
// function merge(lertArr,rightArr){
//     const sortedArr=[]
//     while(lertArr.length && rightArr.length){
//         if(lertArr[0] <= rightArr[0]){
//             sortedArr.push(lertArr.shift())
//         }else{
//             sortedArr.push(rightArr.shift())
//         }
//     }
//     return [...sortedArr,...lertArr,...rightArr]
// }
// const arr=[8,20,-2,4,-6]
// console.log(mergeSort(arr))//[-6,-2,4,8,20]



// 14.笛卡尔求积  O(mn)
// function cartesianProduct(arr1,arr2){
//     const result = []
//     for(let i=0;i<arr1.length;i++){
//         for(let j=0;j<arr2.length;j++){
//             result.push([arr1[i],arr2[j]])
//         }
//     }
//     return result
// }

// const arr1=[1,2]
// const arr2=[3,4,5]
// console.log(cartesianProduct(arr1,arr2))//[ [ 1, 3 ], [ 1, 4 ], [ 1, 5 ], [ 2, 3 ], [ 2, 4 ], [ 2, 5 ] ]