Javascript高级—多种排序算法

最新推荐文章于 2025-01-21 00:32:18 发布
最新推荐文章于 2025-01-21 00:32:18 发布
阅读量275 收藏
点赞数 2
CC 4.0 BY-SA版权
分类专栏： 玩转前端JavaScript JavaScript学习 Javascript高级 文章标签： javascript 排序算法 开发语言
本文为高热度网（http://blog.gaoredu.com/）原创文章，未经博主允许不得转载。更多原创内容请访问http://blog.gaoredu.com/
本文链接：https://blog.csdn.net/m0_37981569/article/details/143783052

冒泡排序

////////////////////////////////////////////////////////////////
// bubble sort
function ArrayList(){
	// 私有变量
	var arr = [];

	// 将数组中i，j位置的数组进行交换
	var swap = function(i, j){
		var temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}

	// add element
	this.insert = function(item) {
		arr.push(item);
	}

	// to string
	this.toString = function(){
		//  数组中的join() 方法默认是按照 "," 进行分割的
		return arr.join();
	}

	// v1 : bubble sort（注意：i, j两个变量都是从0开始的）
	this.bubbleSort = function(){
		var len = arr.length;
		for (var i = 0; i < len; i++) {
			// 内层循环从第一位一直迭代到倒数第二位
			for (var j = 0; j < len - i; j++) {
				// 只要前面的元素比后面的元素大的话，就去直接交换
				if (arr[j] > arr[j + 1]) {
					swap(j, j + 1);
				}
			}
		}
	}




	// v2 : 从内循环减去外循环已经跑过的轮数，可以避免循环中所有不必要的比较
	this.bubbleSort = function (){
		var len = arr.length;
		for (var i = 0; i < len; i++) {
			for (var j = 0; j < len - i - 1; j++) {
				if (arr[j] > arr[j + 1]) {
					swap(j, j + 1);
				}
			}
		}
	}

}3


/*
 * 创建一个无序数组
 * @ size
 * */
function createNoneSortedArray(size){
	var arr = new ArrayList();
	for (var i = size; i > 0; i--) {
		// 直接给数组初始化一个逆序的数组序列
		arr.insert(i);
	}
	return arr;
}



///////////////////////////////////////////////////////////////////////
// 测试
var arr = createNoneSortedArray(5);
console.log(arr, arr.toString());
// bubble sort
arr.bubbleSort();
console.log(arr.toString());

插入排序

//////////////////////////////////////////////////////////////////////////////////////
// insert sort
function ArrayList(){
	var arr = [];

	var swap = function(i, j){
		var temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}

	this.insert = function (item){
		arr.push(item);
	}

	this.toString = function(){
		return arr.join();
	}

	// v1 : insert sort
	this.insertSort = function(){
		var len = arr.length;
		// 每次直接从当前元素前面的元素进行比较交换
		// 假设用户的手中刚开始的时候已经有了一张扑克牌了
		for (var i = 1; i < len; i++) {
			for (var j = i; j > 0; j--) {
				if (arr[j - 1] > arr[j]) {
					swap(j - 1, j);
				}/* else {
					break;
				}*/
			}
		}
	}

	// v2 : 不使用swap函数进行交换，直接使用原地交换的方式进行排序
	this.insertSort = function(){
		var len = arr.length;
		for (var i = 1; i < len; i++) {
			// 1. 先把当前的元素缓存起来
			var e = arr[i];
			// 2. 保存当前元素e应该插入到的位置j
			var j;
			// 注意点：
			// 1. 插入排序的内层循环必须和这个元素e进行比较，而不是和前面的元素进行比较
			// 2. 比较大小的代码必须放在这个内层for循环之内进行比较
			for (j = i; j > 0 && arr[j - 1] > e; j--) {
				arr[j] = arr[j - 1];
			}
			// 3. 执行完毕内层循环之后，j的位置已经是当前的目标插入位置了
			arr[j] = e;
		}
	}
}


function createNoneSortArray(size){
	var arr = new ArrayList();
	for (var i = size; i > 0; i--) {
		arr.insert(i);
	}
	return arr;
}



///////////////////////////////////////////////////////////////////////////////
// 测试
var arr = createNoneSortArray(5);
console.log(arr.toString());
arr.insertSort();
console.log(arr.toString());

选择排序

//////////////////////////////////////////////////////////////////////////////////////
// select sort
function ArrayList(){
	var arr = [];

	var swap = function(i, j){
		var temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}

	this.insert = function (item){
		arr.push(item);
	}


	this.toString = function(){
		return arr.join()
	}

	//  select sort
	this.selectSort = function(){
		var len = arr.length;
		for (var i = 0; i < len; i++) {
			var minIndex = i;
			// 每次从当前位置以后的元素选择一个最小的元素放在第i个位置上面
			for (var j = i; j < len; j++) {
				if (arr[j] < arr[i]) {
					minIndex = j;
				}
			}
			// 如果当前位置和原始的最小值的标定下标是一样的话，就不处理
			if (i !== minIndex)
				swap(i, minIndex);
		}
	}
}


