js实现五种排序

一、冒泡排序

思想：比较两个相邻的项，如果前者比后者大，则交换

       function bubbleSort(arr){
		var length = arr.length,
			temp;

		for (var i=0;i<length;i++ )
		{
			for (var j=0;j<length-1-i;j++)//减i是除去不交换的情况
			{	
				if (arr[j] > arr[j+1])
				{
					temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
			
		}
		return arr;
	}
	var array = [5,4,3,2,1];
	console.log(bubbleSort(array));

二、选择排序

思想：首先找数组中的最小值，将其放在第一位；接着找第二个小的值，放在第二位；以此类推

      function selectionSort(arr){
		var length = arr.length,
			indexMin,
			temp;
		
		for (var i=0;i<length-1;i++ )
		{	
			indexMin = i;
			for (var j=i;j<length;j++)
			{	
				if (arr[indexMin] > arr[j])
				{
					indexMin = j;
				}
			}
			if (i !== indexMin)
			{
				temp = arr[i];
				arr[i] = arr[indexMin];
				arr[indexMin] = temp;
			}
		}
		return arr;
	}

	var array = [5,4,3,2,1];
	console.log(selectionSort(array));

三、插入排序

思想：假设第一位已排好序，算法从第二项开始。新插入的一项与前面的项比较，看新插入的一项插在哪个地方

      function insertSort(arr){
		var length = arr.length,
			j,
			jValue;

		for (var i=1;i<length;i++)
		{
			j = i;
			jValue = arr[i];
			while (j > 0 && arr[j-1] > jValue)
			{	
				arr[j] = arr[j-1];
				j --;
			}
			arr[j] = jValue;
		}
		return arr;
	}

	var array = [5,4,3,2,1];
	console.log(insertSort(array));

四、归并排序

思想：归并排序是一种分治算法，采用递归方法

          首先将原始数组分成较小的数组，直到每个小数组只有一个位置；接着将小数组归并成较大的数组，直到最后只有一个大数组

       function mergeSort(arr){
		var length = arr.length,
			mid = Math.floor(length/2),
			left = arr.slice(0,mid),
			right = arr.slice(mid);
			
		if (length === 1)
		{
			return arr;
		}
		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;
	}

	var array = [5,4,3,2,1];
	console.log(mergeSort(array));

五、快速排序

归并排序是一种分治算法，采用递归方法。

法一：（用了辅助空间）

思想：创建两个数组分别用来保存左右两边的数；取原数组的中间值，将原数组的所有值与中间值进行比较，比中间值小的放在一个数组中，比中间值大的放在另一个数组中；接着用递归方法遍历两个数组

      function quickSort(arr){
            if(arr.length <= 1){return arr;}

            var pivotIndex = Math.floor(arr.length/2),
				pivot = arr.splice(pivotIndex,1)[0];

            var left=[],
				right=[];

            for(var i=0;i<arr.length;i++){
                if(arr[i] < pivot){
                    left.push(arr[i]);
                }
                else{
                    right.push(arr[i]);
                }
            }

            return quickSort(left).concat([pivot],quickSort(right));
        }  

	var array = [5,4,3,2,1];
	console.log(quickSort(array));

法二：（用指针）

思想：

（1）首先取数组的中间值作为主元；

（2）划分操作：创建左右两个指针，左指针指向数组的第一项，右指针指向数组的最后一项；移动左指针直到找到一个比主元大的元素，移动右指针直到找到一个比主元小的元素，进行交换；重复这个过程，直到左指针超过右指针。这个过程使得比主元小的值都在主元之前，比主元大的值都在主元之后。

（3）接着用递归方法遍历两个数组

       function quickSort(array,left,right){
		var index;

		if ( array.length > 1)
		{
			index = partition(array,left,right);
			if ( left < index-1 )
			{
				quickSort(array,left,index-1);
			}
			if ( index < right )
			{
				quickSort(array,index,right);
			}
		}
		return array;
	};

	var partition = function(array,left,right){     //划分过程
		var pivot = array[Math.floor((left+right)/2)],
			i = left,
			j = right;
		
		while ( i<=j )
		{
			while ( array[i] < pivot )
			{
				i++;
			}
			while ( array[j] > pivot )
			{
				j--;
			}
			if ( i <= j )
			{
				swapQuickSort(array,i,j);
				i++;
				j--;
			}
		}
		return i;
	};
	var swapQuickSort = function(array,index1,index2){   //两者比较
		var aux = array[index1];
		array[index1] = array[index2];
		array[index2] = aux;
	};

	//测试
	var arrayN = [5,4,3,2,1];;
	console.log( quickSort( arrayN, 0, arrayN.length-1));

六、五种排序比较