1. 冒泡排序
代码实现
/**
* @ClassName : BubbleSortFinal
* @Description : 冒泡排序:O(n^2)
* @Author : Yemulin
* @Date : 2020/09/02 01:56
* @Version : 1.0
*/
public class BubbleSortFinal {
//测试部分
public static void main(String[] args) {
//创建一个长度为10的数组
int[] arr = new int[10];
for (int i = 0; i < 10; i++) {
arr[i] = (int) (Math.random() * 1000);
}
System.out.println(Arrays.toString(arr));
bubbleSortFinal(arr);
System.out.println(Arrays.toString(arr));
}
//冒泡排序
public static void bubbleSortFinal(int[] arr) {
int temp = 0;
boolean flag = false;
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]) {
flag = true;
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
if (flag == false) {
break;
} else {
flag = false;
}
}
}
}
思路:
public class BubbleSort {
public static void main(String[] args) {
// int[] arr = {3, 9, -1, 10, -2};
// //为了容易理解,将冒泡排序的演变过程进行展示
//
// System.out.println("排序前:");
// System.out.println(Arrays.toString(arr));
//测试一下冒泡排序的速度O(n^2),给80000个数据,测试
//创建要给80000个的随机数组
int[] arr = new int[80000];
for (int i = 0; i < 80000; i++) {
arr[i] = (int) (Math.random() * 8000000);
}
long timeMillis1 = System.currentTimeMillis();
System.out.println("排序前:" + timeMillis1);
//测试冒泡排序
bubbleSort(arr);
long timeMillis2 = System.currentTimeMillis();
System.out.println("排序后:" + timeMillis2);
System.out.println("所需时间:" + (timeMillis2 - timeMillis1) + "毫秒");
// System.out.println(Arrays.toString(arr));
/*//冒泡排序时间复杂度:O(n^2)
int temp = 0; //临时变量
boolean flag = false; //标识变量,表示是否进行过交换
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]) {
flag = true;
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) { //此处即等同于“flag == false”
break;
} else {
flag = false;
}
}*/
/* //第二趟排序,就是将第二大的数排在倒数第二位
for (int j = 0; j < arr.length - 1 - 1; j++) {
//如果前面的数比后面的数大,则交换
if (arr[j] > arr[j + 1]) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
System.out.println("第二次排序后的数组");
System.out.println(Arrays.toString(arr));
//第三趟排序,就是将第三大的数排在倒数第三位
for (int j = 0; j < arr.length - 1 - 2; j++) {
//如果前面的数比后面的数大,则交换
if (arr[j] > arr[j + 1]) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
System.out.println("第三次排序后的数组");
System.out.println(Arrays.toString(arr));
//第四趟排序,就是将第四大的数排在倒数第四位
for (int j = 0; j < arr.length - 1 - 3; j++) {
//如果前面的数比后面的数大,则交换
if (arr[j] > arr[j + 1]) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
System.out.println("第四次排序后的数组");
System.out.println(Arrays.toString(arr));*/
}
//将前面的冒泡排序算法,封装成一个方法
public static void bubbleSort(int[] arr) {
//冒泡排序时间复杂度:O(n^2)
int temp = 0; //临时变量
boolean flag = false; //标识变量,表示是否进行过交换
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]) {
flag = true;
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) { //此处即等同于“flag == false”
break;
} else {
flag = false;
}
}
}
}
2. 选择排序
代码实现
/**
* @ClassName : SelectSortFinal
* @Description :
* @Author : Yemulin
* @Date : 2020/09/02 03:23
* @Version : 1.0
*/
//测试部分
public class SelectSortFinal {
public static void main(String[] args) {
int[] arr = new int[80000];
for (int i = 0; i < 80000; i++) {
arr[i] = (int) (Math.random() * 800000);
}
System.out.println("排序前");
// System.out.println(Arrays.toString(arr));
long millis1 = System.currentTimeMillis();
System.out.println(millis1);
selectSortFinal(arr);
System.out.println("排序后");
// System.out.println(Arrays.toString(arr));
long millis2 = System.currentTimeMillis();
System.out.println(millis2);
System.out.println("所需时间为:" + (millis2-millis1));
}
//选择排序
public static void selectSortFinal(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 - 1; j++) {
if (min > arr[j]) { //说明假定的最小值,并不是最小
min = arr[j]; //重置min
minIndex = j; //重置minIndex
}
}
//如果minIndex不等于i了, 证明发生了交换, 之前的预测最小值是arr[i]是错误的
//所以要交换i与j的值了
if (minIndex != i) {
arr[minIndex] = arr[i];
arr[i] = min;
}
}
}
}
思路:
public class SelectSort {
public static void main(String[] args) {
int[] arr = {101, 34, 119, 1};
System.out.println("排序前");
System.out.println(Arrays.toString(arr));
selectSort(arr);
System.out.println("排序后");
System.out.println(Arrays.toString(arr));
}
//选择排序
public static void selectSort(int[] arr) {
//在推导的过程中,我们发现了很多规律, 因此, 可以使用for来解决
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]; //重置min
minIndex = j; //重置minIndex
}
}
//将最小值,放在arr[0],即交换
if (minIndex != i) {
arr[minIndex] = arr[i];
arr[i] = min;
}
// System.out.println("第"+ i+1 +"轮后~~");
// System.out.println(Arrays.toString(arr));//1, 34, 119, 101
}
//使用逐步推导的方式来,讲解选择排序
//第一轮
//原始的数组: 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("第一轮后~~");
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]; //重置min
minIndex = j; //重置minIndex
}
}
//将最小值,放在arr[0],即交换
if (minIndex != 1) {
arr[minIndex] = arr[1];
arr[1] = min;
}
System.out.println("第二轮后~~");
System.out.println(Arrays.toString(arr));//1, 34, 119, 101
//第三轮
minIndex = 2;
min = arr[2];
for (int j = 2 + 1; j < arr.length; j++) {
if (min > arr[j]) { //说明假定的最小值,并不是最小
min = arr[j]; //重置min
minIndex = j; //重置minIndex
}
}
//将最小值,放在arr[0],即交换
if (minIndex != 2) {
arr[minIndex] = arr[2];
arr[2] = min;
}
System.out.println("第三轮后~~");
System.out.println(Arrays.toString(arr));//1, 34, 101, 119*/
}
}