// 创建一个无序数组序列
function createNoneSortArray(size){
	var arr = new ArrayList();
	for (var i = size; i > 0; i--) {
		arr.insert(i);
	}
	return arr;
}



///////////////////////////////////////////////////////////////////////////////////////
// 测试
var arr = createNoneSortArray(5);
console.log(arr.toString());
arr.selectSort();
console.log(arr.toString());

归并排序

//////////////////////////////////////////////////////////////////////////////////////
// merge sort
function ArrayList(){
	var arr = []

	var swap = function(i, j){
		var temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}


	this.insert = function (item){
		arr.push(item);
	}

	this.toString = function (){
		return arr.join();
	}


	////////////////////////////////////////////////////////////////////
	// merge sort 辅助函数
	// 开始对区间[l, middle], [middle + 1, r]区间的元素进行归并
	var __merge = function(arr, l, middle, r){
		console.log('merge aray start : ', arr, l, middle, r);
		// 1. 开辟一个临时空间，把原始的数组复制到这个新的数组里面
		// 数组深度克隆： arr.slice(), arr.concat(), for循环， fo (var item in arr)循环
		var aux = arr.concat();
		for (var i = l; i <= r; i++) {
			aux[i - l] = arr[i];
			console.log('copy ', arr[i], aux[i], i, r);
		}

		console.log('aux array now is ', aux, arr);

		// 2. 开始进行归并(i, j位置的初始化)
		var i = l, j = middle + 1;
		for (var k = l; k <= r; k++) {
			// 这里需要进行越界的检查啊
			if (i > middle) {
				// 开始去处理右边的
				arr[k] = aux[j - l];
				j++;
			} else if (j > r) {
				arr[k] = aux[i - l];
				i++;
			}

			// 遍历[l, r]区间内的元素(开始依次比较左右区间内的元素的大小，找出一个最小值, 放在第k个位置)
			else if (aux[i - l] < aux[j - l]) {
				arr[k] = aux[i - l];
				i++;
			} else {
				arr[k] = aux[j - l];
				j++;
			}

		}
	}


	// 递归使用归并排序算法对arr[l, r]这个区间范围内的数据进行排序
	var __mergeSort = function(arr, l, r){
		console.log('sort ……', l, r);
		// 1. 递归终止条件(l必须始终大于r的)
		if (l >= r)
			return ;
		// 2. 计算数组中间的位置
		var middle = Math.floor(l + (r - l) / 2);
		console.log('middle now is ', middle);
		// 2. 开始对左边的区间元素进行归并排序[l, middle]
		__mergeSort(arr, l, middle);
		// 3. 开始对右边的区间元素进行归并排序[middle + 1, r]
		__mergeSort(arr, middle + 1, r);
		console.log('loading……', l, r, middle);

		// 4. 排序完成之后，开始进行归并
		__merge(arr, l, middle, r);

		return arr;
	}

	// v1 : merge sort
	this.mergeSort =  function(){
		// 对区间[0, n - 1]的元素进行归并排序
		arr = __mergeSort(arr, 0, arr.length - 1); 		// 将数组中的数据修改为最新的数据信息
		return arr;
	}


}



function createNoneSortArray(size){
	var arr = new ArrayList();
	for (var i = size; i > 0; i--) {
		arr.insert(i);
	}
	return arr;
}



///////////////////////////////////////////////////////////////////////////////////////
// 测试
var arr = createNoneSortArray(5);
console.log('init array : ', arr.toString());
arr.mergeSort();
console.log('caculate result : ', arr.toString());

快速排序

