排序算法，java

内排序和外排序：需要额外的存储空间为外排序。

内排序：

1、插入排序：直接插入排序、二分插入排序、shell排序；

2、选择排序：简单选择排序、堆排序；

3、交换排序：冒泡排序、快速排序。

外排序：

1、归并排序；

2、基排序。

稳定性：排序前两个相等的数在序列中的先后顺序与排序后的它们的先后位置顺序相同。

不稳定排序：shell排序、简单选择排序、堆排序、快速排序；

稳定排序：直接插入排序、二分插入排序、冒泡排序、归并排序、基排序。

package sort;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Sort {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		while (sc.hasNext()) {
			String line = sc.nextLine();
			String [] str = line.split(" ");
			int [] arr = new int[str.length];
			for (int i = 0; i < str.length; i++) {
				arr[i] = Integer.parseInt(str[i]);
			}
			insertSort(arr);
//			binaryInsertSort(arr);
//			shellSort(arr);
//			selectionSort(arr);
//			bubbleSort(arr);
//			quickSort(arr);
//			mergeSort(arr);
//			radixSort(arr);
			for(int a:arr) {
				System.out.print(a + " ");
			}
			
		}

	}
	
	/*
	 * 插入排序
	 * 稳定排序，平均时间复杂度为O(n2)
	 */
	public static void insertSort(int [] arr) {
		for (int i = 1; i < arr.length; i++) {
			int tmp = arr[i];
			while (i > 0) {
				if (tmp < arr[i - 1]) {
					arr[i] = arr[i -1];
					i--;
				} else {
					break;
				}
			}
			arr[i] = tmp;
		}
	}
	
	/*
	 * 二分插入排序
	 * 稳定排序，平均时间复杂度为O(n2)
	 */
	
	public static void binaryInsertSort(int [] arr) {
		for (int i = 1; i < arr.length; i++) {
			int tmp = arr[i];
			int low = 0;
			int high = i - 1;
			int mid = 0;
			while (low <= high) {
				mid = (low + high)/2;
				if (arr[i] < arr[mid]) {
					high = mid - 1;
				} else {
					low = mid + 1;
				}
			}
			for (int j = i - 1; j >= low; j--) {
				arr[j + 1] = arr[j];
			}
			arr[low] = tmp;
		}
	}
	
	/*
	 * Shell排序
	 * 不稳定的排序，平均时间复杂度为O(nlogn)
	 */
	public static void shellSort(int [] arr) {
		int N = arr.length;
		int h = 1;
//		第一次每组最多3个元素
		while (h < N/3) {
			h = h*3 + 1;
		}
		while (h >= 1) {
			for (int i = h; i < arr.length; i++) {
				int tmp = arr[i];
				int j = i;
				for (; j >= h; j -= h) {
					if (arr[j - h] > tmp) {
						arr[j] = arr[j - h];
					} else {
						break;
					}
				}
				arr[j] = tmp;
				
			}
			h /= 3;
		}
	}
	
	/*
	 * 选择排序，每次选出剩余中最小的元素
	 * 不稳定的排序，平均时间复杂度为O(n2)
	 */
	public static void selectionSort(int [] arr) {
		for (int i = 0; i < arr.length; i++) {
			int min = arr[i];
			int index = i;
			for (int j = i + 1; j < arr.length; j++) {
				if (arr[j] < min) {
					min = arr[j];
					index = j;
				}
			}
			if(index != i) {
				arr[index] = arr[i];
				arr[i] = min;
			}
		}
	}
	
	/*
	 * 堆排序，完全二叉树
	 * 不稳定的排序，最坏的时间复杂度为O(nlogn)
	 * 初始建堆的比较次数较多，堆排序不适合元素较少的情况
	 */
	public static void heapSort(int [] arr) {
		
	}
	
	/*
	 * 冒泡排序
	 * 稳定的排序，平均时间复杂度为O(n2)
	 */
	public static void bubbleSort(int [] arr) {
		for (int i = 0; i < arr.length; i++) {
			for (int j = 0; j < arr.length - i - 1; j++) {
				if (arr[j] > arr[j + 1]) {
					int tmp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = tmp;
				}
			}
		}
	}
	
	/*
	 * 快速排序
	 * 不稳定的排序，时间复杂度为O(nlogn)
	 * 快速排序适合n较大时，当序列基本有序时，不适合用快速排序
	 */
	public static void quickSort(int [] arr) {
		quickSort(arr, 0, arr.length - 1);
	}
	
	public static void quickSort(int [] arr, int low, int high) {
		if(low < high) {
			int middle = getMiddle(arr, low, high);
			quickSort(arr, 0, middle - 1);
			quickSort(arr, middle + 1, high);
		}
	} 

	public static int getMiddle(int [] arr, int low, int high) {
		int tmp = arr[low];
		while (low < high) {
			while (low < high && arr[high] >= tmp) {
				high--;
			}
			arr[low] = arr[high];
			while(low < high && arr[low] <= tmp) {
				low++;
			}
			arr[high] = arr[low];
		}
		arr[low] = tmp;
		return low;
	}
	
	/*
	 * 归并排序
	 * 稳定的排序，时间复杂度为O(nlogn)
	 * 一般用于对总体有序，但对各子项相对有序的数列
	 */
	static int [] aux;
	public static void mergeSort(int [] arr) {
		aux = new int[arr.length];
		mergeSort(arr, 0, arr.length - 1);
	}
	
	public static void mergeSort(int [] arr, int low, int high) {
		if (low < high) {
			int mid = (low + high) / 2;
			mergeSort(arr, low, mid);
			mergeSort(arr, mid + 1, high);
			merge(arr, low, mid, high);
		}
	}
	
	public static void merge(int [] arr, int low, int mid, int high) {
		int[] tmpArr = new int[arr.length];
        int middle = mid + 1; 
        int tmp = low;
        int third = low;
        while (low <= mid && middle <= high) {
            if (arr[low] <= arr[middle]) {
                tmpArr[third++] = arr[low++];
            } else {
                tmpArr[third++] = arr[middle++];
            }
        }
        
        while (low <= mid) {
            tmpArr[third++] = arr[low++];
        }
        while (middle <= high) {
            tmpArr[third++] = arr[middle++];
        }
        
        while (tmp <= high) {
            arr[tmp] = tmpArr[tmp++];
        }
	}
	
	/*
	 * 基排序
	 * 稳定的排序，时间复杂度为O(d(n+r)),d为位数，r为基数
	*/
	public static void radixSort(int [] arr) {
		 int max = 0;
	        for (int i = 0; i < arr.length; i++) {
	            if(max
  
  
   
   0){
	            max = max/10;
	            times++;
	        }
	        
	        List
   
   
    
     queue = new ArrayList
    
    
     
     ();
	        for (int i = 0; i < 10; i++) {
	            ArrayList queue1 = new ArrayList();
	            queue.add(queue1);
	        }
	        
	        for (int i = 0; i < times; i++) {
	            
	            for (int j = 0; j < arr.length; j++) {
	                int x = arr[j]%(int)Math.pow(10, i+1)/(int)Math.pow(10, i);
	                ArrayList queue2 = queue.get(x);
	                queue2.add(arr[j]);
	                queue.set(x,queue2);
	            }
	            
	            int count = 0;
	            for (int j = 0; j < 10; j++) {
	                while(queue.get(j).size()>0){
	                    ArrayList
     
     
      
       queue3 = queue.get(j);
	                    arr[count] = queue3.get(0);
	                    queue3.remove(0);
	                    count++;
	                }
	            }
	        }
	}
}