一些排序的总结和代码

冒泡排序：挨着的数两两比较，最大的数浮到最后。
选择排序：令min=a[0]，每一趟选出最小值=min,得出其索引index，与a[0]交换
插入排序：将数据一个一个插入第一个数所在的数组
希尔排序——交换法;
快速排序（递归）：以中间个数为基准，比其小的放左边，比其大的放右边，分别向左向右递归。
基数排序：将数字以个十百位（取决于最大数的位数）来依次放入0-9的桶中（数组），最后取出的是有序数组。

归并排序（递归）：先分解数据，然后组合。合并分三步
1.mid左右有序的数字比较，小的依次填入temp数组，
2.mid左右剩余的数字填入temp尾部
3.将temp拷贝到数组arr

package com.atguigu.sort;

import java.util.Arrays;

public class BubbleSort {

	public static void main(String[] args) {
		int[] arr1 = new int[10];
		for(int i =0; i <10;i++) {
			arr1[i] = (int)(Math.random() * 100); //生成一个长度随机的随机数组 范围小于1000
		}
		BubbleSort(arr1);
		System.out.println("冒泡："+Arrays.toString(arr1));//输出
		
		int[] arr2 = new int[10];
		for(int i =0; i < 10;i++) {
			arr2[i] = (int)(Math.random() * 100); //生成一个随机数组
		}
		SelectSort(arr2);
		System.out.println("选择排序："+Arrays.toString(arr2));//输出
		
		int[] arr3 = new int[10];
		for(int i =0; i < 10;i++) {
			arr3[i] = (int)(Math.random() * 100); //生成一个随机数组
		}
		SelectSort(arr3);
		System.out.println("插入排序："+Arrays.toString(arr3));//输出
		
		
		int[] arr4 = new int[10];
		for(int i =0; i < 10;i++) {
			arr4[i] = (int)(Math.random() * 100); //生成一个随机数组
		}
	    shellSort(arr4);
		System.out.println("希尔排序——交换法："+Arrays.toString(arr4));//输出
		
		
		int[] arr5 = new int[10];
		for(int i =0; i < 10;i++) {
			arr5[i] = (int)(Math.random() * 100); //生成一个随机数组
		}
	    QuickSort(arr5, 0,arr5.length-1);
		System.out.println("快速排序"+Arrays.toString(arr5));//输出
		
		int[] arr6 = new int[10];
		for(int i =0; i < 10;i++) {
			arr6[i] = (int)(Math.random() * 100); //生成一个随机数组
		}
	    radixSort(arr6);
		System.out.println("基数排序"+Arrays.toString(arr6));//输出
		
	}
	
	
	
//冒泡排序法：挨着的两两比较，筛选出最大值放在最后。外层length-1，内层length-1-i	
	public static void BubbleSort(int arr[]) {
		int temp=0;
		//排序length-1趟
		for (int i = 0; i<arr.length-1; i++) {
			for (int j = 0; j < arr.length-1-i; j++) {
				if(arr[j]>arr[j+1]) {
					temp=arr[j];
					arr[j]=arr[j+1];
					arr[j+1]=temp;
				}
			}		
		}
	}
//选择排序法：最小的先出来，排在前面。比冒泡快
			//	i从0开始，设arr[i]为最小值，和后面的比较，得出最小值的索引minindex（即j），
			//	交换a[i]和最小值a[minindex];
	public static void SelectSort(int arr[]) {

		for (int i = 0; i < arr.length-1; i++) {
			int min=arr[i];
			int minindex=i;
			for (int j = i+1; j < arr.length; j++) {
					if (min>arr[j]) {
						min=arr[j];
						minindex=j;
					}
			}
			if (minindex !=i) {
				arr[minindex]=arr[i];
				arr[i]=min;
			}
		}
	}
//插入排序	 将数据一个一个插入第一个数据的数组中，从后往前比较
	public static void InsertSort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            int temp = arr[i];
            //j必须是有效的 且temp<前一个数字才插入
            for (int j = i; temp < arr[j - 1] && j > 0; j--) {
                arr[j] = arr[j - 1];
                arr[j - 1] = temp;
            }
        }
    }
	//老师的插入排序
	/*public static void InsertSort(int[] arr) {
	int insertVal = 0;
	int insertIndex = 0;
	//使用for循环来把代码简化
	for(int i = 1; i < arr.length; i++) {
		//定义待插入的数
		insertVal = arr[i];
		insertIndex = i - 1; // 即arr[1]的前面这个数的下标

		// 给insertVal 找到插入的位置
		// 说明
		// 1. insertIndex >= 0 保证在给insertVal 找插入位置，不越界
		// 2. insertVal < arr[insertIndex] 待插入的数，还没有找到插入位置
		// 3. 就需要将 arr[insertIndex] 后移
		while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
			arr[insertIndex + 1] = arr[insertIndex];// arr[insertIndex]
			insertIndex--;
		}
		// 当退出while循环时，说明插入的位置找到, insertIndex + 1
		// 举例：理解不了，我们一会 debug
		//这里我们判断是否需要赋值
		if(insertIndex + 1 != i) {
			arr[insertIndex + 1] = insertVal;
		}
	}
}*/
//希尔排序——插入排序的进阶——交换法
	public static void shellSort(int[] arr) {
		
		int temp = 0;
		int count = 0;
		// 根据前面的逐步分析，使用循环处理
		for (int gap = arr.length / 2; gap > 0; gap /= 2) {
			for (int i = gap; i < arr.length; i++) {
				// 遍历各组中所有的元素(共gap组，每组有个元素), 步长gap
				for (int j = i - gap; j >= 0; j -= gap) {
					// 如果当前元素大于加上步长后的那个元素，说明交换
					if (arr[j] > arr[j + gap]) {
						temp = arr[j];
						arr[j] = arr[j + gap];
						arr[j + gap] = temp;
					}
				}
			}
			System.out.println("希尔排序第" + (++count) + "轮 =" + Arrays.toString(arr));
		}
	}
	