//////////////////////////////////////////////////////////////////////////////////////
// quick sort
function ArrayList(){
	var arr = [];

	var swap = function(i, j){
		var temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}

	this.insert = function (item){
		arr.push(item);
	}

	this.toString = function (){
		return arr.join();
	}

	///////////////////////////////////////////////////////////////////////////////////////
	// quick sort
	// 求出数组arr在区间[l, r]范围的下标p位置，使得p满足条件, arr[l , p - 1] < arr[p], arr[p + 1, r] > arr[p]
	var __partition = function(arr, l, r){
		// 1. 选择数组中的第一个元素作为标定点
		var v = arr[l];
		// 2. 初始化变量的初始位置, arr[l + 1, i] < v, arr[j, r] >= v
		var i = l + 1, j = r;

		// 3. 开始循环
		while (true) {
			// i 向后移动
			while (i <= r && arr[i] < v){
				i++;
			}

			// j 向前移动
			while (j >= l && arr[j] > v) {
				j--;
			}

			// 交换数据之前需要先来处理一下元素的条件
			if (i > j) {
				break;
			}

			// 此处说明遇到了第一个arr[i] > v && arr[j] < v的元素，直接交换即可
			swap(i, j);

			// 交换完毕之后，开始进入下一个循环
			i++;
			j--;
		}

		// 执行完毕之后，将v元素放在正确的位置
		swap(l, j);
		// 最终j的位置就是标定点的位置
		return j;
	}


	// 实现对区间arr[l, r] 范围内的元素使用快速排序
	var __quickSort = function(arr, l, r){
		// 1. 递归终止的条件
		if (l >= r) {
			return;
		}

		// 2. 开始求出p的位置，使得数组满足条件arr[l, p - 1] < arr[p], arr[p + 1, r] > arr[p]
		var p = __partition(arr, l, r);
		// 3. 继续对arr[l, p - 1], arr[p + 1, r]区间的元素使用快速排序
		__quickSort(arr, l, p - 1);
		__quickSort(arr, p + 1, r);
	}


	this.quickSort = function(){
		// 使用递归实现快速排序
		__quickSort(arr, 0, arr.length - 1);
	}
	
	
	
	
	
	
	function quickSort(arr) {
	  __quickSort(arr, 0, arr.length - 1)
	}
	
	function __quickSort(arr, l, r) {
	  if (l >= r) {
	      return;
	  }
	  
	  let p = __partition(arr, l, r);
	  __quickSort(arr, l, p - 1);
	  __quickSort(arr, P + 1, r)
	}
	
	function __partition() {
	  let v = arr[l];
	  let i = l + 1, j = r;
	  while (true) {
	      while () 
	  } 
	}
}


function createNoneSortArray(size){
	var arr = new ArrayList();
	for (var i = size; i > 0; i--) {
		arr.insert(i);
	}
	return arr;
}



