八大排序算法总结

1.冒泡排序（Bubble Sort）

2.选择排序（Selection sort）

3.插入排序（Insertion sort）

4.基数排序（Radix sort）

5.希尔排序（Shell's Sort）

6.快速排序（Quicksort）

7.堆排序（Heapsort）

8.归并排序（Merge Sort）

前三种的时间复杂度为O(n^2)，后五种的时间复杂度为O(nlogn)

1.冒泡排序（Bubble Sort）

两两比较交换

public void sort(int[]arr) {
    for (int j = 0; j < arr.length-1; j++) {//控制轮数
        for (int i = 0; i < arr.length-j-1; i++)//游标移动比较
        {
            if (arr[i] > arr[i + 1]) {
                int temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
        }
    }
}

2.选择排序（Selection sort）

找到最小值和待排序数组第一个交换。

 public static void sort(int[] arr) {
    for (int j=0;j< arr.length;j++){
	      int minindex=j;
	      int min=arr[j];
	      for (int i=j+1;i< arr.length;i++){
	          if (min>arr[i]){
	         min=arr[i];
	        minindex=i;
	          }
	      }
	      //待排序数组
	      arr[minindex]=arr[j];
	      arr[j]=min;
}
}

3.插入排序（Insertion sort）

认为数组中第一个位置是已经排好序的数组，然后用一个游标 i 指向第二个位置，定义游标 j=i-1，令j 和 j+1进行比较并不断前移依次和已排好序的数组中的数据进行比较，将其有序插入到已排好序数组中。

public static void sort(int[]arr) {
for (int i=1;i< arr.length;i++){
    for (int j=i-1;j>=0;j--){
        if (arr[j]>arr[j+1]){
            int temp=arr[j];
            arr[j]=arr[j+1];
            arr[j+1]=temp;
        }else {
            break;
        }
    }
        }
}

4.基数排序（Radix sort）

基数排序又称“桶子法”、“桶排序”。总共设置十个桶，第一次先按个位放入，接着取出，然后按照十位放入再取出，仿佛仿佛这样操作，直到位数最长的数字的位数比较完毕排序完成。

public class RadixSort {
	public static void main(String[] args) {
		int[] arr = new int[] {12,98,10,123,1,15,26,30,87,96,130,97,45,68,89};
		sort(arr);
		System.out.println(Arrays.toString(arr));
	}
	
	public static void sort(int[] arr) {
		//定义桶
		int[][] bucket = new int[10][arr.length];
		//定义桶记录器
		int[] elementCounts = new int[10];
		
		// 找到数组当中的最大值
		int max = arr[0];
		for(int i = 0;i<arr.length;i++) {
			if(arr[i] > max) {
				max = arr[i];
			}
		}
		
		//找到最大值的位数
		int maxLength = (max + "").length();
		
		int n = 1;
		for(int h = 0;h<maxLength;h++) {
			//向桶内放数据
			for(int i = 0;i<arr.length;i++){
				//计算个位的值
				int element = arr[i] / n % 10;//放入到桶内
				int count = elementCounts[element];
				bucket[element][count] = arr[i];
				elementCounts[element] = elementCounts[element] + 1;
			}
			int index= 0;
			//将桶内的数据取出
			for(int k = 0;k<elementCounts.length;k++){
				if(elementCounts[k] !=0){
					for(int l = 0;l<elementCounts[k];l++){
						arr[index] = bucket[k][l];
						index++;
					}
				}
				//清空桶记录器
				elementCounts[k] = 0;
			}
			n = n * 10;
		}
	}
	
}

5.希尔排序（Shell's Sort）

将小的数据放到前边，大的数据放到后边。通过步长对数据进行分组，将步长设为数组长度的1/2，每次都能将每组在组内进行排序，小数值在前，大数值在后，然后通过改变步长，不断将步长变为上一次步长的1/2，如此反复直至完成排序。

public static void ShellSort(int[]arr){
    for(int gap = arr.length/2; gap>0; gap/=2) {
        for(int i = gap;i<arr.length;i++) {
            for(int j = i-gap;j>=0;j-=gap) {
                if(arr[j] > arr[j+gap]) {
                    int temp = arr[j];
                    arr[j] = arr[j+gap];
                    arr[j+gap] = temp;
                }
            }
        }
    }
}