//快速排序：以中间数为基准，左边的比他小，右边的比他大，然后左右分别递归。
	public static void QuickSort(int arr[],int left,int right) {
		int temp=0;
		int l=left;
		int r=right;
		int pivot=arr[(l+r)/2];
	//while循环的目的是让比pivot值小放到左边, 比pivot值大放到右边
		while (l<r) {
			while (arr[l]<pivot) {
				l++;	
			}
			while (arr[r]>pivot) {
				r--;	
			}
		//如果左边本来就小于pivot,右边本来就大于pivot,不交换就要退出	
			if (l>=r) {
				break;
			}	
		//如果要交换	
			temp=arr[l];
			arr[l]=arr[r];
			arr[r]=temp;
		//如果交换完后，发现这个arr[l] == pivot值 相等 r--， 前移	
			if (arr[l]==pivot) {
				r--;
			}
		//如果交换完后，发现这个arr[r] == pivot值 相等 l++， 后移	
			if (arr[r]==pivot) {
				l++;
			}	
		}
		
    //递归       如果 l == r, 必须l++, r--, 否则为出现栈溢出
		if (l==r) {
			l++;
			r--;
		}
		if (left<r) {
			QuickSort(arr, left, r);
		}
		if (right>l) {
			QuickSort(arr, l, right);
		}	
	}
	
