排序算法

一、冒泡排序

1. 基本原理：拿每个数与它的后一位数进行比较，如果前一位比后一位大，则调换位置。每轮比较都会将比较过的数中最大的放到最后面，下一轮会少比较一次。
   其代码只要有两层循环构成，外层循环控制比较的轮数，内层循环控制每轮比较比较的次数，并判断如果前一位比后一位大，则调换其位置，继续比较下一个数。

package BubbleSort;

import java.util.Arrays;

public class BubbleSort {    //冒泡排序
	
	public static void main(String[] ages) {
		int array[] = new int[] {3,4,1,8,2,6,9,5};
		System.out.println("排序之前："+Arrays.toString(array));
		bubbleSort(array);
		System.out.println("排序之后："+Arrays.toString(array));
	}
	
	public static void bubbleSort(int array[]) {
		
		//外层循环控制比较的轮数
		for(int i=0;i<array.length-1;i++) {
			
			//内层循环控制每轮比较的次数
			for(int j=0;j<array.length-1-i;j++) {
				//判断前一个如果比后面一个大，则交换位置
				if(array[j]>array[j+1]) {
					int dex = array[j];
					array[j] = array[j+1];
					array[j+1] = dex;
				}
			}
			
		}
	}

}

2. 运行截图：
   

二、快速排序

1. 基本原理：一般将数组的第一个元素设置为基准数，记录排序的下标（开始元素下标，结束元素下标）。拿左右两端的元素与基准数作比较，右边：如果比基准数大记录排序的下标（结束元素的下标）向前移动一位，比基准数小的话用该元素替换开始数。左边：如果比基准数小的话记录排序的下标（开始元素的下标）向后移动一位，比基准数大的话用该元素替换结束元素。当记录排序的下标重合后，用基准数替换开始元素。然后以采用迭代的方式重新调用该方法将比基准数大和比基准数小的元素进行排序。

package QuickSort;

import java.util.Arrays;

public class QuickSort {    //快速排序
	public static void main(String[] args) {
		int array[]=  new int[] {4,1,5,2,6,3,7,9,8};
		System.out.println("排序之前："+Arrays.toString(array));
		quicksort(array,0,array[array.length-1]);
		System.out.println("排序之后："+Arrays.toString(array));
	}
	
	//start为开始位置，end为结束位置
	public static void quicksort(int array[],int start,int end) {    //start和end为数组开始和结束的下标
		
		if(start<end) {
		//把数组中的开始数作为标准数
		int stard = array[start];
		
		//记录排序的下标
		int low = start;    //开始下标
		int high = end;     //结束下标
		
		//循环拿左右两边的数与标准数比较
		while(low<high) {
			//右边的数标准数大
			while(low<high&&stard<=array[high]) {
				high--;    //结束下标向前移动一位
			}
			//右边的数比标准数小，将右边的数替换开始的数
			array[low] = array[high];
			
			
			//左边的数比标准数小
			while(low<high&&stard>=array[low]){
				low++;    //开始下标向后移动一位
			}
			//左边的数比标准数大，将左边的数替换结束的数
			array[high] = array[low];
		}
		
		//把标准数替换开始数
		array[low] = stard;
		
		//为所有小于标准数的数以同样的方式排序
		quicksort(array,start,low);
		
		//为所有大于标准数的数以同样的方式排序
		quicksort(array,low+1,end);
		
		
	}
	}

}

2. 运行截图：
   

三、插入排序

1. 原理：其主要由两层循环控制，外层循环控制遍历除了第一个元素以外的所有元素，判断，如果当前元素小于它前面的元素，则把它赋给一个新元素。内层循环控制遍历前面的所有元素，判断如果内层循环的当前元素大于外层循环取出的元素，则将该元素赋值给其后面的元素，内层循环结束后将外层循环取出的元素赋值给内层循环当前元素的下一个元素。

package InsertSort;

