排序
冒泡排序
- 第一次排序:从第一个数开始,与第二个数比较,如果大于第二个数则调换这两个数的位置。然后第二个数和第三个数比较,如果大于第二个数则调换这两个数的位置。依此类推,一直比较到最后一个数。第一次排序下来会将该数组最大的值排到最后。
- 第二次排序,从第一个数开始,与第二个数比较,如果大于第二个数则调换这两个数的位置。然后第二个数和第三个数比较,如果大于第二个数则调换这两个数的位置。依此类推,一直比较到最后第二个数。第二次排序下来会将该数组第二个大的数排到倒数第二位。
- 依此类推,排序成功。
java实现代码
class BubbleSort {
public static void sort(int[] data) {
for (int i = 0; i < data.length - 1; i++) {
for (int j = 0; j < data.length - 1 - i; j++) {
if (data[j] > data[j + 1]) {
int tmp = data[j];
data[j] = data[j + 1];
data[j + 1] = tmp;
}
}
}
}
}
选择排序
- 第一次排序:从第一个数开始,与第二个数比较,如果大于第二个数则调换这两个数的位置。然后第一个数再和第三个数比较,如果大于第三个数则调换这两个数的位置。依此类推,一直比较到最后一个数。第一次排序下来会将该数组最小的值排到第一个。
- 第二次排序:从第二个数开始,与第三个数比较,如果大于第三个数则调换这两个数的位置。然后第二个数再和第四个数比较,如果大于第四个数则调换这两个数的位置。依此类推,一直比较到最后一个数。第二次排序下来会将该数组第二个小的数排到第二个。
- 依此类推,排序成功。
class SelectionSort {
public static void sort(int[] data) {
for (int x = 0; x < data.length - 1; x++) {
for (int y = x + 1; y < data.length; y++) {
if (data[y] < data[x]) {
int tmp = data[y];
data[y] = data[x];
data[x] = tmp;
}
}
}
}
}
插入排序
- 第一次排序:拿第二个数和第一个数比较,如果第二个数小于第一个数则调换这两个数的位置。第一次排序下来会使得该数组第一个和第二个索引有序。
- 第二次排序,拿第三个数和第二个数比较,如果第三个数小于第二个数会继续和第一个数比较,如果大于第一个数就插入到第一个数后面。(无序的第一个数和有序的数从最后一个往前依次比较,找到合适的位置就插入。)第二次排序下来会使得该数组第一个、第二个索引和第三个索引有序。
- 依此类推,排序成功。
class InsertSort {
public static void sort(int[] data) {
for (int i = 1; i < data.length; i++) {
for (int j = i; (j > 0) && (data[j] < data[j - 1]); j--) {
int tmp = data[j];
data[j] = data[j-1];
data[j-1] = tmp;
}
}
}
}
快速排序
- 第一次排序:第一个数依次和最后一个数向前比较(第一个数先和最后一个数比较),遇到的第一个比第一个数小的数(位置记为x),就把第x个数和第一个数位置调换。然后将第x个数从第二个数依次向后比较,遇到的第一个比第x个数大的数,就将这两个数的位置进行调换。依此类推,直到比较的数和被比较的数为同一个,第一次排序完成。第一次排序使得第一个数找到了自己的位置,并将数组划分为两组。
- 第二次排序:以第一次排序的结果中的第一组作为一个数组。按照第一次排序的方式进行排序。
- 依此类推,排序成功。
class QuickSort {
public static void sort(int[] data) {
quickSort(data, 0, data.length - 1);
}
public static void swap(int[] arr, int b, int c) {
int tmp = arr[b];
arr[b] = arr[c];
arr[c] = tmp;
}
private static void quickSort(int[] data, int i, int j) {
int pivotIndex = (i + j) / 2;
swap(data, pivotIndex, j);
int k = partition(data, i - 1, j, data[j]);
swap(data, k, j);
if ((k - i) > 1)
quickSort(data, i, k - 1);
if ((j - k) > 1)
quickSort(data, k + 1, j);
}
private static int partition(int[] data, int l, int r, int pivot) {
do {
while (data[++l] < pivot)
;
while ((r != 0) && data[--r] > pivot)
;
swap(data, l, r);
} while (l < r);
swap(data, l, r);
return l;
}
}
归并排序
- 将数组一半分割,分割出来的部分再一半分割,知道分割出来的部分只有两个元素。
- 比较每个部分的两个元素的大小,并排序。
- 开始合并,第一个部分和第二个部分合并并且元素之间排序。第三个部分和第四个部分合并并且元素之间排序。依此类推。
- 继续合并,按照第三部的规则。依此类推,排序成功。
class MergeSort {
public static void sort(int[] data) {
int[] temp = new int[data.length];
mergeSort(data, temp, 0, data.length - 1);
}
private static void mergeSort(int[] data, int[] temp, int l, int r) {
int mid = (l + r) / 2;
if (l == r)
return;
mergeSort(data, temp, l, mid);
mergeSort(data, temp, mid + 1, r);
for (int i = l; i <= r; i++) {
temp[i] = data[i];
}
int i1 = l;
int i2 = mid + 1;
for (int cur = l; cur <= r; cur++) {
if (i1 == mid + 1)
data[cur] = temp[i2++];
else if (i2 > r)
data[cur] = temp[i1++];
else if (temp[i1] < temp[i2])
data[cur] = temp[i1++];
else
data[cur] = temp[i2++];
}
}
}
希尔排序
算法先将要排序的一组数按某个增量d(n/2,n为要排序数的个数)分成若干组,每组中记录的下标相差d.对每组中全部元素进行直接插入排序,然后再用一个较小的增量(d/2)对它进行分组,在每组中再进行直接插入排序。当增量减到1时,进行直接插入排序后,排序完成。
class ShellSort {
public static void sort(int[] data) {
for (int i = data.length / 2; i > 2; i /= 2) {
for (int j = 0; j < i; j++) {
insertSort(data, j, i);
}
}
insertSort(data, 0, 1);
}
private static void insertSort(int[] data, int start, int inc) {
for (int i = start + inc; i < data.length; i += inc) {
for (int j = i; (j >= inc) && (data[j] < data[j - inc]); j -= inc) {
int tmp = data[j];
data[j] = data[j - inc];
data[j - inc] = tmp;
}
}
}
}
基数排序
将所有待比较数值(正整数)统一为同样的数位长度,数位较短的数前面补零。然后,从最低位开始,依次进行一次排序。这样从最低位排序一直到最高位排序完成以后,数列就变成一个有序序列。
查找
顺序查找
二分法查找
元素必须是有序的,如果是无序的则要先进行排序操作。