//基数排序
	
	public static void radixSort(int[] arr) {
			
		//1. 得到数组中最大的数的位数
		int max = arr[0]; 
		for(int i = 1; i < arr.length; i++) {
			if (arr[i] > max) {
				max = arr[i];
			}
		}
		//得到最大数是几位数
		int maxLength = (max + "").length();
		
		//定义一个二维数组，表示10个桶, 每个桶就是一个一维数组
		//说明
		//1. 二维数组包含10个一维数组
		//2. 为了防止在放入数的时候，数据溢出，则每个一维数组(桶)，大小定为arr.length
		//3. 需要明确，基数排序是使用空间换时间的经典算法
		int[][] bucket = new int[10][arr.length];
		
		//为了记录每个桶中，实际存放了多少个数据,我们定义一个一维数组来记录各个桶的每次放入的数据个数
		//比如：bucketElementCounts[0] , 记录的就是  bucket[0] 桶的放入数据个数
		int[] bucketElementCounts = new int[10];
		
		for(int i = 0 , n = 1; i < maxLength; i++, n *= 10) {
			//(针对每个元素的对应位进行排序处理)， 第一次是个位，第二次是十位，第三次是百位..
			for(int j = 0; j < arr.length; j++) {
				//取出每个元素的对应位的值
				int digitOfElement = arr[j] / n % 10;
				//放入到对应的桶中
				bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
				bucketElementCounts[digitOfElement]++;
			}
			//按照这个桶的顺序(一维数组的下标依次取出数据，放入原来数组)
			int index = 0;
			//遍历每一桶，并将桶中是数据，放入到原数组
			for(int k = 0; k < bucketElementCounts.length; k++) {
				//如果桶中，有数据，我们才放入到原数组
				if(bucketElementCounts[k] != 0) {
					//循环该桶即第k个桶(即第k个一维数组), 放入
					for(int l = 0; l < bucketElementCounts[k]; l++) {
						//取出元素放入到arr
						arr[index++] = bucket[k][l];
					}
				}
				//第i+1轮处理后，需要将每个 bucketElementCounts[k] = 0 ！！！！
				bucketElementCounts[k] = 0;
				
			}			
		}
	}
}

归并排序

package com.atguigu.sort;

import java.util.Arrays;

public class MergetSort {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		int arr[]= {11,55,82,0,5,56,125,22,18,26};
		int temp[] = new int[arr.length]; //归并排序需要一个额外空间
 		mergeSort(arr, 0, arr.length - 1, temp);
 		System.out.println("归并排序="+Arrays.toString(arr));
	}
//归并排序，先分解，再合并。
	//分+合方法
	public static void mergeSort(int[] arr, int left, int right, int[] temp) {
		if(left < right) {
			int mid = (left + right) / 2; //中间索引
			//向左递归进行分解
			mergeSort(arr, left, mid, temp);
			//向右递归进行分解
			mergeSort(arr, mid + 1, right, temp);
			//合并
			merge(arr, left, mid, right, temp);
			
		}
	}
	
	//合并的方法
	/**
	 * 
	 * @param arr 排序的原始数组
	 * @param left 左边有序序列的初始索引
	 * @param mid 中间索引
	 * @param right 右边索引
	 * @param temp 做中转的数组
	 */
	public static void merge(int[] arr, int left, int mid, int right, int[] temp) {
		
		int i = left; // 初始化i, 左边有序序列的初始索引
		int j = mid + 1; //初始化j, 右边有序序列的初始索引
		int t = 0; // 指向temp数组的当前索引
		
		//(一)
		//先把左右两边(有序)的数据按照规则填充到temp数组
		//直到左右两边的有序序列，有一边处理完毕为止
		while (i <= mid && j <= right) {//继续
			//如果左边的有序序列的当前元素，小于等于右边有序序列的当前元素
			//即将左边的当前元素，填充到 temp数组 
			//然后 t++, i++
			if(arr[i] <= arr[j]) {
				temp[t] = arr[i];
				t += 1;
				i += 1;
			} else { //反之,将右边有序序列的当前元素，填充到temp数组
				temp[t] = arr[j];
				t += 1;
				j += 1;
			}
		}
		
		//(二)
		//把有剩余数据的一边的数据依次全部填充到temp
		while( i <= mid) { //左边的有序序列还有剩余的元素，就全部填充到temp
			temp[t] = arr[i];
			t += 1;
			i += 1;	
		}
		
		while( j <= right) { //右边的有序序列还有剩余的元素，就全部填充到temp
			temp[t] = arr[j];
			t += 1;
			j += 1;	
		}
		
		
		//(三)
		//将temp数组的元素拷贝到arr
		//注意，并不是每次都拷贝所有
		t = 0;
		int tempLeft = left; // 
		//第一次合并 tempLeft = 0 , right = 1 //  tempLeft = 2  right = 3 // tL=0 ri=3
		//最后一次 tempLeft = 0  right = 7
		while(tempLeft <= right) { 
			arr[tempLeft] = temp[t];
			t += 1;
			tempLeft += 1;
		}
		
	}
}