import java.util.Arrays;

public class InsertSort {     //插入排序
	public static void main(String[] ages) {
		//创建一个数组
		int array[] = new int[] {4,1,5,2,6,3,7,8,9};
		System.out.println("排序之前："+Arrays.toString(array));
		//调用插入排序方法insertSort
		insertSort(array);
		System.out.println("排序之后："+Arrays.toString(array));
	}
	
	public static void insertSort(int array[]) {
		//外层循环遍历数组中除了第一个元素外的所有元素
		for(int i=1;i<array.length;i++) {
			//判断当前元素是否比前一个数字小
			if(array[i]<array[i-1]) {
				//将当前元素赋值给一个新变量
				int nex = array[i];
			
			
			int j;
			//内层循环遍历前面所有元素
			for(j=i-1;j>=0;j--) {
				//如果上层元素循环取出的元素小于当前元素，则将当前元素赋值给其后一位元素
				if(nex<array[j])
					array[j+1] = array[j];
			}
			//内层循环结束后要将外层循环取出的元素赋值给内层循环当前元素的后一位
			array[j+1] = nex;
		}
		}
	}

}

2. 运行截图：

四、希尔排序

1. 基本原理：将整个数组分为步长相等的几个部分，分别进行插入排序。主要由三层循环构成，第一次循环控制遍历步长，第二次循环控制遍历所有元素，第三次循环控制遍历每组的元素，并判断，如果当前元素大于加上步长的元素，则交换位置。

package ShellSort;

import java.util.Arrays;

public class ShellSort {      //希尔排序
	public static void main(String[] ages) {
		int array[] = new int [] {4,1,7,5,2,8,6,9,3};
		System.out.println(" 排序之前："+Arrays.toString(array));
		shellSort(array);
		System.out.println(" 排序之后："+Arrays.toString(array));
		
	}
	
	public static void shellSort(int array[]) {
		
		int k=1;
		
		//第一层循环控制遍历步长
		for(int d = array.length/2;d>0;d=d/2) {
			//第二层循环控制遍历所有元素
			for(int i=d;i<array.length;i++) {
				//第三层遍历本组的所有元素
				for(int j=i-d;j>=0;j=j-d) {
					//判断，如果当前元素大于加上步长的元素，则调换位置。
					if(array[j]>array[j+d]) {
						int dex = array[j+d];
						array[j+d] = array[j];
						array[j] = dex;
					}
				}
			}
			System.out.println("第"+k+"次排序："+Arrays.toString(array));
			k++;
		}
	}

}

2. 运行截图：
   

五、选择排序

1. 基本原理：主要由两次循环构成，第一层循环控制遍历所有的元素，第二层循环控制遍历当前元素后面的所有元素，每次循环找出最小元素的下标与当前元素的下标进行对比，如果不是同一个元素的话调换位置，把最小的元素放到对前面。

package SelectSort;

import java.util.Arrays;

public class SelectSort {    //选择排序
	public static void main(String[] ages) {
		int array[] = new int[] {1,4,7,5,2,8,6,3,9};
		System.out.println("排序之前："+Arrays.toString(array));
		selectSort(array);
		System.out.println("排序之后："+Arrays.toString(array));
		
	}
	
	public static void selectSort(int array[]) {
		
		//外层循环遍历所有的元素
		for(int i=0;i<array.length;i++) {
			int min=i;
			
			//内层循环控制遍历所有比外层循环大
			for(int j=i+1;j<array.length;j++) {
				if(array[min]>array[j]) {
					min = j;
				}
			}
			//判断找出的最小元素下标是否是当前元素下标
			if(min != i) {
				int temp = array[i];
				array[i] = array[min];
				array[min] = temp;
			}
		}
	}

}

2. 运行截图：
   

六、归并排序

1. 基本原理：归并排序采用分治法，首先对运用递归对数组进行分割，当分割到不能再分割的时候再进行合并，遍历取出最小的数放入临时数组中，遍历到最后直接将多余的元素放入零时数组中，再将临时数组放入原来的数组中去。

