常用算法
一、排序算法
1.1、冒泡排序
冒泡排序(Bubble Sorting)的基本思想是：通过对待排序序列从前向后（从下标较小的元素开始），依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就象水底下的气泡一样逐渐向上冒。
冒泡排序思路分析
代码实现
- 从小到大排序
public static int[] bubbleSort(int[] arr) {
int temp = 0;
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
return arr;
}
- 从大到小排序
public static int[] bubbleSort1(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] < arr[j + 1]) {
int temp1 = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp1;
}
}
}
return arr;
}
- main函数调用函数
public static void main(String[] args) {
int[] arr = {3, 9, -1, 10, -2};
System.out.println(Arrays.toString(bubbleSort(arr)));
System.out.println();
System.out.println(Arrays.toString(bubbleSort1(arr)));
}
冒泡排序优化
思路：排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行过交换，就说明序列有序，因此要在排序过程中设置一个标志flag判断元素是否进行过交换。从而减少不必要的比较。（这里说的优化，可以在冒泡排序写好后，在进行)
优化代码实现
public class BubbleSortPlus {
public static void main(String[] args) {
//int[] arr = {3, 9, -1, 10, 20};
int[] arr = {3, 9, -1, 10, -2};
int n = arr.length;
boolean flag = false; // 表示变量，表示是否进行过交换
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
flag = true;
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
System.out.println("第" + (i + 1) + "趟排序后的数组");
System.out.println(Arrays.toString(arr));
if (!flag) { // 在一趟排序中一次交换都没有进行过
break;
} else {
flag = false; // 重置flag，进行下次判断
}
}
}
}
运行结果比较
- 未优化的结果：3, 9, -1, 10, 20
- 优化后的结果：3, 9, -1, 10, 20
测试冒泡排序算法的时间复杂度
我们随机生成一个[0, 80000)的数组，统计排序前的时间，在记录排序后的时间，最后打印出执行的时间
public class BubbleSortPlus {
public static void bubbleSort(int[] arr) {
int n = arr.length;
boolean flag = false;
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
flag = true;
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
if (!flag) {
break;
} else {
flag = false;
}
}
}
public static void main(String[] args) {
//int[] arr = {3, 9, -1, 10, 20};
//int[] arr = {3, 9, -1, 10, -2};
int[] arr = new int[80000];
for (int i = 0; i < 80000; i++) {
arr[i] = (int) (Math.random() * 80000); // 生成一个[0, 80000)数
}
//System.out.println("排序前");
//System.out.println(Arrays.toString(arr));
long bubbleSortBefore = System.currentTimeMillis();
bubbleSort(arr);
//System.out.println("排序后");
//System.out.println(Arrays.toString(arr));
long bubbleSortAfter = System.currentTimeMillis();
System.out.println("消耗时间为" + (bubbleSortAfter - bubbleSortBefore) + "毫秒");
}
}
结果
1.2、选择排序
基本介绍
选择排序也属于内部排序法，是从欲排序的数据中，按指定的规则选出某一元素，再依规定交换位置后达到
排序的目的。
选择排序思想
选择排序(select sorting)也是一种简单的排序方法。它的基本思想是：第一次从arr[O]~arr[n-1]中选取最小值，
与ar[0]交换，第二次从arr[1] ~ arr[n-1]中选取最小值，与ar[1]交换，第三次从arr[2]~ arr[n-1]中选取最小值，与arr[2]
交换，…，第i次从ar[i-1]~ar[n-1]中选取最小值，与arr[i-1]交换，…，第n-1次从arr[n-2]arr[n-1]中选取最小值，
与arr[n-2]交换，总共通过n-1次，得到一个按排序码从小到大排列的有序序列。
选择排序思路
代码实现
我们以数组[101, 34, 119, 1]为例来逐步分析选择排序
- 第一轮排序后顺序为[1, 34, 119, 101]
int minIndex = 0;
int min = arr[0];
for (int j = 0 + 1; j < arr.length; j++) {
if (min > arr[j]) { // 假设第一个数位最小值
min = arr[j]; // 重新给min赋值
minIndex = j; // 重置minIndex的值
}
}
// 找到最小值，放在arr[0]。即交换
if (minIndex != 0) {
arr[minIndex] = arr[0];
arr[0] = min;
}
System.out.println(Arrays.toString(arr));
- 第二轮排序后顺序为[1, 34, 119, 101]
minIndex = 1;
min = arr[1];
for (int j = 1 + 1; j < arr.length; j++ ) {
if (min > arr[j]) {
min = arr[j];
minIndex = j;
}
}
if (minIndex != 1) {
arr[minIndex] = arr[1];
arr[1] = min;
}
System.out.println(Arrays.toString(arr));
- 第三轮排序后的顺序为[1, 34, 101, 119]
minIndex = 2;
min = arr[2];
for (int j = 2 + 1; j < arr.length; j++ ) {
if (min > arr[j]) {
min = arr[j];
minIndex = j;
}
}
if (minIndex != 2) {
arr[minIndex] = arr[2];
arr[2] = min;
}
System.out.println(Arrays.toString(arr));
- 总结上面的三轮排序我们可以发现一定的规律
public static void selectSort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
int minIndex = i;
int min = arr[0];
for (int j = i + 1; j < arr.length; j++) {
if (min > arr[j]) {
min = arr[j]; // 重新给min赋值
minIndex = j; // 重置minIndex的值
}
}
if (minIndex != i) {
arr[minIndex] = arr[i];
arr[i] = min;
}
}
System.out.println(Arrays.toString(arr));
}
public static void main(String[] args) {
int[] arr = {101, 34, 119, 1};
bubbleSort(arr);
}
测试冒泡排序的时间复杂度
- 创建80000个随机数组
public class SelectSort {
public static void main(String[] args) {
int[] arr = new int[80000];
for (int i = 0; i < 80000; i++) {
arr[i] = (int) (Math.random() * 8000000); // 生成一个[0, 8000000)数
}
long bubbleSortBefore = System.currentTimeMillis();
selectSort(arr);
long bubbleSortAfter = System.currentTimeMillis();
System.out.println("消耗时间为" + (bubbleSortAfter - bubbleSortBefore) + "毫秒");
}
public static void selectSort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
int minIndex = i;
int min = arr[i];
for (int j = i + 1; j < arr.length; j++) {
if (min > arr[j]) {
min = arr[j];
minIndex = j;
}
}
if (minIndex != i) {
arr[minIndex] = arr[i];
arr[i] = min;
}
}
}
}
结果
经过测试我们可以看到选择排序的时间比冒泡排序的时间少很多
![Mysql全解[基础篇]](https://img-blog.csdnimg.cn/066c4d9a092f4ebc8c80ce145c024fd4.png)
