八大排序算法实现

1、选择排序：每次排序都把最小的放在最前面，或者把最大的放到最前面

private function selectionSort(array:Array):void
{
   var len:int = array.length;
   for (var i:int = 0; i < len - 1; i++)
   {
       var min:int = array[i];
       var minIndex:int = i;
       for (var k:int = i + 1; k < len; k++)
       {
           if (array[k] < min)
           {
               min = array[k];
               minIndex = k;
           }
       }
       if (minIndex != i)
       {
           array[minIndex] = array[i];
           array[i] = min;
       }
   }
}

 

2、冒泡排序：依次交换，每次排序之后最大的数都到了最后

private function bubbleSort(array:Array):void
{
   var len:int = array.length;
   var needSort:Boolean = true;
       
   for (var i:int = 1; i < len && needSort; i++)
   {
       needSort = false;
       for (var k:int = 0; k < len - i; k++)
       {
           if (array[k] > array[k + 1])
           {
               var temp:int = array[k];
               array[k] = array[k + 1];
               array[k + 1] = temp;
               needSort = true;
           }
       }
   }
}

 

3、插入排序（直接插入）:每次插入前前面的数组都已经排好序

private function insertSort(array:Array):void
{
    var len:int = array.length;
   for (var i:int = 1; i < len; i++)
   {
       var temp:int = array[i];
       for (var k:int = i - 1; k >= 0 && array[k] > temp; k--)
       {
           array[k + 1] = array[k];
       }
       array[k + 1] = temp;
   }
}

3、插入排序（二分插入）:因为每次插入前前面的数组都已经排好序，所以可以通过二分法找到合适的插入位置

private function binaryInsertSort(array:Array):void
{
   var len:int = array.length;
   var low:int;
   var high:int;
   var mid:int;
   
   for (var i:int = 1; i < len; i++)
   {
       var temp:int = array[i];
       low = 0;
       high = i - 1;
       
       while (low <= high)
       {
           mid = (low + high) / 2;
            if (temp > array[mid])
           {
               low = mid  + 1;
           }else {
               high = mid - 1;
           }
       }
       for (var j:int = i - 1; j > high; j--)
       {
           array[j + 1] = array[j];
       }
       array[high + 1] = temp;
   }
}

 

4、希尔排序（简单实用的排序方法）:通过改进插入排序方法而来（有间隔的插入排序），虽然代码很好写，但是我一直都不是很懂为什么这样更快

private function shellSort(array:Array):void
{
   var len:int = array.length;
   var distance:int = len;
   
   while (distance > 1)
   {
       distance = distance / 3 + 1;
       for (var i:int = distance; i < len; i++)
       {
           var temp:int = array[i];
                     for (var k:int = i - distance; k >= 0 && array[k] > temp; k = k - distance)
           {
               array[k + distance] = array[k]; 
           }
           array[k + distance] = temp;
       }
   }
}

 

5、归并排序：利用分治的思想，通过递归，一句话，就是拆分拆分再拆分，合并合并再合并。

private function mergeSort(array:Array):void
{
   var len:int = array.length;
   if (len > 1)
   {
       var firstArray:Array = array.slice(0, len / 2);
       mergeSort(firstArray);
       var secondArray:Array = array.slice(len / 2, len);
       mergeSort(secondArray);
       var tempArray:Array = mergeArray(firstArray, secondArray);
       
       var length:int = array.length;
       for (var i:int = 0; i < length; i++)
       {
           array[i] = tempArray[i];
       }
   }
}

private function mergeArray(firstArray:Array, secondArray:Array):Array
{
   var firstIndex:int = 0; 
   var secondIndex:int = 0;
   var tempIndex:int = 0;
   
   var tempArray:Array = [];
   
   var firstLen:int = firstArray.length;
   var secondLen:int = secondArray.length;
   
   while (firstIndex < firstLen && secondIndex < secondLen)
   {
       if (firstArray[firstIndex] < secondArray[secondIndex])
       {
           tempArray[tempIndex++] = firstArray[firstIndex++];
       }
       else 
       {
           tempArray[tempIndex++] = secondArray[secondIndex++];
       }
   }
   
   while (firstIndex < firstLen)
   {
       tempArray[tempIndex++] = firstArray[firstIndex++];
   }
   
   while (secondIndex < secondLen)
   {
       tempArray[tempIndex++] = secondArray[secondIndex++];
   }
   
   return tempArray;
}

 

