java几种常用的算法

1）冒泡排序：

依次比较相邻的两个元素，通过一次比较把未排序序列中最大（或最小）的元素放置在未排序序列的末尾。

1. public class BubbleSort {
2. public static void sort(int data[]) {
3. for (int i = 0; i < data.length -1; i++) {
4. for (int j = 0; j < data.length - i - 1; j++) {
5. if (data[j] > data[j + 1]) {
6. int temp = data[j];
7. data[j] = data[j + 1];
8. data[j + 1] = temp;
9. }
10. }
11. }
12. }
13. }

2）选择排序：

每一次从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。

1. public class SelectionSort {
2. public static void sort(int data[]) {
3. int minVal;
4. int minIndex;
5. for (int i = 0; i < data.length - 1; i++) {
6. minVal = data[i];
7. minIndex = i;
8. for (int j = i + 1; j < data.length; j++) {
9. if (data[j] < minVal) {
10. minVal = data[j];
11. minIndex = j;
12. }
13. }
14. if (minVal != data[i] && minIndex != i) {
15. data[minIndex] = data[i];
16. data[i] = minVal;
17. }
18. }
19. }
20. }

3）插入排序：

将数列分为有序和无序两个部分，每次处理就是将无序数列的第一个元素与有序数列的元素从后往前逐个进行比较，找出插入位置，将该元素插入到有序数列的合适位置中。

1. public class InsertionSort {
2. public static void sort(int data[]) {
3. for (int i = 1; i < data.length; i++) {
4. for (int j = i; j > 0; j--) {
5. if (data[j] < data[j - 1]) {
6. int temp = data[j];
7. data[j] = data[j - 1];
8. data[j - 1] = temp;
9. }
10. }
11. }
12. }
13. }

4）归并排序：

将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。排序过程如下：
（1）申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
（2）设定两个指针，最初位置分别为两个已经排序序列的起始位置
（3）比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
（4）重复步骤3直到某一指针达到序列尾
（5）将另一序列剩下的所有元素直接复制到合并序列尾

1. public class MergeSort {
2. public static void sort(int data[], int start, int end) {
3. if (start < end) {
4. int mid = (start + end) / 2;
5. sort(data, start, mid);
6. sort(data, mid + 1, end);
7. merge(data, start, mid, end);
8. }
9. }
10. public static void merge(int data[], int start, int mid, int end) {
11. int temp[] = new int[end - start + 1];
12. int i = start;
13. int j = mid + 1;
14. int k = 0;
15. while (i <= mid && j <= end) {
16. if (data[i] < data[j]) {
17. temp[k++] = data[i++];
18. } else {
19. temp[k++] = data[j++];
20. }
21. }
22. while (i <= mid) {
23. temp[k++] = data[i++];
24. }
25. while (j <= end) {
26. temp[k++] = data[j++];
27. }
28. for (k = 0, i = start; k < temp.length; k++, i++) {
29. data[i] = temp[k];
30. }
31. }
32. }

5）快速排序：

通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

1. public class QuickSort {
2. public static void sort(int data[], int start, int end) {
3. if (end - start <= 0) {
4. return;
5. }
6. int last = start;
7. for (int i = start + 1; i <= end; i++) {
8. if (data[i] < data[start]) {
9. int temp = data[++last];
10. data[last] = data[i];
11. data[i] = temp;
12. }
13. }
14. int temp = data[last];
15. data[last] = data[start];
16. data[start] = temp;
17. sort(data, start, last - 1);
18. sort(data, last + 1, end);
19. }
20. }