导航:首页 > 编程语言 > 01算法javascript

01算法javascript

发布时间:2024-10-01 06:01:28

① 几种常见的排序算法及javaScript实现

前言

在学习数据结构和排序算法过程中,会发现原理和思路都十分简洁和清晰,难度在于用如何用代码将过程表达出来,而这就是程序员内功的修炼了。

在学习过程中非常喜欢一句话:“好的算法就是一本好的食谱,只要按照食谱的步骤进行,小白也能做出美味的烹饪,而学习前人的经典算法,即使没有多高的天分,也能帮助你解决很多问题。”

1.选择排序

选择排序是最容易理解的一种排序算法。

1.1算法原理

遍历数据,把数据中的最大值(或者最小值)与起始(或者末尾)数据进行交换。

1.2算法思路

1.从“待排序数据”中找到最小值。

2.把最小值和“待排序数据起止位置的元素”交换。

3.“待排序数据”的起始位置向后移动一位。

4.循环操作1~3,直至“待排序部分”只剩下一个元素。

下图展示了用选择排序算法的过程。

1.3代码实现let?selectSort?=?(array)?=>?{??for?(let?i?=?0;?i?<?array.length-1;?i++)?{????let?min?=?array[i];//先找到起始值????for(let?j?=?i+1;j<?array.length;j++){??????if(min>?array[j]){//再次循环找到最小值????????let?temp?=?min;//使用临时变量交换最小值和起始值????????min?=?array[j];????????array[j]?=?temp;??????}????}????array[i]?=?min//将最小值放到数组最前面????}??return?array;}let?testArray?=?[35,80,21,54,11,45,92,39];console.log(selectSort(testArray));

测试结果:

1.4算法效率

选择排序的简单和直观名副其实,这也造就了它出了名的慢性子,无论是哪种情况,哪怕原数组已排序完成,它也将花费将近n?/2次遍历来确认一遍。唯一值得高兴的是,它并不耗费额外的内存空间。

平均时间复杂度最好情况最坏情况空间复杂度O(n2)O(n2)O(n2)O(1)2.冒泡排序2.1算法原理

比较相邻的两个元素的大小关系,如果大小关系和排序顺序是相反的,则交换这两个元素的位置。

2.2算法思路

1.“待排序数据”的第1个数据和第2个数据相互比较。

2.如果第1个数据>第2个数据,那么交换两个数据的位置。

3.进行比较的数据位置向后移动一位。

4.直到比较到最后2个数据,那么末尾的数据就是最大值。

5.在“待排序数据”里面除去末尾的最大值,在新的“待排序数据”继续上述操作。

下图展示了进行冒泡排序的过程:

2.3代码实现let?bubbleSort?=?(array)?=>?{??for?(let?i?=?0;?i?<array.length-1?;?i++)?{//最后一个数字不用遍历?????for?(let?j?=?0;?j?<?array.length-1-i;?j++)?{//每次比较,都要去除末尾已经排好序的值,所以要-i????????if?(array[j]>array[j+1]){//找到较小值,交换位置??????????let?temp?=?array[j];??????????array[j]?=?array[j+1];??????????array[j+1]?=?temp;????????}????}??}??return?array;}let?testArray?=?[35,80,21,54,11,45,92,39];console.log(bubbleSort(testArray));

测试结果:

2.4算法效率

冒泡排序是稳定的排序算法,最容易实现的排序,最坏的情况是每次都需要交换,共需遍历并交换将近n?/2次,时间复杂度为O(n?).最佳的情况是内循环遍历一次后发现排序是对的,因此退出循环,时间复杂度为O(n).平均来讲,时间复杂度为O(n?).由于冒泡排序中只有缓存的temp变量需要内存空间,因此空间复杂度为常量O(1)平均时间复杂度|最好情况|最坏情况?|空间复杂度||-------|----|-----|-----||O(n2)?|O(n)|O(n2)|O(1)

3.插入排序3.1算法原理

假设一组数据列(D0,D1,D2...,Dn)中的某个数据Di之前的数据列(D0~Di-1)是已经排好序的,那么把Di按照大小关系插入到已经排好序的数据列中,按此方法一直操作到最后一个数据,就可以完成排序。

3.2算法思路

在开始处理之前,可以认为“已排序部分”只包括数组的起始元素,而“待排序部分”包含第二个元素及其以后的所有元素。排序过程如下:

1.第一个元素被认为已经排好序

2.找到下一个元素,与前面已排序的元素进行对比

3.如果已排序的元素大于待排序元素,将已排序元素后移

4.重复步骤3,直到找到已排序元素小于或者等于待排序元素的位置

5.把待排序元素插入到该位置

6.重复步骤2到5直到最后一个元素。

3.3实现代码let??insertSort?=?(array)?=>?{??for?(let?i?=?1;?i?<?array.length;?i++)?{//从第二个元素开始循环????let?temp?=?array[i];//把待排序的元素放在临时变量里,因为后移操作会覆盖掉待排序元素????let?j?=?i-1;//往前找已经排好序的元素????while(j>=0?&&?array[j]?>?temp){//j<0,会导致找不到数组元素??????array[j+1]?=?array[j];//如果排好序的元素存在比待排序的元素大,就后移??????j--;????}????array[j+1]?=?temp;//把待排序的元素值赋值回来??}??return?array;}let?testArray?=?[35,80,21,54,11,45,92,39];console.log(insertSort(testArray));

测试结果:

3.4算法效率

是稳定的排序算法。平均时间复杂度|最好情况|最坏情况?|空间复杂度||-------|----|-----|-----||O(n2)?|O(n)|O(n2)|O(1)

4.归并排序4.1算法原理

所谓归并,指的是把“几个已排序的数据列”合并成“一个已排序的数据列”,即把待排序列分为若干个子序列,每个子序列都是有序的,然后再把子序列合并成整体有序序列。

4.2算法思路

采用递归法:

1.将序列每相邻两个数字进行归并操作,形成floor(n/2)个序列,排序后每个序列包含两个元素

2.将上述序列再次归并,形成floor(n/4)个序列,每个序列包含四个元素

3.重复步骤2,直到所有元素归并完毕

4.进行合并操作,对每个排好的数据列做对比,找到最小值,放到容器中。

5.找到最小值后,原数组的下一个数据就会称为起始值。

下图是对3个数据列进行归并排序的展示,可以看到每次数据列取值之后,下一个数据就会变为起始元素。

4.3代码实现let?merge?=?(a,b)?=>?{//合并函数??if?(a.length?===?0)?return?b??if?(b.length?===?0)?return?a??return?a[0]?>?b[0]??//每次取值,找到数组中的最小值????[b[0]].concat(merge(a,?b.slice(1)))?://取值后,把数组第二个数据设置为起始值????[a[0]].concat(merge(a.slice(1),?b))}let?mergeSort?=?(array)?=>?{??let?n?=?array.length;??if(n?===?1){return?array}??let?left?=?array.slice(0,Math.floor(n/2));//将数组分割,直到长度为1??let?right?=?array.slice(Math.floor(n/2));??return?merge(mergeSort(left),mergeSort(right))}let?testArray?=?[35,80,21,54,11,45,92,39];console.log(mergeSort(testArray));

测试结果:

4.4算法效率

稳定排序算法,从效率上看,归并排序可算是排序算法中的”佼佼者”.假设数组长度为n,那么拆分数组共需logn,又每步都是一个普通的合并子数组的过程,时间复杂度为O(n),故其综合时间复杂度为O(nlogn)。另一方面,归并排序多次递归过程中拆分的子数组需要保存在内存空间,其空间复杂度为O(n)。和选择排序一样,归并排序的性能不受输入数据的影响,但表现比选择排序好的多,因为始终都是O(nlogn)的时间复杂度。代价是需要额外的内存空间。

平均时间复杂度最好情况最坏情况空间复杂度O(nlogn)O(nlogn)O(nlogn)O(n)5.快速排序5.1算法原理

通过一次排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以达到整个数据变成有序序列。

5.2算法思路

快速排序使用分治策略来把一个序列(list)分为两个子序列(sub-lists)。步骤为:1.从数列中挑出一个元素,称为“基准”(pivot)。

2.重新排序数列,所有比基准值小的元素摆放在基准前面,所有比基准值大的元素摆在基准后面(相同数可以到任一边)。在这个分区结束之后,该基准就处于数列的中间位置。

3.递归地(recursively)把小于基准值元素的子数列和大于基准值元素的子数列排序。

下图展示了用初始元素作为基准值进行快速排序:

5.3代码实现let?quickSort?=?(array)?=>?{??if?(array.length?<=1){return?array;}??let?pivotIndex?=?Math.floor(array.length/2);//使用数列中间的元素作为基准??let?pivot?=?array.splice(pivotIndex,1)[0];??let?left?=?[];??let?right?=?[];??for?(let?i?=?0;?i?<?array.length;?i++)?{????if?(array[i]?<?pivot){//比基准值小的放在前面,大的或者等于的放在后面??????left.push(array[i])????}else?{right.push(array[i])}??}??return?quickSort(left).concat([pivot],quickSort(right))//递归子数组}let?testArray?=?[35,80,21,54,11,45,92,39];console.log(quickSort(testArray));

测试结果:

5.4算法效率

快速排序并不稳定,快速排序每次交换的元素都有可能不是相邻的,因此它有可能打破原来值为相同的元素之间的顺序。

平均时间复杂度最好情况最坏情况空间复杂度O(nlogn)O(nlogn)O(n2)O(1)6.希尔排序6.1算法原理

把数据按照一定间隔分割成不同的组,并且对每个组进行插入排序。

6.2算法思路

1.把分组间隔gap初始化为N/2(商的整数部分)

2.当gap当于1的时候,循环执行

3.把数据列以gap为间隔分组

4.对每一组进行插入排序

5.把gap/2代入gap。

下图展示了使用希尔排序的过程

6.3代码实现let?insertSortGap?=?(array,gap)?=>?{//这段代码的解释可以往上看插入排序的注释????for(let?i?=?gap;i<?array.length;i++){??????let?temp?=?array[i];??????let?j?=?i-gap;??????while?(j>=?0?&&?array[j]?>?temp){????????array[j+gap]?=?array[j];????????j?-=?gap??????}??????array[j+gap]?=?temp????}}let?shellSort?=?(array)?=>?{??let?gap?=?Math.floor(array.length/2);??while?(gap>=1){????insertSortGap(array,gap)//分组后调用快速排序????gap?=?Math.floor(gap/2)??}??return?array}let?testArray?=?[35,80,21,54,11,45,92,39];console.log(shellSort(testArray));

测试结果:

6.4算法效率

不稳定排序算法,希尔排序第一个突破O(n2)的排序算法;是简单插入排序的改进版;它与插入排序的不同之处在于,它会优先比较距离较远的元素,直接插入排序是稳定的;而希尔排序是不稳定的,希尔排序的时间复杂度和步长的选择有关平均时间复杂度|最好情况|最坏情况?|空间复杂度||-------|----|-----|-----||O(n1.3)?|O(n)|O(n2)|O(1)

后续

除了以上的6种算法外,常用的还有计数排序和推排序算法,堆排序算法的涉及到二叉树数据结构的知识,后面再慢慢补充把。

原文:https://juejin.cn/post/7094903421018472479

② web前端开发需要哪些技能

一、HTML5+CSS3

HTML5和CSS3是通往Web工程师路上必须学会的基本内容,主要包括了解常用浏览器和浏览器内核;了解语义化的概念;掌握HTML5语法及使用技巧;掌握HTML5常用标签。掌握CSS语法及使用技巧;掌握DIV+CSS布局方式;掌握常见网页布局模式。掌握HTML5新布局标签、多媒体标签;掌握CSS32D、3D变换、动画效果;能够使用CSS3新属性美化修饰网页;了解移动端屏幕、移动端浏览器、操作系统的不同等内容。

二、js交互设计

JS交互技术可以赋予页面一个动态的效果展示,提升用户的浏览体验,这部分主要是通过JS的学习掌握JavaScript基本语法;掌握常见JavaScript算法;掌握DOM的各种操作;熟练使用面向对象思想进行DOM编程;掌握JavaScript的高级语法;掌握JavaScript常见兼容性方案。熟练使用jQuery操作DOM;熟练使用和编写jQuery案例。

三、Node开发

Node.js不仅仅是一个框架,它是一个完整的JavaScript环境,配备了开发人员可能需要的开发工具。所以学好Node是在打通前后端开发中需要掌握的技术。这部分需要掌握ES6的基础用法和兼容性;掌握ES6的核心语法;使用ES6实现前端模块化开发。使用Webpack模块打包器;使用Node.js进行Web服务端开发;掌握JavaScript异步编程模型;掌握JavaScript模块化编程方式;使用Node.js操作MongoDB数据库;独立开发基于后台接口的动态网站、Ajax数据交互的项目;独立完成企业网站从前台到后台的基本开发工作。

四、前端框架

前端框架是Web开发人员需要熟练掌握的技能,并且在实际开发中是会被广泛应用的,那么对于前端框架方面需要掌握现在主流的Vue、React、Angular等,掌握D3.js进行大数据可视化交互开发;掌握Vue技术栈进行项目开发;掌握React技术栈进行项目开发;掌握使用主流框架开发门户网站、管理系统、移动Web等客户端;掌握Webpack项目构建配置流程;掌握Web项目的部署与发布模式;掌握常见网站业务模块开发等。

五、小程序与APP开发现在移动应用越来越受欢迎,掌握了小程序和APP开发技术可以增强自身竞争力,这就需要掌握小程序的开发基础;能够独立开发小程序项目;能够掌握Canvas的使用;能够掌握小程序的部署与发布;能够掌握小程序开发框架mpvue的使用;掌握第三方AI平台的使用。能够掌握小游戏开发基础;能够独立开发小游戏项目;能够掌握小游戏的部署与发布;能够独立使用ReactNative开发原生App。

视频教程

网页链接

③ javascript算法题,26个字母和数字转换,怎么做

26个字母转为ASCII码:

varc='A';
console.log(c.charCodeAt(0));

26个字母转换为1~26对应专的数字:属

varc='A';//字母
console.log(c.toLocaleLowerCase().charCodeAt(0)-96);

④ web前端javascript能实现什么算法或者计算

在Web开发中,JavaScript很重要,算法也很重要。下面整理了一下一些常见的算法在JavaScript下的实现,包括二分法、求字符串长度、数组去重、插入排序、选择排序、希尔排序、快速排序、冒泡法等等。仅仅是为了练手,不保证高效与美观,或许还有Bug,有时间再完善吧。

1.二分法:

function binary(items,value){

var startIndex=0,

stopIndex=items.length-1,

midlleIndex=(startIndex+stopIndex)>>>1;

while(items[middleIndex]!=value && startIndex

if(items[middleIndex]>value){

stopIndex=middleIndex-1;

}else{

startIndex=middleIndex+1;

}

middleIndex=(startIndex+stopIndex)>>>1;

}

return items[middleIndex]!=value ? false:true;

}

2.十六进制颜色值的随机生成:

function randomColor(){

var arrHex=["0","2","3","4","5","6","7","8","9","a","b","c","d"],

strHex="#",

index;

for(var i=0;i < 6; i++){

index=Math.round(Math.random()*15);

strHex+=arrHex[index];

}

return strHex;

}

一个求字符串长度的方法:

function GetBytes(str){

var len=str.length,

bytes=len;

for(var i=0;i < len;i++){

if(str.CharCodeAt>255){

bytes++;

}

}

return bytes;

}

3.js实现数组去重:

Array.protype.delRepeat=function(){

var newArray=new Array();

var len=this.length;

for(var i=0;i < len;i++){

for(var j=i+1;j < len;j++)

{

if(this[i]==this[j])

{

++i;

}

}

newArray.push(this[i]);

}

return newArray;

}

4.插入排序。所谓的插入排序,就是将序列中的第一个元素看成一个有序的子序列,然后不段向后比较交换比较交换。

function insertSort(arr){

var key;

for(var j = 1; j < arr.length ; j++){

//排好序的

var i = j - 1;

key = arr[j];

while(i >= 0 && arr[i] > key){

arr[i + 1] = arr[i];

i --;

}

arr[i + 1] = key;

}

return arr;

}

5.选择排序。其实基本的思想就是从待排序的数组中选择最小或者最大的,放在起始位置,然后从剩下的数组中选择最小或者最大的排在这公司数的后面。

function selectionSort(data)

{

var i, j, min, temp , count=data.length;

for(i = 0; i < count - 1; i++) {

/* find the minimum */

min = i;

for (j = i+1; j < count; j++)

{

if (data[j] < data[min])

{ min = j;}

}

/* swap data[i] and data[min] */

temp = data[i];

data[i] = data[min];

data[min] = temp;

}

return data;

}

6.希尔排序,也称递减增量排序算法。其实说到底也是插入排序的变种。

function shellSort(array){

var stepArr = [1750, 701, 301, 132, 57, 23, 10, 4, 1]; //
reverse()在维基上看到这个最优的步长较小数组

var i = 0;

var stepArrLength = stepArr.length;

var len = array.length;

var len2 = parseInt(len/2);

for(;i < stepArrLength; i++){

if(stepArr[i] > len2){

continue;

}

stepSort(stepArr[i]);

}

// 排序一个步长

function stepSort(step){

//console.log(step) 使用的步长统计

var i = 0, j = 0, f, tem, key;

var stepLen = len%step > 0 ? parseInt(len/step) + 1 : len/step;

for(;i < step; i++){// 依次循环列

for(j=1;/*j < stepLen && */step * j + i < len;
j++){//依次循环每列的每行

tem = f = step * j + i;

key = array[f];

while((tem-=step) >= 0){// 依次向上查找

if(array[tem] > key){

array[tem+step] = array[tem];

}else{

break;

}

}

array[tem + step ] = key;

}

}

}

return array;

}

7.快速排序。其实说到底快速排序算法就系对冒泡排序的一种改进,采用的就是算法理论中的分治递归的思想,说得明白点,它的做法就是:通过一趟排序将待排序的纪录分割成两部分,其中一部分的纪录值比另外一部分的纪录值要小,就可以继续分别对这两部分纪录进行排序;不段的递归实施上面两个操作,从而实现纪录值的排序。

function quickSort(arr,l,r){

if(l < r){

var mid=arr[parseInt((l+r)/2)],i=l-1,j=r+1;

while(true){

while(arr[++i] < mid);

while(arr[--j]>mid);

if(i>=j)break;

var temp=arr[i];

arr[i]=arr[j];

arr[j]=temp;

}

quickSort(arr,l,i-1);

quickSort(arr,j+1,r);

}

return arr;

}

8.冒泡法:

function bullSort(array){

var temp;

for(var i=0;i < array.length;i++)

{

for(var j=array.length-1;j > i;j--){

if(array[j] < array[j-1])

{

temp = array[j];

array[j]=array[j-1];

array[j-1]=temp;

}

}

}

return array;

}

阅读全文

与01算法javascript相关的资料

热点内容
借吧易贷app 浏览:505
央财大数据研究生需要多少分 浏览:393
苹果5视频文件在哪里 浏览:448
苹果编辑叠放怎么添加app 浏览:803
ionic判断是否是安卓 浏览:11
怎么玩约单app 浏览:468
数据线插联想电脑哪里 浏览:934
手机文件传送到u盘后还占内存 浏览:753
制作专业网站注意什么 浏览:449
微盘上传视频显示文件不存在 浏览:309
苹果怎么清理appstore购买记录 浏览:187
iso怎么提取视频文件 浏览:336
求苹果好玩的手游 浏览:703
测量员app如何连rtk 浏览:638
微信红包不显示数字 浏览:367
怀孕日历表app 浏览:217
腾讯云数据产品有哪些 浏览:276
装win10系统的u盘文件系统 浏览:150
光遇云野设计编程是什么 浏览:649
word页码1212 浏览:128

友情链接