欢迎Java爱好者品读其他算法详解:
简单比较排序:http://blog.csdn.net/ysjian_pingcx/article/details/8652091
选择排序: http://blog.csdn.net/ysjian_pingcx/article/details/8656048
直接插入排序:http://blog.csdn.net/ysjian_pingcx/article/details/8674454
快速排序: http://blog.csdn.net/ysjian_pingcx/article/details/8687444
快速排序优化:http://blog.csdn.net/ysjian_pingcx/article/details/8687444
/**
* 原始的冒泡排序法,时间复杂度为O(n2)
*
* @param array
*/
public void bubbleSort(int... array) {
int length = array.length;
for (int i = 0; i < length - 1; i++) {
for (int j = 0; j < length - i - 1; j++) {// 内部循环的边界要比长度小一
if (array[j] > array[j + 1]) {
swap(j, j + 1, array);//相邻的两个元素比较,将大的放到最右边
}
}
}
}
for (int i = 0; i < length - 1; i++)
for (int j = 0; j < length - i - 1; j++)
/**
* 内部实现,用于交换数组的两个引用值
*
* @param beforeIndex
* @param afterIndex
* @param arr
*/
private void swap(int oneIndex, int anotherIndex, int[] array) {
int temp = array[oneIndex];
array[oneIndex] = array[anotherIndex];
array[anotherIndex] = temp;
}
/**
* 冒泡排序法
*
* @author PingCX
*
*/
public class BubbleSort {
public static void main(String[] args) {
BubbleSort bubbleSort = new BubbleSort();
int[] array = { 25, 36, 21, 45, 98, 13};
System.out.println(Arrays.toString(array));
bubbleSort.bubbleSort(array);// 调用快速排序的方法
System.out.println(Arrays.toString(array));// 打印排序后的数组元素
}
/**
* 原始的冒泡排序法,时间复杂度为O(n2)
*
* @param array
*/
public void bubbleSort(int... array) {
int length = array.length;
for (int i = 0; i < length - 1; i++) {
for (int j = 0; j < length - i - 1; j++) {// 内部循环的边界要比长度小一
if (array[j] > array[j + 1]) {
swap(j, j + 1, array);//相邻的两个元素比较,将大的放到最右边
}
}
}
}
/**
* 内部实现,用于交换数组的两个引用值
*
* @param beforeIndex
* @param afterIndex
* @param arr
*/
private void swap(int oneIndex, int anotherIndex, int[] array) {
int temp = array[oneIndex];
array[oneIndex] = array[anotherIndex];
array[anotherIndex] = temp;
}
}
/**
* 优化的冒泡排序法,时间复杂度为O(n2)
*
* @param array
*/
public void bubbleSort(int... array) {
int length = array.length;
boolean flag = true; //一个标记
for (int i = 0; i < length - 1 && flag; i++) {//加这个条件就是当有序的时候就不用重复后面的操作了
flag = false;
for (int j = 0; j < length - i - 1; j++) {
if (array[j] > array[j + 1]) {
swap(j, j + 1, array);// 相邻的两个元素比较,将大的放到最右边
flag = true;
}
}
}
}
@上边的代码多了一个 boolean flag = true;
for (int i = 0; i < length - 1 && flag; i++)
@开始flag为true,能进入循环,已进入循环就将flag = false;:
for (int i = 0; i < length-1 && flag; i++) {//加这个条件就是当有序的时候就不用重复后面的操作了
flag = false;//进入循环体,就置为false
if (array[j] > array[j + 1]) {
swap(j, j + 1, array);// 相邻的两个元素比较,将大的放到最右边
flag = true;//存在反序的就将flag置为true
}
/**
* 优化的冒泡排序法
*
* @author PingCX
*
*/
public class BubbleSortOpt {
public static void main(String[] args) {
BubbleSortOpt bubbleSort = new BubbleSortOpt();
int[] array = { 25, 36, 21, 45, 98, 13};
System.out.println(Arrays.toString(array));
bubbleSort.bubbleSort(array);// 调用快速排序的方法
System.out.println(Arrays.toString(array));// 打印排序后的数组元素
}
/**
* 优化的冒泡排序法,时间复杂度为O(n2)
*
* @param array
*/
public void bubbleSort(int... array) {
int length = array.length;
boolean flag = true; //一个标记
for (int i = 0; i < length-1 && flag; i++) {//加这个条件就是当有序的时候就不用重复后面的操作了
flag = false;//进入循环体,就置为false
for (int j = 0; j < length - i - 1; j++) {
if (array[j] > array[j + 1]) {
swap(j, j + 1, array);// 相邻的两个元素比较,将大的放到最右边
flag = true;//存在反序的就将flag置为true
}
}
}
}
/**
* 内部实现,用于交换数组的两个引用值
*
* @param beforeIndex
* @param afterIndex
* @param arr
*/
private void swap(int oneIndex, int anotherIndex, int[] array) {
int temp = array[oneIndex];
array[oneIndex] = array[anotherIndex];
array[anotherIndex] = temp;
}
}
上面是对int[] 进行的排序,那么面向对象的这这应用不能只局限于int[] 数组中,也就是任何可以比较的类型都可以用冒泡来排序,下面是优化后的代码的实现:
/**
* 冒泡排序法
*
* @author PingCX
*
*/
public class BubbleSortTOpt {
public static void main(String[] args) {
BubbleSortTOpt bubbleSort = new BubbleSortTOpt();
Integer[] array = { 25, 36, 21, 45, 98, 13};
System.out.println("Before sorting:");
System.out.println(Arrays.toString(array));
bubbleSort.bubbleSort(array);// 调用冒泡排序的方法
System.out.println("After sorting:");
System.out.println(Arrays.toString(array));// 打印排序后的数组元素
}
/**
* 冒泡排序法,时间复杂度为O(n2)
*
* @param array
*/
public <T extends Comparable<T>> void bubbleSort(T[] array) {
int length = array.length;
boolean flag = true;
for (int i = 0; i < length - 1 && flag; i++) {
flag = false;
for (int j = 0; j < length - i - 1; j++) {
if (array[j].compareTo(array[j + 1]) > 0) {
swap(j, j + 1, array);// 相邻的两个元素比较,将大的放到最右边
flag = true;
}
}
}
}
/**
* 内部实现,用于交换数组的两个引用值
*
* @param beforeIndex
* @param afterIndex
* @param arr
*/
private <T extends Comparable<T>> void swap(int oneIndex, int anotherIndex,
T[] array) {
T temp = array[oneIndex];
array[oneIndex] = array[anotherIndex];
array[anotherIndex] = temp;
}
}
欢迎Java爱好者品读其他算法详解:
简单比较排序:http://blog.csdn.net/ysjian_pingcx/article/details/8652091
选择排序: http://blog.csdn.net/ysjian_pingcx/article/details/8656048
直接插入排序:http://blog.csdn.net/ysjian_pingcx/article/details/8674454
快速排序: http://blog.csdn.net/ysjian_pingcx/article/details/8687444
快速排序优化:http://blog.csdn.net/ysjian_pingcx/article/details/8687444