package MergrSort;

import java.util.Arrays;

public class MergeSort {       //归并排序
	public static void main(String[] args) {
		int array[] = new int[] {4,1,7,5,2,8,6,3,9};
		System.out.println("排序之前："+Arrays.toString(array));
		mergeSort(array,0,array.length-1);
		System.out.println("排序之后："+Arrays.toString(array));
	}
	
	public static void mergeSort(int array[],int low,int high) {
		
		if(low<high) {
		int middle=(low+high)/2;
		
		//处理左边
		mergeSort(array,low,middle);
		//处理右边
		mergeSort(array,middle+1,high);
		
		//归并
		merge(array,low,middle,high);
		}
	}
	
	public static void merge(int array[],int low,int middle,int high) {        //合并
		//用于储存归并后元素的临时数组
		int temp[] = new int[high-low+1];
		//记录第一个数组中需要遍历元素的下标
		int i = low;
		//记录第二个数组中需要遍历元素的下标
		int j = middle+1;
		//用于记录在临时数组中存放元素的下标
		int dex = 0;
		
		//遍历两个数组中取出的小的元素，放入临时数组
		while(i<=middle&&j<=high) {
			if(array[i]<array[j]) {
				//将较小的数据放入临时数组中
				temp[dex] = array[i];
				//小标往后移动一位
				i++;
			}else {
				temp[dex] = array[j];
				j++;
			}
			dex++;
		}
		
		//处理多余的元素
		while(i<=middle) {
			temp[dex] = array[i];
			dex++;
		}
		
		while(j<=high) {
			temp[dex] = array[j];
			dex++;
		}
		
		//把临时数组中的元素重新放到原数组中
		for(int k=0;k<temp.length;k++) {
			array[k+low] = temp[k];
		}
		
		
		
	}

}

2. 运行截图：
   

七、基数排序

1. 基本原理：基数排序是一种非比较的排序方法，它将数组中的每个元素元素分别按照个位数，百位数，一直到最大位数分别存放的是个有对应序号的数组中（一个二维数组），并且按照放入时的顺序取出来，放入原来的数组中去。

package RadixSort;

import java.util.Arrays;

public class RadixSort {
	public static void main(String[] args) {
		
		int array[] = new int[] {45,126,7,66,548,69,36,5};
		System.out.println("排序之前："+Arrays.toString(array));
		radixsort(array);
		System.out.println("排序之后："+Arrays.toString(array));
		
	}
	
	public static void radixsort(int array[]) {
		//数组中最大的数
		int max = Integer.MAX_VALUE;
		for(int i=0;i<array.length;i++) {
			if(array[i]>max) {
				max = array[i];
			}
		}
		
		//计算最大数字时几位数
		int maxlength = (max+"").length();
		
		//用于临时储存数据的数组
		int temp[][] = new int [10][array.length];
		
		//用于存放在temp中相应数组存放数字的数量
		int counts[] = new int[10];
		
		//根据最大数的位数决定比较的次数
		for(int i=0,n=1;i<maxlength;i++,n*=10) {
			//把每个数组分别计算余数
			for(int j=0;j<array.length;j++) {
				//计算余数
				int ys = array[j]/n%10;
				//将当前遍历的数字存放到指定的数组中
				temp[ys][counts[ys]] = array[j];
				//记录相应桶中元素的数量
				counts[ys]++;
			}
			
			//记录元素要存放的位置
			int index = 0;
			//把数字取出来
			for(int k=0;k<counts.length;k++) {
				if(counts[k]!=0) {
					//循环取出元素
					for(int l=0;l<counts[k];l++) {
						array[index] = temp[k][l];
						index++;
					}
					//把数量设置为零
					counts[k] = 0;
				}
			}
		}
	}

}

2. 运行截图：