- 冒泡排序
**
* 冒泡排序（Bubble Sort）
* 它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。
* 走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
*
*/
public class BubbleSort {
/**
* 1. 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
* 2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
* 3. 针对所有的元素重复以上的步骤，除了最后一个；
* 重复步骤1~3，直到排序完成。
*/
public static int[] bubbleSort(int[] array) {
if (array == null || array.length == 0)
return array;
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array.length - 1 - i; j++) {
if (array[j + 1] < array[j]) {
int temp = array[j + 1];
array[j + 1] = array[j];
array[j] = temp;
}
}
}
return array;
}
public static void main(String[] args) {
int[] array = {4, 2, 7, 9, 0, 3, 8, 1, 5};
array = bubbleSort(array);
for(int i : array) {
System.out.println(i);
}
}
}
- 选择排序
/**
* 选择排序（Selection Sort）
* 从数组中选择找到最小（最大）的元素排在首位（末尾），以此类推
*
*/
public class SelectionSort {
public static int[] selectionSort(int[] array) {
if (array == null || array.length == 0)
return array;
for (int i = 0; i < array.length; i++) {
int minIndex = i;
for (int j = i; j < array.length; j++) {
if (array[j] < array[minIndex]) //找到最小的数
minIndex = j; //将最小数的索引保存
}
int temp = array[minIndex];
array[minIndex] = array[i];
array[i] = temp;
}
return array;
}
public static void main(String[] args) {
int[] array = {4, 2, 7, 9, 0, 3, 8, 1, 5};
array = selectionSort(array);
for(int i : array) {
System.out.println(i);
}
}
}
- 插入排序
/**
* 插入排序（Insertion-Sort）
* 它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
*
*/
public class InsertionSort {
/**
* 1. 取出第一个元素，认为已经排序
* 2. 取出下一个元素，和前面的已排序的元素相比，小于则不断的往前比，知道大于它
* 3. 重复1和2
*/
public static int[] insertionSort(int[] array) {
if(array == null || array.length == 0) {
return array;
}
for(int i = 0; i < array.length - 1; i++) {
int current = array[i + 1];
int preIndex = i;
while(preIndex >= 0 && current < array[preIndex]) {
array[preIndex + 1] = array[preIndex];
preIndex--;
}
array[preIndex + 1] = current;
}
return array;
}
public static void main(String[] args) {
int[] array = {4, 2, 7, 9, 0, 3, 8, 1, 5};
array = insertionSort(array);
for(int i : array) {
System.out.println(i);
}
}
}
- 希尔排序
/**
* 希尔排序
*
*/
public class ShellSort {
public static int[] shellSort(int[] array) {
if (array == null || array.length == 0)
return array;
int len = array.length;
int temp, gap = len / 2;
while (gap > 0) {
for (int i = gap; i < len; i++) {
temp = array[i];
int preIndex = i - gap;
while (preIndex >= 0 && array[preIndex] > temp) {
array[preIndex + gap] = array[preIndex];
preIndex -= gap;
}
array[preIndex + gap] = temp;
}
gap /= 2;
}
return array;
}
public static void main(String[] args) {
int[] array = {4, 2, 7, 9, 0, 3, 8, 1, 5};
array = shellSort(array);
for(int i : array) {
System.out.println(i);
}
}
}
- 快速排序
public class QuickSort {
public static void quickSort(int[] data) {
quickSort(data, 0, data.length - 1);
}
public static void quickSort(int[] data, int start, int end) {
if (data == null || data.length == 0 || start >= end)
return;
int i = start, j = end;
int pivotKey = data[start];//基准值
while (i < j) {
while (i < j && data[j] >= pivotKey)//从右往左找，知道找到小于等于基准值的下标，记录起来
j--;
if (i < j)
data[i++] = data[j];//交换，使左边的数据小于等于基准值
while (i < j && data[i] <= pivotKey)//从左往右找，知道找到大于等于基准值的下标，记录起来
i++;
if (i < j)
data[j--] = data[i];//交换，使右边的数据大于等于基准值
}
data[i] = pivotKey;//交换基准值
quickSort(data, start, i - 1);//递归小于基准值的左边数据，重复上述操作
quickSort(data, i + 1, end);//递归大于基准值的右边数据，重复上述操作
}
public static void main(String[] args) {
int[] array = {4, 2, 7, 9, 0, 3, 8, 6, 1, 5};
quickSort(array);
for(int i : array) {
System.out.println(i);
}
}
}