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));

六、五種排序比較