冒泡排序
冒泡排序只会操作相邻的两个数据。每次冒泡操作都会对相邻的两个元素进行比较,看是否满足大小关系要求。如果不满足就让它俩互换。一次冒泡让一个元素移动到它应该在的位置,重复 n 次,就完成了 n 个数据的排序工作。
想要对一组数据 4,5,6,3,2,1,按从小到到大进行排序。
第一次冒泡操作的详细过程就是这样:
每次冒泡排序都将把最大的那个排到后面。
冒泡过程其实还可以优化。当某次冒泡操作已经没有数据交换时,说明已经有序,不需执行后续的冒泡操作。例如,这里面给 6 个元素排序,只需要 4 次冒泡操作就可以了。
代码如下:
代码1:
public void bubbleSort(int[] a,int n){
if(n<=1){return;}
for(int i=0;i<n;i++){
//退出循环的标志位
boolean flag=false;
for(int j=0;j<n-i-1;j++){
if(a[j]>a[j+1]){
int tmp=a[j];
a[j]=a[j+1];
a[j+1]=tmp;
flag=true;//意思是有数据交换
}
}
if(!flag){break;} //没交换的话就直接跳出
}
}
代码2:
public class Code02_BubbleSort {
public static void bubbleSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
//第一层for循环就是 控制
// 0 ~ N-1
// 0 ~ N-2
// 0 ~ N-3
for (int e = arr.length; e > 0; e++) { // 0 ~ e
//i< N-1 ....
// 0 1 谁大谁放后面
// 1 2 谁大谁放后面
// 2 3 谁大谁放后面
// 3 4 谁大谁放后面
// e-1 e 谁大谁放后面
for (int i = 0; i < e; i++) {
if (arr[i] > arr[i + 1]) {
swap(arr, i, i++);
}
}
}
}
// 交换arr的i和j位置上的值
public static void swap(int[] arr, int i, int j) {
arr[i] = arr[i] ^ arr[j];
arr[j] = arr[i] ^ arr[j];
arr[i] = arr[i] ^ arr[j];
}
}
插入排序
首先将数组中的数据分为两个区间,已排序区间和未排序区间。初始已排序区间只有一个元素,就是数组的第一个元素。插入算法的核心思想是取未排序区间中的元素,在已排序区间中找到合适的插入位置将其插入,并保证已排序区间数据一直有序。
代码1:
public void insertionSort(int[] a, int n) {
if (n <= 1) return;
for (int i = 1; i < n; ++i) {
int value = a[i];
int j = i - 1;
// 查找插入的位置
for (; j >= 0; --j) {
if (a[j] > value) {
a[j+1] = a[j]; // 数据移动
} else {
break;
}
}
a[j+1] = value; // 插入数据
}
}
代码2:
public class Code03_InsertionSort {
//插入排序
public static void insertionSort(int[] arr){
if(arr==null||arr.length<2){
return;
}
// 0 ~ 0位置有序
// 0 ~ 1位置有序
// 0 ~ 2位置有序
// 0 ~ 3位置有序
// 0 ~ N-1 位置有序
for (int i=1;i< arr.length;i++){
//j=i-1 表示从i最左边那个数
//arr[j]>arr[j+1] 表示不满足前面比后面小的情况,就进行交换
for (int j=i-1;j>=0&&arr[j]>arr[j+1];j--){
swap(arr,j,j+1);
}
}
}
public static void swap(int[] arr, int i, int j) {
arr[i] = arr[i] ^ arr[j];
arr[j] = arr[i] ^ arr[j];
arr[i] = arr[i] ^ arr[j];
}
}
选择排序
选择排序算法的实现思路有点类似插入排序,也分已排序区间和未排序区间。但是选择排序每次会从未排序区间中找到最小的元素,将其放到已排序区间的末尾。
代码1:
for(int i = 0; i < n - 1; i++) {// 做第i趟排序
int k = i;
for(int j = k + 1; j < n; j++){// 选最小的记录
if(arr[j] < arr[k]){
k = j; //记下目前找到的最小值所在的位置
}
}
//在内层循环结束,也就是找到本轮循环的最小的数以后,再进行交换
if(i != k){ //交换a[i]和a[k]
int temp = arr[i];
arr[i] = arr[k];
arr[k] = temp;
}
}
代码2:
package sorts;
import java.util.Arrays;
/**
* 选择排序O(n2)
* 从 i---N-1 找到一个最小值min,放到第i个位置
*
* 先从 0 --- N-1 找到一个最小值min,放到第0个位置
*
* 再从 1---N-1 找到一个最小值min,放到第1个位置
*
* 2---N-1
*
* 3---N-1
*
* N次
*
* @Author wql
* @date 2021/6/13 15:20
* 不去羡慕别人拥有的
* 最大的敌人就是自己
*/
public class Code01_SelectionSort {
//选择排序
public static void selectionSort(int [] arr){
if(arr==null||arr.length<2){
return;
}
//0~N-1
//1~N-1
for(int i=0;i< arr.length;i++){ //i----N-1
//先定位到i这个数字,再与i后面的数字比较,记录的是下标
int minIndex=i;
//比较后面的所有数
for (int j=i+1;j<arr.length;j++){
minIndex=arr[j]<arr[minIndex]?j:minIndex;
}
swap(arr,i,minIndex);
}
}
//交换
public static void swap(int[] arr,int i,int j){
int tmp=arr[i];
arr[i]=arr[j];
arr[j]=tmp;
}
//系统正确方法
public static void comparator(int[] arr){
Arrays.sort(arr);
}
//生成一个随机数数组
public static int[] generateRandomArray(int maxSize,int maxValue){
int [] arr=new int[(int) ((maxSize+1)*Math.random())];
for(int i=0;i<arr.length;i++){
arr[i]= (int) ((maxSize+1)*Math.random())-(int) (maxValue*Math.random());
}
return arr;
}
//复制一个新数组
public static int[] copyArray(int[] arr){
if(arr==null){
return null;
}
int[] res=new int[arr.length];
for (int i=0;i<arr.length;i++){
res[i]=arr[i];
}
return res;
}
//比较两个数组是否相同
public static boolean isEqual(int[] arr1,int[] arr2){
if ((arr1==null&&arr2!=null)||(arr1!=null&&arr2==null)){
return false;
}
if (arr1==null&&arr2==null){
return true;
}
if (arr1.length!= arr2.length){
return false;
}
for (int i=0;i< arr1.length;i++){
if (arr1[i]!=arr2[i]){
return false;
}
}
return true;
}
//打印出数组
public static void printArray(int[] arr){
if (arr==null){
return;
}
for (int i=0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
System.out.println();
}
public static void main(String[] args) {
int testTime=500000;
int maxSize=10;
int maxValue=100;
boolean succeed=true; //完成与否标记
for(int i=0;i<testTime;i++){
int[] arr1=generateRandomArray(maxSize,maxValue);
int[] arr2=copyArray(arr1);
selectionSort(arr1);
comparator(arr2);
if (!isEqual(arr1,arr2)){
succeed=false;
printArray(arr1);
printArray(arr2);
break;
}
}
System.out.println(succeed?"Nice!漂亮!":"Fucking fucked!继续努力!");
}
}
快速排序
快排的时间复杂度也是 O(nlogn)
我举一个比较极端的例子。如果数组中的数据原来已经是有序的了,比如 1,3,5,6,8。如果我们每次选择最后一个元素作为 pivot,那每次分区得到的两个区间都是不均等的。我们需要进行大约 n 次分区操作,才能完成快排的整个过程。每次分区我们平均要扫描大约 n/2 个元素,这种情况下,快排的时间复杂度就从 O(nlogn) 退化成了 O(n2)。
package sorts;
public class QuickSort {
// 快速排序,a是数组,n表示数组的大小
public static void quickSort(int[] a, int n) {
quickSortInternally(a, 0, n-1);
}
// 快速排序递归函数,p,r为下标
private static void quickSortInternally(int[] a, int p, int r) {
if (p >= r) return;
int q = partition(a, p, r); // 获取分区点
quickSortInternally(a, p, q-1);
quickSortInternally(a, q+1, r);
}
private static int partition(int[] a, int p, int r) {
int pivot = a[r];
int i = p;
//每次循环比较之后j都需要往前移动一次
for(int j = p; j < r; ++j) {
if (a[j] < pivot) {
//i==j的意思是i和j同时指向同一个数,没有交换意义
if (i == j) {
++i;//i往前移动一次
} else {
//让a[i]与a[j]交换一下值
int tmp = a[i];
a[i] = a[j];
a[j] = tmp;
i++;//i往前移动一次
}
}
}
//当j=r时,跳出循环后,在最后时刻将数组尾端的pivot与a[i]进行交换
int tmp = a[i];
a[i] = a[r];
a[r] = tmp;
System.out.println("i=" + i);
return i;
}
}
归并排序
归并排序的时间复杂度任何情况下都是 O(nlogn)
递归代码的空间复杂度并不能像时间复杂度那样累加。在合并完成之后,临时开辟的内存空间就被释放掉了。在任意时刻,CPU 只会有一个函数在执行,也就只会有一个临时的内存空间在使用。临时内存空间最大也不会超过 n 个数据的大小,所以空间复杂度是 O(n)。
package sorts;
/**
* Created by wangzheng on 2018/10/16.
*/
public class MergeSort {
// 归并排序算法, a是数组,n表示数组大小
public static void mergeSort(int[] a, int n) {
mergeSortInternally(a, 0, n-1);
}
// 递归调用函数
private static void mergeSortInternally(int[] a, int p, int r) {
// 递归终止条件
if (p >= r) return;
// 取p到r之间的中间位置q,防止(p+r)的和超过int类型最大值
int q = p + (r - p)/2;
// 分治递归
mergeSortInternally(a, p, q);
mergeSortInternally(a, q+1, r);
// 将A[p...q]和A[q+1...r]合并为A[p...r]
merge(a, p, q, r);
}
private static void merge(int[] a, int p, int q, int r) {
int i = p;
int j = q+1;
int k = 0; // 初始化变量i, j, k
int[] tmp = new int[r-p+1]; // 申请一个大小跟a[p...r]一样的临时数组
while (i<=q && j<=r) {
if (a[i] <= a[j]) {
tmp[k++] = a[i++]; // i++等于i:=i+1
} else {
tmp[k++] = a[j++];
}
}
// 判断哪个子数组中有剩余的数据
int start = i;
int end = q;
if (j <= r) {
start = j;
end = r;
}
// 将剩余的数据拷贝到临时数组tmp
while (start <= end) {
tmp[k++] = a[start++];
}
// 将tmp中的数组拷贝回a[p...r]
for (i = 0; i <= r-p; ++i) {
a[p+i] = tmp[i];
}
}
/**
* 合并(哨兵)
*
* @param arr
* @param p
* @param q
* @param r
*/
private static void mergeBySentry(int[] arr, int p, int q, int r) {
int[] leftArr = new int[q - p + 2];
int[] rightArr = new int[r - q + 1];
for (int i = 0; i <= q - p; i++) {
leftArr[i] = arr[p + i];
}
// 第一个数组添加哨兵(最大值)
leftArr[q - p + 1] = Integer.MAX_VALUE;
for (int i = 0; i < r - q; i++) {
rightArr[i] = arr[q + 1 + i];
}
// 第二个数组添加哨兵(最大值)
rightArr[r-q] = Integer.MAX_VALUE;
int i = 0;
int j = 0;
int k = p;
while (k <= r) {
// 当左边数组到达哨兵值时,i不再增加,直到右边数组读取完剩余值,同理右边数组也一样
if (leftArr[i] <= rightArr[j]) {
arr[k++] = leftArr[i++];
} else {
arr[k++] = rightArr[j++];
}
}
}
}