//////////////////////////////////////////////////////////////////////////////////
// 测试
var arr = createNoneSortArray(5);
console.log(arr.toString());
arr.quickSort();
console.log(arr.toString());
JS实现高级排序——（希尔排序、快速排序）
weixin_43324314的博客
07-13 1248
希尔排序、快速排序是最常见也是最常用的高级排序，希尔排序的出现打破了排序效率不可以超过O(N2)的定论，具有极其高的意义。在希尔排序后出现了很多更快的高级排序，但是相比之下，最重要的还是快速排序。下面我将对着两种高级排序进行思路、图解、代码、效率等的分析与讲解。 如果还对数组的初始化存在疑问的可以看我之前发布的简单排序，里面已经一一道出了，下面我就不再写了。 传送门：简单排序 一、希尔排序 1.希尔排序的思路 希尔排序是插入排序的升级版 设置一个增量，然后根据增量进行分组，每个分组内进行插入排序，尽可能让
直击高频编程考点：排序算法知识及经典算法题总结
热门推荐
张彦峰的博客
10-27 5万+
排序算法知识及编程练习总结：背景知识介绍+主流排序算法与应用+相关排序算法练习（冒泡排序+鸡尾酒排序+插入排序+选择排序+快速排序+归并排序+堆排序+Top K 问题分析+使用堆排序思想实现优先级队列+计数排序+桶排序+基数排序）
23个高级JS编程技巧，你能看懂几个？
w2sft的博客
09-09 397
23个高级JS编程技巧，你能看懂几个？
JavaScript语言的算法
最新发布
2501_90300283的博客
01-21 396
算法是计算机科学中的核心概念，JavaScript作为一门流行的编程语言，能够实现多种算法和数据结构的操作。本文介绍了常见的排序算法和查找算法，以及如何使用JavaScript实现这类算法。通过这些基础知识的学习，希望能帮助读者理解算法的基本原理，并在实践中灵活运用。在学习算法的过程中，建议通过编写代码和解题来巩固知识。可以尝试参与一些在线编程平台的算法挑战，例如LeetCode、HackerRank等，提升自己的解题能力。同时，保持对算法的思考和研究，不断积累经验，将为未来的编程之路铺平道路。
JavaScript的五种排序方法
知之为知之，不知为不知
04-19 3785
JavaScript的五种排序方法，冒泡排序、选择排序、插入排序、归并排序、快速排序
js中的高级算法
milijiangjun的博客
07-17 680
JavaScript排序可视化网络应用：动态展示多种排序算法效果
该应用允许用户选择多种排序算法，并能够自定义网页样式以满足个人偏好。该应用的目的是为了帮助开发者和学生更好地理解各种排序算法，通过图形化展示使得抽象的概念变得直观易懂。该应用托管于一个特定的网络地址，...
JavaScript制作排序算法动画教程
文章最后将提供一个名为“JavaScript实现排序算法动画演示”的资源文件，该文件集成了多种排序算法的动画实现，用户可以直接在网页上观看并学习各种排序算法的具体实现和动画效果。该资源将帮助开发者更好地理解排序...
排序算法可视化工具：多种排序算法动态展现
资源摘要信息:" SortingVisualizer 是一个用于可视化多种排序算法的工具，其中包括了如冒泡排序、选择排序以及合并排序等经典排序算法。该工具的目的是让使用者能够直观地观察到不同排序算法在执行过程中的数据变化...
JavaScript实现集合排序算法中级教程
在编程中，排序是一个基本且常见的任务，高效的排序算法能够显著提升程序的运行速度和性能。排序算法的选择取决于数据的大小、数据的性质以及对时间复杂度和空间复杂度的要求。 知识点5：JavaScript实现集合排序的...
JS一些算法
桃树林
05-23 1658
杨辉三角：var row = 10, arr = new Array(); for(var i=0;i&lt;row;i++){ var arrRow = []; for(var j=0;j&lt;=i;j++){ if(i == 0 || j ==0 || i==j){ arrRow.push(1); }else{ ...
js几种常见排序的实现
大康子
04-21 2万+
下面主要是对冒泡排序、选择排序、快速排序、插入排序的js实现的回顾。1. 冒泡排序 定义： 比较相邻的前后二个数据，如果前面数据大于后面的数据，就将二个 数据交换。 这样对数组的第0个数据到N-1个数据进行一次遍历后，最大的一个数据就“沉”到数组第N-1个位置。 N=N-1，如果N不为0就重复前面二步，否则排序
JavaScript中常见的十种排序方法
magic_engineer的博客
12-25 1623
注：文中所有示例均执行升序排列 一、冒泡排序 原理：比较相邻元素，如果前者大于后者，则调换位置，对每个元素执行，此时最后一个元素将是最大值，重复上述操作至排序完成。 代码示例： function sort(arr) { for (var i = 0;i &lt; arr.length;i++) { for (var j = 0;j &lt; arr.length-...
JS高级 05-02-05 Array类型 重排序方法
学无止境
06-26 171
数组中已经存在两个可以直接用来重排序的方法：reverse()和sort()。有读者可能猜到了, reverse()方法会对反转数组项的顺序。请看下面这个例子。 var values = [1, 2, 3, 4, 5]; values.reverse(); console.log(values); // [5, 4, 3, 2, 1] 这里数组的初始值及顺序是1、2、3、4、5。而调用数组的reverse() 方法后，其值的顺序变成了 5、4、3、2、1。这个方法的作用相当直观明了，但不够灵活，因此才有了
javascript高级算法题
徐同保的专栏
04-08 1014
&lt;!DOCTYPE html&gt; &lt;html lang="en"&gt; &lt;head&gt; &lt;meta charset="UTF-8"&gt; &lt;title&gt;javascript高级算法题&lt;/title&gt;
JS高级函数--------filter、sort
优雅的博客
01-17 1280
filter filter()方法：用于把Array中的某些元素过滤掉，然后返回剩下的元素 filter()也接受一个函数，把传入的函数依次作用于每个元素，然后根据返回值是true还是false决定保留还是丢弃该元素。 arr.filter(function(ele,index,arr){ }); filter()接收的回调函数，其实可以有多个参数。通常我们仅使用第一个参数ele，表示
javascript高级进阶之字符串常见算法
qq_44449938的博客
10-20 265
文章目录字符串逆序输出算法 字符串逆序输出算法 应用场景，双11订单并发存储进对应的服务器 方法一：使用reverse() function reverseString(str){ return str.split('').reverse().join('') } 方法二：模拟栈先进后出的原则（js并没有提供栈的结构） function Stack(){ this.data = []; //保存栈内的元素 this.top = 0;//记录栈顶的位置信息 } //在栈的原型链上添加方法 Stack
js高级表格排序
weixin_30666753的博客
06-30 105
源码无需任何修改，直接复制即可，建议放在head区，最好单独存一个js文件然后在head区引用进来。 然后为每个要排序的表格设置一个id，比如此例中的tb_1。记得这个table需要thead和tbody元素，否则dom节点解析会出错。thead里放一行标题，建议用th，然后为每个th加入以下属性：onclick="sortTable('tb_1', *)" style="cursor:point...
程序员必须知道的10大基础实用算法及其讲解(Javascript代码实现)
fendouzhe123的专栏
06-25 6073
注：本文的文字解释部分并非原创，
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值