冒泡排序及优化(Java实现)

向大端冒泡

public class BubbleSort {public static <T extends Comparable<? super T>> void sort(T[] arr) {for (int i = 0, len = arr.length; i < len - 1; i++) {for (int j = 0; j < len - i - 1; j++) {if (arr[j].compareTo(arr[j + 1]) > 0) {swap(arr, j, j + 1);}}}}private static void swap(Object[] arr, int i, int j) {if (i != j) {Object temp = arr[i];arr[i] = arr[j];arr[j] = temp;}}private static void printArr(Object[] arr) {for (Object o : arr) {System.out.print(o);System.out.print("\t");}System.out.println();}public static void main(String args[]) {Integer[] arr = {3, 5, 1, 7, 2, 9, 8, 0, 4, 6};printArr(arr);//3  5   1   7   2   9   8   0   4   6sort(arr);printArr(arr);//0    1   2   3   4   5   6   7   8   9}
}

向小端冒泡

public class BubbleSort {public static <T extends Comparable<? super T>> void sort(T[] arr) {for (int i = 0, len = arr.length; i < len - 1; i++) {for (int j = len - 1; j > i; j--) {if (arr[j-1].compareTo(arr[j])>0) {swap(arr,j - 1, j);}}}}private static void swap(Object[] arr, int i, int j) {if (i != j) {Object temp = arr[i];arr[i] = arr[j];arr[j] = temp;}}private static void printArr(Object[] arr) {for (Object o : arr) {System.out.print(o);System.out.print("\t");}System.out.println();}public static void main(String args[]) {Integer[] arr = {3, 5, 1, 7, 2, 9, 8, 0, 4, 6};printArr(arr);//3  5   1   7   2   9   8   0   4   6sort(arr);printArr(arr);//0    1   2   3   4   5   6   7   8   9}
}

鸡尾酒排序（来回排序）

例子来自百度：以序列(2,3,4,5,1)为例，鸡尾酒排序只需要访问两次（升序降序各一次）次序列就可以完成排序，但如果使用冒泡排序则需要四次。

普通冒泡和鸡尾酒都是交换了4次，但是鸡尾酒是遍历了2遍数组，也就是读取了10个数；而冒泡排序遍历了4遍数组，也就是读取了20个数。

public class BubbleSort {public static <T extends Comparable<? super T>> void sort(T[] arr) {int low = 0;//low前面的已经排好序int high = arr.length - 1;//high后面的已经排好序while (low < high) {//俩指针相遇说明排序完毕//正向冒泡for (int i = low; i < high; i++) {if (arr[i].compareTo(arr[i + 1]) > 0) {swap(arr, i, i + 1);}}high--;//反向冒泡for (int j = high; j > low; j--) {if (arr[j - 1].compareTo(arr[j]) > 0) {swap(arr, j - 1, j);}}low++;}}private static void swap(Object[] arr, int i, int j) {if (i != j) {Object temp = arr[i];arr[i] = arr[j];arr[j] = temp;}}private static void printArr(Object[] arr) {for (Object o : arr) {System.out.print(o);System.out.print("\t");}System.out.println();}public static void main(String args[]) {Integer[] arr = {3, 5, 1, 7, 2, 9, 8, 0, 4, 6};printArr(arr);//3    5   1   7   2   9   8   0   4   6sort(arr);printArr(arr);//0    1   2   3   4   5   6   7   8   9}
}

冒泡优化1：用标记位提前判断有序性

在数组基本有序时，如果经过少数趟冒泡后，发现已经顺序了，则不必循环完n-1次才结束，这时已经可以立即停止排序了。

public class BubbleSort {public static <T extends Comparable<? super T>> void sort(T[] arr) {for (int i = 0, len = arr.length; i < arr.length; i++) {boolean hasChanged = false;for (int j = 0; j < len - i - 1; j++) {if (arr[j].compareTo(arr[j + 1]) > 0) {swap(arr, j, j + 1);hasChanged = true;}}if(!hasChanged) break;}}private static void swap(Object[] arr, int i, int j) {if (i != j) {Object temp = arr[i];arr[i] = arr[j];arr[j] = temp;}}private static void printArr(Object[] arr) {for (Object o : arr) {System.out.print(o);System.out.print("\t");}System.out.println();}public static void main(String args[]) {Integer[] arr = {3, 5, 1, 7, 2, 9, 8, 0, 4, 6};printArr(arr);//3 5   1   7   2   9   8   0   4   6sort(arr);printArr(arr);//0    1   2   3   4   5   6   7   8   9}
}

冒泡优化2：记录下最后一次交换的位置j，表示j后面已经排好序

随时地变更i，即还需要遍历的次数在不断变更。普通冒泡排序每一趟排序只能减少1个数字的遍历规模(也就是i++)，但是记录最后交换位置后，每次可以减少多个数字(也就是i = len - lastPosition - 1)。

public class BubbleSort {public static <T extends Comparable<? super T>> void sort(T[] arr) {for (int i = 0, len = arr.length, lastPosition = 0; i < len - 1; i = len - lastPosition - 1) {lastPosition = 0;for (int j = 0; j < len - i - 1; j++) {if (arr[j].compareTo(arr[j + 1]) > 0) {swap(arr, j, j + 1);lastPosition = j;}}}}private static void swap(Object[] arr, int i, int j) {if (i != j) {Object temp = arr[i];arr[i] = arr[j];arr[j] = temp;}}private static void printArr(Object[] arr) {for (Object o : arr) {System.out.print(o);System.out.print("\t");}System.out.println();}public static void main(String args[]) {Integer[] arr = {3, 5, 1, 7, 2, 9, 8, 0, 4, 6};printArr(arr);//3   5   1   7   2   9   8   0   4   6sort(arr);printArr(arr);//0    1   2   3   4   5   6   7   8   9}
}

转载于:https://www.cnblogs.com/noKing/p/7911594.html

冒泡排序及优化(Java实现)相关推荐

java每轮排序结果,冒泡排序及其优化java
java冒泡排序及其优化## version1 public static void bubbleSort() { int[] arr={5,6,1,4,3,2,7,8}: for (int i = ...
java 鸡尾酒排序_冒泡排序及优化(Java实现)
向大端冒泡 public class BubbleSort { public static > void sort(T[] arr) { for (int i = 0, len = arr.le ...
Java的知识点18——数组存储表格数据、冒泡排序的基础算法、冒泡排序的优化算法、二分法查找
数组存储表格数据 package cn.dym08; import java.util.Arrays; public class Test09 {public static void main(Str ...
asp java 变量_ASP_用stack变量优化Java代码，　　java程序包含了大量的对象 - phpStudy...
用stack变量优化Java代码 java程序包含了大量的对象,我们需要了解它们是从哪里被访问的,变量存储于何处对程序的性能有显著的影响--尤其是某些需要被频繁访问的变量. 我们写一个Java类,在其 ...
jvm 系列(九):如何优化 Java GC 「译」
本文由CrowHawk翻译,地址:如何优化Java GC「译」,是Java GC调优的经典佳作. Sangmin Lee发表在Cubrid上的"Become a Java GC Expert ...
带哨兵的冒泡排序_冒泡排序的优化以及快排过程及优化
冒泡排序的优化: 1.加入哨兵.2.记住每一次交换的最后位置,该位置以后的为有序,不需要改变. 1.快速排序的基本思想: 快速排序使用分治的思想,通过一趟排序将待排序列分割成两部分,其中一部分记录的关 ...
jvm系列(十):如何优化Java GC「译」
本文由CrowHawk翻译,地址:如何优化Java GC「译」,是Java GC调优的经典佳作. Sangmin Lee发表在Cubrid上的"Become a Java GC Expert ...
十大经典排序算法之冒泡排序及其优化
一.冒泡排序 1.冒泡排序算法的原理如下: 1.比较相邻的元素.如果第一个比第二个大,就交换他们两个. 2.对每一对相邻元素做同样的工作,从开始第一对到结尾的最后一对.在这一点,最后的元素应该会是最大 ...
java 堆大小的最大值_优化Java堆大小的5个技巧
优化Java堆大小的5个技巧摘要:Java堆容量不足可以对性能造成很大影响,这样无疑就给程序带来不可必要的麻烦,本文总结了影响Java堆容量不足的五大原因以及巧妙地去优化? 本文作者Pierre是一 ...