java中的常见8种排序算法

分类：
1）插入排序（直接插入排序、希尔排序）
2）交换排序（冒泡排序、快速排序）
3）选择排序（直接选择排序、堆排序）
4）归并排序
5）分配排序（基数排序）

所需辅助空间最多：归并排序
所需辅助空间最少：堆排序
平均速度最快：快速排序

不稳定：快速排序，希尔排序，堆排序。

1）插入排序

/*** 直接插入排序,性能比冒泡和简单选择排序好* 算法复杂度O(n*n)* @param data*/public static void insertSort(int[] data) {int temp = 0;for (int i = 1; i < data.length; i++) {int j = i - 1;temp = data[i];for (; j >= 0 && temp < data[j]; j--) {data[j + 1] = data[j];  //将大于temp的值整体后移一个单位}data[j + 1] = temp;}}

/*** 希尔排序，是选取一个增量，对整个数组分组，然后对每个小部分使其有序，* 最后对整个部分使其有序，时间复杂度是O（n^3/2）,是一种不稳定排序* @param data*/public static void shellSort(int[] data) {double d1 = data.length;int temp = 0;while (true) {d1 = Math.ceil(d1 / 2);int d = (int) d1;for (int x = 0; x < d; x++) {for (int i = x + d; i < data.length; i += d) {int j = i - d;temp = data[i];for (; j >= 0 && temp < data[j]; j -= d) {data[j + d] = data[j];}data[j + d] = temp;}}if (d == 1) {break;}}}

2）交换排序

/*** 冒泡排序从下到大优化了的冒泡排序* 冒泡排序的时间复杂度是O(n*n)* @param data* @return*/public static int[] sort(int[] data) {int temp;boolean flag = false;for (int i = 0; i < data.length - 1; i++) {flag = true;for (int j = 0; j < data.length - i - 1; j++) {if (data[j] > data[j + 1]) {temp = data[j];data[j] = data[j + 1];data[j + 1] = temp;flag = false;}}//如果有一次内层循环没有交换排序，则说明数组已经有序了，直接退出，不用进行下一轮冒泡循环,提高效率if (flag) {break; //可以注释这一行，单步测试或者查看i的值即可验证}System.out.println(i);}return data;}

/*** 快速排序，* 选择一个基准元素,通常选择第一个元素或者最后一个元素,通过一趟扫描，* 将待排序列分成两部分,一部分比基准元素小,一部分大于等于基准元素,* 此时基准元素在其排好序后的正确位置,然后再用同样的方法递归地排序划分的两部分。* @param data*/public static void quickSort(int[] data) {quick(data);}private static int getMiddle(int[] list, int low, int high) {int tmp = list[low];    //数组的第一个作为中轴while (low < high) {while (low < high && list[high] >= tmp) {high--;}list[low] = list[high];   //比中轴小的记录移到低端while (low < high && list[low] <= tmp) {low++;}list[high] = list[low];   //比中轴大的记录移到高端}list[low] = tmp;              //中轴记录到尾return low;                   //返回中轴的位置}private static void _quickSort(int[] list, int low, int high) {if (low < high) {int middle = getMiddle(list, low, high);  //将list数组进行一分为二_quickSort(list, low, middle - 1);       //对低字表进行递归排序_quickSort(list, middle + 1, high);       //对高字表进行递归排序}}private static  void quick(int[] a2) {if (a2.length > 0) {    //查看数组是否为空_quickSort(a2, 0, a2.length - 1);}}

3）选择排序

/*** 简单选择排序，从小到大*时间复杂度是O(n*n)* @param data*/public static void selectSort(int[] data) {int min_pos = 0;for (int i = 0; i < data.length; i++) {min_pos = i;int min = data[i];for (int j = i + 1; j < data.length; j++) {if (data[j] < min) {min = data[j];min_pos = j;}}data[min_pos] = data[i];data[i] = min;}}

/*** 堆排序是对直接选择排序的改良* 时间复杂度是O(n*Logn)* @param data*/public static void heapSort(int[] data){int arrayLength = data.length;for(int i=0;i<arrayLength-1;i++){buildMaxHeap(data,arrayLength-1-i);swap(data,0,arrayLength-1-i);}}private static void swap(int[] data,int i,int j){int tmp = data[i];data[i] =data[j];data[j] = tmp;}private static void buildMaxHeap(int[] data,int lastIndex){for(int i=(lastIndex-1)/2;i>=0;i--){int k=i;while(k*2+1<=lastIndex){int biggerIndex = 2*k+1;if(biggerIndex<lastIndex){if(data[biggerIndex]<data[biggerIndex+1]){biggerIndex++;}}if(data[k]<data[biggerIndex]){swap(data,k,biggerIndex);k=biggerIndex;}else{break;}}}}

4）归并排序

/*** 归并排序* 比较占用内存，但是高效稳定的排序算法* 是将两个（或两个以上）有序表合并成一个新的有序表* @param data*/public static void mergeSort(int[] data) {sort(data, 0, data.length - 1);}private static void sort(int[] data, int left, int right) {if (left < right) {//找出中间索引int center = (left + right) / 2;//对左边数组进行递归sort(data, left, center);//对右边数组进行递归sort(data, center + 1, right);//合并merge(data, left, center, right);}}private static void merge(int[] data, int left, int center, int right) {int[] tmpArr = new int[data.length];int mid = center + 1;//third记录中间数组的索引int third = left;int tmp = left;while (left <= center && mid <= right) {//从两个数组中取出最小的放入中间数组if (data[left] <= data[mid]) {tmpArr[third++] = data[left++];} else {tmpArr[third++] = data[mid++];}}//剩余部分依次放入中间数组while (mid <= right) {tmpArr[third++] = data[mid++];}while (left <= center) {tmpArr[third++] = data[left++];}//将中间数组中的内容复制回原数组while (tmp <= right) {data[tmp] = tmpArr[tmp++];}}

5）基数排序

/*** 基数排序* 将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。* 然后，从最低位开始，依次进行一次排序。* 这样从最低位排序一直到最高位排序完成以后,数列就变成一个有序序列。* @param data*/public static void radixSort(int[] data) {sort(data);}private static void sort(int[] array) {//首先确定排序的趟数;int max = array[0];for (int i = 1; i < array.length; i++) {if (array[i] > max) {max = array[i];}}int time = 0;//判断位数;while (max > 0) {max /= 10;time++;}//建立10个队列;List<ArrayList> queue = new ArrayList<ArrayList>();for (int i = 0; i < 10; i++) {ArrayList<Integer> queue1 = new ArrayList<Integer>();queue.add(queue1);}//进行time次分配和收集;for (int i = 0; i < time; i++) {//分配数组元素;for (int j = 0; j < array.length; j++) {//得到数字的第time+1位数;int x = array[j] % (int) Math.pow(10, i + 1) / (int) Math.pow(10, i);ArrayList<Integer> queue2 = queue.get(x);queue2.add(array[j]);queue.set(x, queue2);}int count = 0;//元素计数器;//收集队列元素;for (int k = 0; k < 10; k++) {while (queue.get(k).size() > 0) {ArrayList<Integer> queue3 = queue.get(k);array[count] = queue3.get(0);queue3.remove(0);count++;}}}}