插入排序
基本思想:在要排序的一组数中,假设前面(n-1)[n>=2] 个数已经是排好顺序的,现在要把第n个数插到前面的有序数中,使得这n个数也是排好顺序的。如此反复循环,直到全部排好顺序。
public class InsertionSort {
public int[] insertionSort(int[] A, int n) {
for(int i = 1; i<n; i++){
//如果与前一个数对比,大于前一个数,不进行对换。
for(int j = i; j > 0 && A[j]<A[j-1]; j--){
int temp = A[j];
A[j] = A[j-1];
A[j-1] = temp;
}
}
return A;
}
}
------------------------------------------------------------------------------------------------------------------------------------
希尔排序
基本思想:算法先将要排序的一组数按某个增量d(n/2,n为要排序数的个数)分成若干组,每组中记录的下标相差d.对每组中全部元素进行直接插入排序,然后再用一个较小的增量(d/2)对它进行分组,在每组中再进行直接插入排序。当增量减到1时,进行直接插入排序后,排序完成。
public class ShellSort {
public int[] shellSort(int[] A, int n) {
// write code here
int D,j;
for(D = n/2; D>0; D /= 2){
for(int i=D; i<n; i++){
int temp = A[i];
for(j=i; j>=D && A[j-D]>temp; j-=D){
A[j] = A[j-D];
}
A[j] = temp;
}
}
return A;
}
}
---------------------------------------------------------------------------------------------------------------------------------------------
堆排序
public class HeapSort {
public int[] heapSort(int[] A, int n) {
for(int i=n/2-1; i>= 0; i--)
sink(A, i, n);
for(int j=n-1; j > 0; j--){
swap(A, 0, j);
sink(A, 0, j);
}
return A;
}
private void swap(int[] A, int m, int n){
int temp = A[m];
A[m] = A[n];
A[n] = temp;
}
private void sink(int[] A, int p, int n){
int parent,child;
int x;
x = A[p];
for(parent = p; (2*parent+1)<n; parent=child){
child=2*parent+1;
if((child != n-1) && A[child]<A[child+1])
child++;
if(x>A[child])
break;
else
A[parent] = A[child];
}
A[parent] = x;
}
}
-----------------------------------------------------------------------------------------------------------------------------------------
归并排序
归并(Merge)排序法是将两个(或两个以上)有序表合并成一个新的有序表,即把待排序序列分为若干个子序列,每个子序列是有序的。然后再把有序子序列合并为整体有序序列。(速度快 nlogn ,需要占用被排序相同大小的内存空间) 缺点:占用内存空间
public class MergeSort {
public int[] mergeSort(int[] A, int n) {
// write code here
sort(A, 0, n-1);
return A;
}
public void sort(int[] A, int lo, int hi){
if(hi<=lo) return;
int mid = lo + (hi - lo) / 2;
sort(A, lo, mid);
sort(A, mid+1, hi);
merge(A, lo, mid, hi);
}
public void merge(int[] A, int lo, int mid, int hi){
int i = lo, j = mid+1;
int[] B = new int[A.length];
for(int k = lo; k <= hi; k++){
B[k] = A[k];
}
for(int k = lo; k <= hi; k++){
if(i > mid)
A[k] = B[j++];
else if(j > hi)
A[k] = B[i++];
else if(B[i] > B[j])
A[k] = B[j++];
else
A[k] = B[i++];
}
}
}
-----------------------------------------------------------------------------------------------------------------------------------------------------
快速排序
基本思想:选择一个基准元素,通常选择第一个元素或者最后一个元素,通过一趟扫描,将待排序列分成两部分,一部分比基准元素小,一部分大于等于基准元素,此时基准元素在其排好序后的正确位置,然后再用同样的方法递归地排序划分的两部分。
public class QuickSort {
public int[] quickSort(int[] A, int n) {
// write code here
sort(A, 0, n-1);
return A;
}
public void sort(int[] A, int lo, int hi){
if(hi <= lo) return;
int j = partition(A, lo, hi);
sort(A, lo, j-1);
sort(A, j+1, hi);
}
public int partition(int[] A, int lo, int hi){
int i = lo, j = hi+1;
int v = A[lo];
while(true){
while(A[++i] < v){
if(i == hi){
break;
}
}
while(v < A[--j]){
if(j == lo){
break;
}
}
if(i >= j)
break;
exch(A, i, j);
}
exch(A, lo, j);
return j;
}
public void exch(int[] A, int i, int j){
int temp = A[i];
A[i] = A[j];
A[j] = temp;
}
}
---------------------------------------------------------------------------------------------------------------------------------------------------------
选择排序
public class SelectionSort {
public int[] selectionSort(int[] A, int n) {
// write code here
for(int i=0;i<n;i++){
for(int j=i+1; j<n;j++){
if(A[j]<A[i]){
int temp = A[i];
A[i] = A[j];
A[j] = temp;
}
}
}
return A;
}
}
------------------------------------------------------------------------------------------------------------------------------------------------------------
冒泡排序
public class BubbleSort {
public int[] bubbleSort(int[] A, int n) {
// write code here
// write code here
int temp = 0;
for(int i = 0;i < n-1;i++){
for(int j = 0;j<n-i-1;j++){
if(A [j] > A [j+1]){
temp = A[j];
A[j] = A[j+1];
A[j+1] = temp;
}
}
}
return A;
}
}