排序算法总结（js代码实现，思想通用）

最新推荐文章于 2022-03-07 11:31:34 发布

DLGDark

最新推荐文章于 2022-03-07 11:31:34 发布

阅读量360

点赞数

分类专栏： js 算法文章标签：排序算法 javascript

本文链接：https://blog.csdn.net/DLGDark/article/details/78513543

版权

js 同时被 2 个专栏收录

29 篇文章 1 订阅

订阅专栏

算法

2 篇文章 0 订阅

订阅专栏

<!DOCTYPE html>
<html>
<head>
	<meta charset="utf-8">
	<meta http-equiv="X-UA-Compatible" content="IE=edge">
	<title>sort</title>
	<link rel="stylesheet" href="">
</head>
<body>
	<script>

		//测试用例
		var a=[1,3,8,2,6,9,7,13,25,45,18];
		console.log(a);


		//1.冒泡排序
		function bubbleSort(arr){
			var len=arr.length;
			for(var i=0;i<len-1;i++){
				for(var j=0;j<len-1-i;j++){
					if(arr[j]>arr[j+1]){			//相邻元素比较
						var temp=arr[j+1];			//两两交换
						arr[j+1]=arr[j];
						arr[j]=temp;
					}
				}
			}
			return arr;
		}

		
		//2.选择排序
		function selectionSort(arr){
			var len=arr.length;
			var minIndex,temp;
			for(var i=0;i<len-1;i++){
				minIndex=i;
				for(var j=i;j<len-1;j++){
					if(arr[j]<arr[minIndex]){		//寻找最小的数
						minIndex=j;					//保存最小数的索引
					}
				}
				temp=arr[i];						//将找出的最小数与比较的数进行两两交换
				arr[i]=arr[minIndex];
				arr[minIndex]=temp;
			}
			return arr;
		}


		//3.插入排序
		function insertionSort(arr){
			var len=arr.length;
			var preIndex,current;
			for(var i=1;i<len;i++){
				preIndex=i-1;						//记录前一个位置
				current=arr[i];						//记录当前位置的值
				while(preIndex>0 && arr[preIndex]>current){				//当下标大于零时且要比较的值大于当前的值，将与当前值比较的值往后移
					arr[preIndex+1]=arr[preIndex];
					preIndex--;
				}
				arr[preIndex+1]=current;								//循环结束时，将当前值插入对应的位置即可
			}
			return arr;
		}


		//4.希尔排序
		function shellSort(arr){
			var len=arr.length;
			var gap=Math.floor(len/2);						//步长或增量
			while(gap>=1){
				for(var i=gap;i<len;i++){
					var temp=arr[i];						//记录当前要比较的值
					for(var j=i-gap; j>=0 && temp<arr[j]; j=j-gap){			//循环递减步长长度与temp比较
						arr[j+gap]=arr[j];
					}
					arr[j+gap]=temp;
				}
				gap=Math.floor(gap/2);				//改变步长
			}
			return arr;								//返回结果
		}		


		//5.归并排序
		function mergeSort(arr){				//采用自上而下的递归方式
			var len=arr.length;
			if(len<2){							//如果元素个数少于2个，则直接返回数组
				return arr;
			}
			var middle=Math.floor(len/2),		//一分为二，记录中间元素下标
				left=arr.slice(0,middle),		//以中间位置分的左边的数组
				right=arr.slice(middle);		//以中间位置分的右边的数组
			return merge(mergeSort(left),mergeSort(right));			//递归调用
		}

		function merge(left,right){				//传入两个参数，一个是左数组，一个是右数组

			var result=[];

			while(left.length && right.length){		//左边数组和右边数组必须都存在元素时
				if(left[0]<=right[0]){
					result.push(left.shift());		//如果左边数组第一个元素小，则取出左边数组中第一个元素，并放入结果数组中
				}else{
					result.push(right.shift());		//如果右边数组第一个元素小，则取出右边数组中第一个元素，并放入结果数组中
				}
			}

			while(left.length){					//如果左边数组还有元素，则全部并入
				result.push(left.shift());
			}

			while(right.length){
				result.push(right.shift());		//如果右边数组还有元素，则全部并入
			}

			return result;						//返回结果数组
		}


		//6.快速排序
		function quickSort(arr,low,high){	
			if(low<high){
				var pos=qkPass(arr,low,high);				//将参数传入函数，调用排序函数，并接受返回的基准值的索引
				quickSort(arr,low,pos-1);					//索引左边不包含索引位置，将左边划分的数组进行递归调用
				quickSort(arr,pos+1,high);					//索引右边不包含索引位置，将右边划分的数组进行递归调用
			}
			return arr;										//返回结果数组
		}

		function qkPass(arr,low,high){
			var base=arr[low];								//默认第一个元素为基准值
			while(low<high){
				while(low<high && arr[high]>base){			//从右边最高位置的元素与基准值进行比较，如果大于基准值，则自减一
					--high;
				}
				arr[low]=arr[high];							//若找到比基准值小的元素，则将其赋值给arr[low]
				              
				while(low<high && arr[low]<=base){			//从左边最低位置的元素与基准值进行比较，如果小于或等于基准值，则自加一
					++low;
				}
				arr[high]=arr[low];							//若找到比基准值大的元素，则将其赋值给arr[high]
			}
			arr[low]=base;									//最后将基准值赋给arr[low]

			return low;										//返回基准值所在位置的索引
		}
		




		//测试
		console.log(bubbleSort(a));
		console.log(selectionSort(a));
		console.log(insertionSort(a));
		console.log(shellSort(a));
		console.log(mergeSort(a));
		console.log(quickSort(a,0,10));


	</script>
</body>
</html>