排序算法

package source;public class SortAlgorithm {/** * 冒泡排序（Bubble Sort）是一种简单的排序算法。 * 它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。 * 走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。 * 这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。 * 冒泡排序算法的运作如下： *1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。 *2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。 *3.针对所有的元素重复以上的步骤，除了最后一个。 *4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 */public void bubbleSort(int[] array) {int len = array.length;for(int i = 0; i < len - 1; i++){for(int j = len - 1; j > i; j--){if(array[j] < array[j - 1]){swap(array,j,j-1);}}}}/** * 计数排序(Counting sort)是一种稳定的排序算法。 * 计数排序使用一个额外的数组C，其中第i个元素是代排序数组A中值等于i的元素的个数。 * 然后根据数组C来将A中的元素排到正确的位置。 * 算法的步骤如下： * 1. 找出待排序的数组中最大和最小的元素 * 2. 统计数组中每个值为i的元素出现的次数，存入数组C的第i项 * 3. 对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加） * 4. 反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1 */public void countSort(int[] array) {int temp[];int i, j, min, max;min = max = array[0];for( i = 1; i < array.length; i++){if(array[i] < min){min = array[i];}else if(array[i] > max){max = array[i];}}int range = max - min + 1;temp = new int[range];for(i = 0; i < range; i ++){temp[i] = 0;}for(i = 0; i < array.length; i++){temp[array[i] - min]++;}j = 0;for(i = 0; i < range; i++){while( 0 != temp[i]){array[j] = i + 1;temp[i]--;j++;}}}/** * 堆积排序：移除位在第一个数据的根结点,并做最大堆积调整的递归运算 * 1.建立一个堆H[0..n-1] *2.把堆首（最大值）和堆尾互换 *3.把堆的尺寸缩小1，并调用maxHeapify,目的是把新的数组顶端数据调整到相应位置 *4.重复2号步骤，直到堆的尺寸为1 * @param array */public void heapSort(int[] array) {buildMaxHeap(array);for(int i=array.length-1;i>=0;i--) { swap(array,0, i); maxHeapify(array, 0, i-1); }}/** * 建立最大堆积：将堆积树所有数据重新排序 * @param array */private void buildMaxHeap(int[] array) {for(int i = array.length/2 -1; i >= 0; i--){maxHeapify(array,i,array.length - 1);}}/** * 最大堆积调整：将堆积树的末端子结点作调整,使得子结点永远小于父结点 * @param array * @param start * @param end */private void maxHeapify(int[] array, int start, int end) {int index; int temp = array[start]; index = 2 * start + 1; while(index <= end) { if(index < end && array[index] < array[index+1]) index = index + 1; if(temp > array[index]) break; else { array[start] = array[index]; start = index; index = 2 * start + 1; } } array[start] = temp;}/** * 插入排序（Insertion Sort）的算法描述是一种简单直观的排序算法。 * 它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。 * 插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中， * 需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。 * 具体算法描述如下： *1.从第一个元素开始，该元素可以认为已经被排序 * 2.取出下一个元素，在已经排序的元素序列中从后向前扫描 *3.如果该元素（已排序）大于新元素，将该元素移到下一位置 *4.重复步骤3，直到找到已排序的元素小于或者等于新元素的位置 *5.将新元素插入到该位置中 *6.重复步骤2 */public void insertSort(int[] array) {int len = array.length;int loc,temp;for(int i = 1; i < len; i++){if(array[i] < array[i - 1]){temp = array[i];loc = i;do{array[loc] = array[loc - 1];loc--;}while(loc > 0 && array[loc - 1] > temp);array[loc] = temp;}}}/** * 归并排序具体工作原理如下（假设序列共有n个元素）： * 1. 将序列每相邻两个数字进行归并操作（merge），形成floor(n / 2)个序列，排序后每个序列包含两个元素 * 2. 将上述序列再次归并，形成floor(n / 4)个序列，每个序列包含四个元素 * 3. 重复步骤2，直到所有元素排序完毕 */public void mergeSort(int[] array) {recMerge(array, 0, array.length - 1);}private void recMerge(int[] array, int start, int end) {int i;if(start < end){i = (start + end) / 2;recMerge(array, start, i);recMerge(array, i + 1, end);merge(array,start, i, end);}} /** * 归并操作(merge)，也叫归并算法，指的是将两个已经排序的序列合并成一个序列的操作。 * 归并操作的工作原理如下： * 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列 * 设定两个指针，最初位置分别为两个已经排序序列的起始位置 * 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置 * 重复步骤3直到某一指针达到序列尾 * 将另一序列剩下的所有元素直接复制到合并序列尾 */private void merge(int[] array, int start, int mid, int end) {int temp1[] = new int[100], temp2[] = new int[100];int n1, n2;int i, j, k;n1 = mid - start + 1;n2 = end - mid;temp1 = new int[n1 + 1];temp2 = new int[n2 + 1];temp1[n1] = temp2[n2] = 1000000000;for(i = 0; i < n1; i++){temp1[i] = array[start + i];}for(i = 0; i < n2; i++){temp2[i] = array[mid + i + 1];}i = j = 0;for(k = start; k <= end; k++){if(temp1[i] < temp2[j]){array[k] = temp1[i];i++;}else{array[k] = temp2[j];j++;}}}/** * 快速排序使用分治法（Divide and conquer）策略来把一个序列（list）分为两个子序列（sub-lists）。 *步骤为： *1.从数列中挑出一个元素，称为 "基准"（pivot）， *2.重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分割之后，该基准是它的最后位置。这个称为分割（partition）操作。 *3.递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。 *递回的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递回下去，但是这个算法总会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。 */public void quickSort(int[] array) {qSort(array, 0,array.length - 1);}private void qSort(int[] array, int begin, int end) {if(begin > end) return;int pivot = partition(array, begin, end); qSort(array, begin,pivot - 1);qSort(array, pivot + 1,end);}private int partition(int[] array, int begin, int end) {swap(array, begin, (begin + end)/2);int pivot = array[begin];int index = begin;for(int i = begin + 1; i <= end; i++){if(array[i] < pivot){index++;swap(array,index,i);}}swap(array, begin, index);return index;}/** * 选择排序(Selection sort)是一种简单直观的排序算法。 * 它的工作原理如下: * 首先在未排序序列中找到最小元素，存放到排序序列的起始位置， * 然后，再从剩余未排序元素中继续寻找最小元素，然后放到排序序列末尾。 * 以此类推，直到所有元素均排序完毕。 */public void selectionSort(int[] array) {int min,len = array.length;//找出从a[i]到a[size-1]的最小元素的位置for(int i = 0; i < len - 1; i++){min = i;for(int j = i + 1; j < len; j++){if(array[min] > array[j]){min = j;}}swap(array, i, min);}}/** * 希尔排序(Shell Sort)也称为递减增量排序算法 * 希尔排序是基于插入排序的以下两点性质而提出改进方法的： * 插入排序在对几乎已经排好序的数据操作时， 效率高， 即可以达到线性排序的效率. * 但插入排序一般来说是低效的， 因为插入排序每次只能将数据移动一位. * 对有n个元素的可比较资料，先取一个小于n的整数d1作为第一个增量，把文件的全部记录分成d1个组。 * 所有距离为d1的倍数的记录放在同一个组中。先在各组内进行直接插入排序； * 然后，取第二个增量d2<d1重复上述的分组和排序，直至所取的增量dt=1(dt<dt-1<…<d2<d1)， * 即所有记录放在同一组中进行直接插入排序为止。 */public void shellSort(int[] array) {int i,j,k,temp;for(i = array.length/2; i > 0; i /= 2){for(j = i; j < array.length; j+=i){temp = array[j];k = j;while(k - i >= 0 && temp < array[k - i]){array[k] = array[ k - i];k -= i;}array[k] = temp;}}}private void swap(int[] array, int i, int j) {int temp = array[i];array[i] = array[j];array[j] = temp;}@Overridepublic void print(int[] array) {for(int i = 0; i < array.length; i++){System.out.print(array[i] + " ");}System.out.println();System.out.println("------------------Print End-----------------");}}