Java数据结构和算法---排序

几种排序
冒泡排序

选择排序

快速排序

几种排序

冒泡排序

原理：

冒泡排序：相邻两个数据进行比较，如果后面的比前面的数据小则进行交换，自然最大的那个数据被排到了最后。但是 ，效率很低，遍历了N次，同时需要交换
N + （N-1）+(N-2)+...+2+1   ~ N*(N-1)/2   次

代码

public class BubbleSort {
public static void main(String[] args) {
sort();
}

public static void sort() {
int array[] = new int[]{1, 4, 46, 53, 2425, 42, 34, 5, 234, 46, 3, 456, 456, 4, 656, 24, 626, 26256, 56, 256, 256, 657, 534};
int temp=0;
for (int i = 0; i < array.length - 1; i++) {
for (int j = 0; j < array.length - 1 - i; j++) {
if (array[j] > array[j + 1]) {//我们发现这里有弊端就是每次都需要交换，效率低
temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
System.out.println(Arrays.toString(array));
}
}

选择排序

选择排序

序—— 我们发现冒泡排序的弊端其中一点是每次都需要交换，达到的效果是把最大的那一个排到了最后，那么，我们是不是可以不交换那么多次来达到这样的效果呢？

原理

在冒泡的基础之上，我们并不需要每次都去换位，而是每次找出最小的放在前面，这样每循环一次只需要交换一次。

public class SelectSort {
public static void main(String[] args) {
sort();
}

public static void sort() {
int array[] = new int[]{1, 4, 46, 53, 2425, 42, 34, 5, 234, 46, 3, 456, 456, 4, 656, 24, 626, 26256, 56, 256, 256, 657, 534};
int min = 0;
for (int i = 0; i < array.length - 1; i++) {
min=i;
for (int j = i + 1; j < array.length; j++) {
if (array[j] < array[min]) {
min = j;
}
}
swip(array, min, i);
}
System.out.println(Arrays.toString(array));
}

private static void swip(int[] array, int min, int i) {
int temp = array[i];
array[i] = array[min];
array[min] = temp;
}
}

快速排序

快速排序

我们知道在有序的查询操作中二分法的效率是很高的，时间复杂度为 O(logN),其原理也很简单。但是我们发现以上的两种排序算法时间复杂度是很高的，那么我们能否去借鉴二分法的原理来提高我们排序的效率呢，答案是肯定的！

原理

请看 http://blog.csdn.net/yzllz001/article/details/50982841 讲解的很到位。

代码实现

public class FastSort {
public static void main(String[] args) {
int[] a = {12, 20, 5, 16, 15, 45, 97, 245, 32, 8777, 6788, 23, 34, 234, 524, 5684, 2345, 4264, 1, 30, 45, 23, 9};
int start = 0;
int end = a.length - 1;
sort(a, start, end);
System.out.println(Arrays.toString(a));

}

public static void sort(int[] a, int low, int high) {
int start = low;
int end = high;
int key = a[low];//通过这个“中间值”把数据一分为二，然后两边的继续“二分”
while (end > start) {
//从后往前比较
while (end > start && a[end] >= key)  //如果没有比关键值小的，比较下一个，直到有比关键值小的交换位置，然后又从前往后比较
end--;
if (a[end] <= key) {
int temp = a[end];
a[end] = a[start];
a[start] = temp;
}
//从前往后比较
while (end > start && a[start] <= key)//如果没有比关键值大的，比较下一个，直到有比关键值大的交换位置
start++;
if (a[start] >= key) {
int temp = a[start];
a[start] = a[end];
a[end] = temp;
}
//此时第一次循环比较结束，关键值的位置已经确定了。左边的值都比关键值小，右边的值都比关键值大，但是两边的顺序还有可能是不一样的，进行下面的递归调用
}
//递归
if (start > low) sort(a, low, start - 1);//左边序列。第一个索引位置到关键值索引-1
if (end < high) sort(a, end + 1, high);//右边序列。从关键值索引+1到最后一个
}

}