Java排序汇总Word下载.docx

1、 * return 一个初始化好的数组 */ public int createArray（） Random random = new Random（）; int array = new int10; for （int i = 0; i 10; i+） array = random.nextInt（100） - random.nextInt（100）;/生成两个随机数相减，保证生成的数中有负数 System.out.println（=原始序列=）; printArray（array）; return array; * 打印数组中的元素到控制台 * param source public voi

2、d printArray（int data） for （int i : data） System.out.print（i + System.out.println（）; * 交换数组中指定的两元素的位置 * param data * param x * param y private void swap（int data, int x, int y） int temp = datax; datax = datay; datay = temp; * 冒泡排序-交换排序的一种 * 方法：相邻两元素进行比较，如有需要则进行交换，每完成一次循环就将最大元素排在最后（如从小到大排序），下一次循环是将其他

3、的数进行类似操作。 * 性能：比较次数O（n2）,n2/2；交换次数O（n2）,n2/4 * * param data 要排序的数组 * param sortType 排序类型 * return public void bubbleSort（int data, String sortType） if （sortType.equals（asc） /正排序，从小排到大 /比较的轮数 for （int i = 1; data.length; /将相邻两个数进行比较，较大的数往后冒泡 for （int j = 0; j dataj + 1） /交换相邻两个数 swap（data, j, j + 1）;

4、 else if （sortType.equals（desc） /倒排序，从大排到小 if （dataj else 您输入的排序类型错误！ printArray（data）;/输出冒泡排序后的数组值 * 直接选择排序法-选择排序的一种每一趟从待排序的数据元素中选出最小（或最大）的一个元素， 顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。比较次数O（n2）,n2/2 * 交换次数O（n）,n * 交换次数比冒泡排序少多了，由于交换所需CPU时间比比较所需的CUP时间多，所以选择排序比冒泡排序快。 * 但是N比较大时，比较所需的CPU时间占主要地位，所以这时的性能和冒泡排序差不太多，

5、但毫无疑问肯定要快些。 public void selectSort（int data, String sortType） int index; index = 0; for （int j = 1;= data.length - i; dataindex） index = j; /交换在位置data.length-i和index（最大值）两个数 swap（data, data.length - i, index）;/输出直接选择排序后的数组值 * 插入排序将一个记录插入到已排好序的有序表（有可能是空表）中,从而得到一个新的记录数增1的有序表。比较次数O（n2）,n2/4 * 复制次数O（n）,

6、n2/4 * 比较次数是前两者的一般，而复制所需的CPU时间较交换少，所以性能上比冒泡排序提高一倍多，而比选择排序也要快。 * public void insertSort（int data, String sortType） /保证前i+1个数排好序 i; /交换在位置j和i两个数 swap（data, i, j）;/输出插入排序后的数组值 * 反转数组的方法 * param data 源数组 public void reverse（int data） int length = data.length; int temp = 0;/临时变量 length / 2; temp = data;

7、data = datalength - 1 - i; datalength - 1 - i = temp;/输出到转后数组的值 * 快速排序 * 快速排序使用分治法（Divide and conquer）策略来把一个序列（list）分为两个子序列（sub-lists）。 * 步骤为： * 1. 从数列中挑出一个元素，称为 基准（pivot）， * 2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分割之后，该基准是它的最后位置。这个称为分割（partition）操作。 * 3. 递归地（recursive）把小于基准值元素

8、的子数列和大于基准值元素的子数列排序。 * 递回的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递回下去，但是这个算法总会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。 * param data 待排序的数组 * param low * param high * see SortTest#qsort（int, int, int） * see SortTest#qsort_desc（int, int, int） public void quickSort（int data, String sortType） qsort_asc（da

9、ta, 0, data.length - 1）; qsort_desc（data, 0, data.length - 1）; * 快速排序的具体实现，排正序 private void qsort_asc（int data, int low, int high） int i, j, x; if （low high） /这个条件用来结束递归 i = low; j = high; x = data; while （i x） j-; /从右向左找第一个小于x的数 if （i data = dataj; i+; data /从左向右找第一个大于x的数 dataj = data; data = x; qs

10、ort_asc（data, low, i - 1）; qsort_asc（data, i + 1, high）; * 快速排序的具体实现，排倒序 private void qsort_desc（int data, int low, int high） dataj qsort_desc（data, low, i - 1）; qsort_desc（data, i + 1, high）; *二分查找特定整数在整型数组中的位置（递归） *查找线性表必须是有序列表 email=*paramdataset*paramdataset/email email=*paramdata*paramdata/emai

11、l email=*parambeginIndex*parambeginIndex/email email=*paramendIndex*paramendIndex/email email=*returnindex*returnindex/email public int binarySearch（int dataset, int data, int beginIndex, int endIndex） int midIndex = （beginIndex + endIndex） 1; /相当于mid = （low + high） / 2，但是效率会高些 if （data datasetendIn

12、dex | beginIndex endIndex） return -1; datasetmidIndex） return binarySearch（dataset, data, beginIndex, midIndex - 1）; else if （data return binarySearch（dataset, data, midIndex + 1, endIndex）; return midIndex; *二分查找特定整数在整型数组中的位置（非递归） public int binarySearch（int dataset, int data） int beginIndex = 0; i

13、nt endIndex = dataset.length - 1; int midIndex = -1; while （beginIndex /相当于midIndex = （beginIndex + endIndex） / 2，但是效率会高些 endIndex = midIndex - 1; beginIndex = midIndex + 1; public static void main（String args） SortTest sortTest = new SortTest（）; int array = sortTest.createArray（）;=冒泡排序后（正序）= sortTe

14、st.bubbleSort（array, =冒泡排序后（倒序）= array = sortTest.createArray（）;=倒转数组后= sortTest.reverse（array）;=选择排序后（正序）= sortTest.selectSort（array, =选择排序后（倒序）=插入排序后（正序）= sortTest.insertSort（array, =插入排序后（倒序）=快速排序后（正序）= sortTest.quickSort（array, sortTest.printArray（array）;=快速排序后（倒序）=数组二分查找=您要找的数在第 + sortTest.binarySearch（array, 74） + 个位子。（下标从0计算）