6、快速排序：把数组分成左小右大，递归，完事

private function quickSort(array:Array, low:int, high:int):void
{
   if (low < high)
   {
       var pivotIndex:int = halfArray(array, low, high);
       quickSort(array, low, pivotIndex - 1);
       quickSort(array, pivotIndex + 1, high);
   }
}

private function halfArray(array:Array, low:int, high:int):int
{
   var pivot:int = array[low];
   
   while (low < high)
   {
       while (low < high && array[high] >= pivot)
       {
           high--;
       }
       array[low] = array[high];
       while (low < high && array[low] <= pivot)
       {
           low++;
       }
       array[high] = array[low];
   }
   array[low] = pivot;
   return low;
}

 

7、堆排序：利用堆的思想对数组进行排序（最大堆就是父节点比子节点都大）

private function heapSort(array:Array):void
{
   var len:int = array.length;
   for (var i:int = 1; i < len; i++)
   {
       makeHeap(array, i);
   }
   for (var k:int = len - 1; k > 0; k--)
   {
       var temp:int = array[k];
       array[k] = array[0];
       array[0] = temp;
       updateHeap(array, k - 1);
   }
}

private function makeHeap(array:Array, last:int):void
{
   var currentIndex:int = last;
   while (currentIndex > 0)
   {
             if (array[currentIndex] > array[int((currentIndex - 1) / 2)])
       {
           var temp:int = array[currentIndex];
                                      array[currentIndex] = array[int((currentIndex - 1) / 2)];
           array[int((currentIndex - 1) / 2)] = temp; 
           
           currentIndex = (currentIndex - 1) / 2;
       }
       else 
       {
           break;
       }
   }
}

private function updateHeap(array:Array, last:int):void
{
   var currentIndex:int = 0; 
   var isHeap:Boolean = false;
   
   while (!isHeap)
   {
       var leftIndex:int = 2 * currentIndex + 1;
       var rightIndex:int = 2 * currentIndex + 2;
       var maxIndex:int = currentIndex;
       
             if (leftIndex <= last && array[currentIndex] < array[leftIndex])
       {
           maxIndex = leftIndex;
       }
             if (rightIndex <= last && array[maxIndex] < array[rightIndex])
       {
           maxIndex = rightIndex;
       }
       
       if (maxIndex != currentIndex)
       {
           var temp:int = array[currentIndex];
           array[currentIndex] = array[maxIndex];
           array[maxIndex] = temp;
           currentIndex = maxIndex;
       }
       else
       {
           isHeap = true;            
       }
   }
}

 

8、基数排序（利用桶的思想，遍历把数组项装进不同的桶，再组合，在装桶，循环几次即可（跟最大位数跟所选基数有关））

/**
* 基数排序
* @param array    待排序的数组
* @param base    基数
*/        
private function radixSort(array:Array, base:int = 10):void
{
   var maxLen:int = findLen(array, base);
   var arrLen:int = array.length;
   var temp:int = 1;
   
   var container:Array = [];
   for (var i:int = 0; i < base; i++)
       container[i] = [];
   
   while (maxLen--)
   {
       //    放到相应的容器中
       for (var j:int = 0; j < arrLen; j++)
       {
           container[int(array[j] / temp) % base].push(array[j]);
       }
       temp *= base;
       //    重新排列
       array.length = 0;
       var containerLen:int = container.length;
       for (var k:int = 0; k < containerLen; k++)
       {
           if(container[k].length)
           {
               var len:int = container[k].length;
               for (var m:int = 0; m < len; m++)
               {
                   array.push(container[k][m]);
               }
               
               container[k].length = 0;
           }
       }
   }
}

/**
* 找出数组项最大长度
* @param array    待排序的数组
* @param base    基数
* @return 
*/        
private function findLen(array:Array, base:int):int
{
   var maxLen:int = 1;
   var temp:int = base;
   var len:int = array.length;
   for (var i:int = 0; i < len; i++)
   {
       while (array[i] >= temp)
       {
           maxLen++;
           temp *= base;
       }
   }
   
   return maxLen;
}

 

over！