八种排序java实现

8种排序方法的java实现，均来自于算法导论的伪代码实现。

第一种：插入排序【看注释】

 * 插入排序：原址排序，比较排序* * 时间复杂度：o(n²)* * page-10* **/
public class InsertSortArray {public static void main(String[] args) {int a[] = { 5, 2, 4, 6, 1, 3 };// 由于Java中除了基本数据类型是按值传递以外，其他的都是按引用传递的，修改的都是源数据。insertionSort(a);// 打印输出结果for (int i = 0; i < a.length; i++) {System.out.print(a[i] + " ");}}/*** @param a:待排序的数组*/private static void insertionSort(int[] a) {// 从第二个数开始插入比较for (int j = 1; j < a.length; j++) {// key代表即将插入的数字int key = a[j];// 从插入位置左边第一个位置开始比较int i = j - 1;// 一直向左移动，key小于谁，就放置在谁的左边第一个位置while (i >= 0 && a[i] > key) {// key需要插入当前位置的左边，则需要把比他大的向右移动a[i + 1] = a[i];i--;}// 跳出循环的时候，a[i]<key，a[i+1]=key是必须的a[i + 1] = key;}}}

第二种：并归排序

/*** 归并排序：非原址排序，比较排序* * * * 时间复杂度：o(nlogn)* * **/
public class MergeSortArray {/*** * @param array：带排序的数组* @param start：需要排序数组的开始下标* @param end：需要排序数组的结束下标，array.length-1*/private static void mergeSort(int[] array, int start, int end) {if (start < end) {// 1、二分数组int mid = (start + end) / 2;mergeSort(array, start, mid);mergeSort(array, mid + 1, end);// 2、合并数组merge(array, start, mid, end);}}/*** 合并数组* * @param array* @param start* @param mid* @param end*/private static void merge(int[] array, int start, int mid, int end) {// 得到左右两边数组的长度int left = mid - start + 1;int right = end - mid;// 创建一个缓存数组，分别存储左右数组的值// 数组的长度比实际的大1int left_array[] = new int[left + 1];int right_array[] = new int[right + 1];for (int i = 0; i < left; i++) {left_array[i] = array[start + i];}for (int i = 0; i < right; i++) {right_array[i] = array[mid + 1 + i];}// 最后一个对于的位置，存放数组结束表标志left_array[left] = Integer.MAX_VALUE;right_array[right] = Integer.MAX_VALUE;int i = 0;int j = 0;for (int k = start; k <= end; k++) {if (left_array[i] <= right_array[j]) {array[k] = left_array[i];i = i + 1;} else {array[k] = right_array[j];j = j + 1;}}}public static void main(String[] args) {int a[] = { 5, 2, 4, 7, 1, 3, 2, 6 };// 把数组指定的下标支架的数据排序// 如果是整个数组，则传入 0和length-1mergeSort(a, 3, 4);// 打印输出结果for (int i = 0; i < a.length; i++) {System.out.print(a[i] + " ");}}
}

第三种：堆排序

/*** 堆排序：原址排序，比较排序* * @author luopan**/
public class HeapSortArray {/*** 维护最大堆的性质函数* * 注意：只能调整指定位置* * 时间复杂度：o(logn)，o(h)【h是树的高度】* * @param array：这个数组存储的可能不是一个具有最大堆性质的，但是经过这个函数以后，返回一个具有最大堆性质的堆。* @param index:默认数组的下表是从0开始的*/private static void max_heapify(int array[], int index, int heap_size) {int left = 2 * index + 1;// index的左孩子int right = 2 * (index + 1);// index的右孩子int largest = -1;// 左孩子比父结点的值大if (left < heap_size && array[left] > array[index]) {largest = left;} else {largest = index;}// 右孩子比largest点的值大if (right < heap_size && array[right] > array[largest]) {largest = right;}if (largest != index) {int tmp = array[index];array[index] = array[largest];array[largest] = tmp;max_heapify(array, largest, heap_size);}}/*** 传入一个数组，得到一个最大堆数组* * @param array*/private static void build_max_heap(int array[]) {int heap_size = array.length;for (int i = array.length / 2; i >= 0; i--) {max_heapify(array, i, heap_size);}}/*** 堆排序算法* * @param array*/private static void heap_sort(int array[]) {// 第一步，创建一个最大堆build_max_heap(array);int heap_size = array.length;// 数组的最大值一定在array[0]上for (int i = array.length - 1; i >= 1; i--) {// 把array[0]中最大数调整到array[i]中int tmp = array[0];array[0] = array[i];array[i] = tmp;// 然后把array[0...length-2]调整成最大堆heap_size--;max_heapify(array, 0, heap_size);}}public static void main(String[] args) {int a[] = { 1, 2, 3, 4, 7, 8, 9, 10, 14, 16 };// int a[] = { 35, 10, 20, 9, 8, 19, 17, 7, 6, 5, 4, 16, 15 };build_max_heap(a);System.out.println("最大堆如下：");for (int i = 0; i < a.length; i++) {if (i == a.length - 1) {System.out.print(a[i]);} else {System.out.print(a[i] + ",");}}heap_sort(a);System.out.println("\n堆排序以后的：");for (int i = 0; i < a.length; i++) {if (i == a.length - 1) {System.out.print(a[i]);} else {System.out.print(a[i] + ",");}}}
}

第四种：快速排序

/*** 快速排序，原址排序，比较排序* * 最坏情况的时间复杂度是o(n²)，期望时间复杂度是o(nlogn)* * 快速排序也采用分治思想：* * A[p..r]===>A[p..q-1]和A[q+1..r]* * A[p..q-1]<A[q]且A[q+1..r]>A[q+1]* * 中间值的选择是随机的，那么程序执行的时间复杂度就是随机的。* */
public class QuickSortArray {/*** 快速排序* * @param array* @param start：需要排序的开始下标* @param end：需要排序的结束下标*/private static void quick_sort(int array[], int start, int end) {if (start < end) {int q = quick_partion(array, start, end);quick_sort(array, start, q - 1);quick_sort(array, q + 1, end);}}/*** 计算下标q成为快速排序最关键的一部分* * @param array* @param start* @param end* @return 返回分割下标q*/private static int quick_partion(int array[], int start, int end) {// 1、选取用于分割数组为两部分的中间值【真的是随机选取】int x = array[end];// 2、选取一个下标int i = start - 1;// 3、循环寻找适当的下标q【只能循环到end-1，因为end已经被使用了】for (int j = start; j < end; j++) {if (array[j] <= x) {// 找到比中间值x小的值i = i + 1;int tmp = array[i];array[i] = array[j];array[j] = tmp;}}// 4、在循环结束的时候，需要把中间值移动到适当的位置int tmp = array[end];array[end] = array[i + 1];array[i + 1] = tmp;return i + 1;}public static void main(String[] args) {// int a[] = { 1, 2, 3, 4, 7, 8, 9, 10, 14, 16 };int a[] = { 35, 10, 20, 9, 8, 19, 17, 7, 6, 5, 4, 16, 15 };quick_sort(a, 0, a.length - 1);System.out.println("快速排序以后：");for (int i = 0; i < a.length; i++) {if (i == a.length - 1) {System.out.print(a[i]);} else {System.out.print(a[i] + ",");}}}
}

第五种：快速排序的随机化版本

/**** 快速排序的随机化版本* * 与始终选取array[end]作为中间值不同，我们采用一种随机抽样技术，使得数组分割更加的平衡* * i = RANDOM(start,end)：从start到end之间随机选取一个下标* * 然后，exchange array[i] 和 array[end]* * 接下来就直接使用QuickSortArray的程序即可。**/
public class QuickRandomSortArray {public static void main(String[] args) {}
}

第六种：计数排序

/*** 计数排序：假设n个输入元素中的每个都在0-k区间，并且假设数组元素属于一个小区间内的整数* * 对于每一个输入元素x，确定小于x的元素个数。* * 利用这个信息，就可以直接把x放到它的输出数组的位置上了* * 额外的tmpArray浪费了很多的空间，如果分布范围很大，但是很稀疏，则就有空间浪费的问题了。**/
public class CountingSortArray {/*** 计数排序* * @param inArray：输入待排序数组* @param outArray：输出结果数组* @param k：数组的范围*/private static void counting_sort(int inArray[], int outArray[], int k) {// 1、创建一个临时数组，并且全部赋值为0int tmpArray[] = new int[k + 1];for (int i = 0; i <= k; i++) {tmpArray[i] = 0;}// 2、统计输入数组的每个元素的频率for (int i = 0; i < inArray.length; i++) {tmpArray[inArray[i]] = tmpArray[inArray[i]] + 1;}// 3、统计出小于或者等i的个数for (int i = 1; i <= k; i++) {tmpArray[i] = tmpArray[i - 1] + tmpArray[i];}// 4、按照小于等于i的个数，确定每个元素的位置for (int i = inArray.length - 1; i >= 0; i--) {// 【注意】由于outArray在按照0的下标开始的，但是统计次数的时候是从1开始的，所以需要减去1outArray[tmpArray[inArray[i]] - 1] = inArray[i];tmpArray[inArray[i]] = tmpArray[inArray[i]] - 1;// 把统计数次减1，是为处理相同元素的手段}}public static void main(String[] args) {int a[] = { 2, 5, 3, 0, 2, 3, 0, 3 };int out[] = new int[a.length];counting_sort(a, out, 5);System.out.println("计数排序以后：");for (int i = 0; i < out.length; i++) {if (i == out.length - 1) {System.out.print(out[i]);} else {System.out.print(out[i] + ",");}}}
}

第七种：基数排序

/*** 基数排序：* * 数组所有元素中位数最高d* * 按照最低位有效进行排序，然后合并在一起。**/
public class RadixSortArray {/*** 计算得到数值指定位置的数字* * @param num* @param pos：pos=1代表个位，pos=2代表十位以此类推* @return*/private static int getNumInpos(int num, int pos) {int tmp = 1;for (int i = 0; i < pos - 1; i++) {tmp *= 10;}return (num / tmp) % 10;}/*** * @param array* @param d*/private static void radix_sort(int array[], int d) {int tmp[] = new int[array.length];// 下标0-9，分别代表0-9这10个数int radix[] = new int[10];// 从低位向最高位遍历，1代表个位，2代表十位，以此类推for (int i = 1; i <= d; i++) {// 1、把数组复制到缓存数组中System.arraycopy(array, 0, tmp, 0, array.length);Arrays.fill(radix, 0);// 2、遍历数组，获取个十百千万...关键字for (int j = 0; j < tmp.length; j++) {int key = getNumInpos(tmp[j], i);radix[key]++;}// 3、统计出小于或者等于的个数for (int j = 1; j < radix.length; j++) {radix[j] = radix[j - 1] + radix[j];}// System.out.print("第" + i + "位个数统计:");// for (int j = 0; j < radix.length; j++) {// System.out.print(radix[j] + " ");// }// 4、按照小于等于的个数，更新array的元素位置for (int m = array.length - 1; m >= 0; m--) {int key = getNumInpos(tmp[m], i);// 和计数排序是一样的，调整数组元素该存放的位置上即可array[radix[key] - 1] = tmp[m];radix[key]--;// 遇到相同的元素，我们需要把次数减1，然后供下次出现填充}// System.out.println();//换行调试}}public static void main(String[] args) {int array[] = { 329, 457, 657, 839, 436, 720, 355 };radix_sort(array, 3);System.out.println("计数排序以后：");for (int i = 0; i < array.length; i++) {if (i == array.length - 1) {System.out.print(array[i]);} else {System.out.print(array[i] + ",");}}}
}

第八种：桶排序

import java.util.ArrayList;
import java.util.Collections;/*** * 桶排序：假设输入数据服从均匀分布，这样的话排序的时间复杂度是：o(n)* * 也就是说数组元素分布在：[0,1)区间* * 桶排序将[0,1)区间划分为n个相同大小的区间，称为桶* * **/
public class BucketSortArray {/*** 桶排序数组* * @param array*/private static void bucket_sort(int array[]) {// 1、计算待排数组的最大值和最小值int max = Integer.MIN_VALUE;int min = Integer.MAX_VALUE;for (int i = 0; i < array.length; i++) {max = Math.max(max, array[i]);min = Math.min(min, array[i]);}// 2、动态计算桶的数量，并且初始化int buckets = (max - min) / array.length + 1;ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<ArrayList<Integer>>(buckets);for (int i = 0; i < buckets; i++) {bucketArr.add(new ArrayList<Integer>());}// 3、将元素放进桶中,按照元素的大小进桶for (int i = 0; i < array.length; i++) {int num = (array[i] - min) / array.length;bucketArr.get(num).add(array[i]);}// 4、对每个桶分别排序for (int i = 0; i < bucketArr.size(); i++) {Collections.sort(bucketArr.get(i));}// 5、合并桶，并返回数组ArrayList<Integer> tmp;int index = 0;for (int i = 0; i < bucketArr.size(); i++) {tmp = bucketArr.get(i);for (int j = 0; j < tmp.size(); j++) {array[index] = tmp.get(j);index++;}}}public static void main(String[] args) {int a[] = { 102456, 9012, 39867, 68957, 83556, 19702 };bucket_sort(a);System.out.println("桶排序以后：");for (int i = 0; i < a.length; i++) {if (i == a.length - 1) {System.out.print(a[i]);} else {System.out.print(a[i] + ",");}}}
}

算法导论的前8章主要讲都是这些排序伪代码为例子。仅此记录笔记。一个星期的成果。

八种排序java实现相关推荐

Java常用的八种排序算法与代码实现
在Java的时候,对于排序的应用需要熟练的掌握,这样才能够确保Java学习时候能够有扎实的基础能力.那Java有哪些排序算法呢?本文小千就来详细说说Java经典的8种排序算法. 经典的排序算法有八种, ...
Java 八种排序算法比较实践
写这篇文章是因为面试时经常会问这个问题,但是工作中也没用到过,所以一直是一知半解.但是我是属于比较较真的人,这次下定决心要把它们搞明白.知识在于积累,多点知识对自己总是有好处的. 我比较好奇的是,这几 ...
八种排序算法动画讲解
思维导图前言算法和数据结构是一个程序员的内功,所以经常在一些笔试中都会要求手写一些简单的排序算法,以此考验面试者的编程水平!动图来源于今日头条.动图来源于今日头条.动图来源于今日头条! 1.冒泡排 ...
归并排序改良 java_Java 八种排序算法总结
image 前言好久没复习基础了,写个冒泡排序都要想一会.感觉自己好像老了好多,今天手痒总结一下排序算法.目前网上博客普遍都有详细介绍,写的很清楚.说实话我是没必要再写一遍的,感觉就是在啰嗦.还是重 ...
一遍记住Java常用的八种排序算法与代码实现
点击上方"方志朋",选择"设为星标" 回复"666"获取新整理的面试资料作者:KaelQ www.jianshu.com/p/5e1712 ...
java实现八种排序算法并测试速度（详细）
算法代码: /*** Created by CLY on 2017/3/17.*/ package pers.cly.sorting; /*** 排序工具类,里面包含各种排序方法*/ public c ...
java排序算法代码_Java实现八种排序算法（代码详细解释）
package八大排序算法;importjava.util.Arrays;importorg.junit.Test;/*** 1.插入排序直接插入排序.希尔排序折半插入排序 * 2.交换排序冒泡 ...
java八种排序算法---直接插入排序
在学习算法的过程中,我们难免会接触很多和排序相关的算法.总而言之,对于任何编程人员来说,基本的排序算法是必须要掌握的. 从今天开始,我们将要进行基本的排序算法的讲解.Are you ready?Let ...
【基础不牢地动山摇】一遍记住 Java 面试中常用的八种排序算法与代码实现！...
作者:KaelQ www.jianshu.com/p/5e171281a387 1.直接插入排序经常碰到这样一类排序问题:把新的数据插入到已经排好的数据列中. 将第一个数和第二个数排序,然后构成一个 ...
Java基础学习总结（60）——Java常用的八种排序算法
1.直接插入排序经常碰到这样一类排序问题:把新的数据插入到已经排好的数据列中. 将第一个数和第二个数排序,然后构成一个有序序列将第三个数插入进去,构成一个新的有序序列.

八种排序java实现

八种排序java实现相关推荐

最新文章

热门文章