冒泡排序
冒泡排序的主要的思想是：比较两个相邻的元素，如果左边大于右边的话就交换两个元素的位置。
这样的背景下：需要两层循环，外层循环根据数组中数目的多少确定循环次数，而内层的循环根据每次比较的次数确定循环次数。这样做的时间复杂度为O（n^2）
public class BubbleSort {
public static void bubbleSort(int[] arr){
if(arr == null )return ;
for(int i=0;i<arr.length;i++){
for(int j=0;j<arr.length-i-1;j++){
if(arr[j]>arr[j+1]){
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
public static void main(String[] args){
int[] arr = {3,4,2,1,7,6};
bubbleSort(arr);
System.out.println(Arrays.toString(arr));
}
}
插入排序
插入排序的优点在于：插入排序可以减少我们的空间复杂度都是在原地上进行插入的所以空间复杂度比较低。
主要的思想是：每个当前元素的数跟其下一个元素进行比较，如果小于下一个元素，则把下个元素拿出来挨个与上面的元素进行比较，然后把上面的元素依次下沉一个位置。
时间复杂度也为O(n^2)，我看到的一个很好的解释的图如下所示，参考的博文的地址如下。
https://www.cnblogs.com/kkun/archive/2011/11/23/2260265.html
上面是参考的博文的地址。
具体的代码实现
import java.util.Arrays;
public class InsertSort {
public static void insertSort(int[] arr){
if(arr == null ) return;
for(int i=0;i<arr.length-1;i++){
// int temp = arr[i];
if(arr[i] > arr[i+1]){
int j = i;
int temp = arr[i+1];
while(j>=0 && arr[j] > temp){
arr[j+1] = arr[j];
j--;
}
arr[j+1] = temp;
}
}
}
public static void main(String[] args){
int[] arr = {3,4,1,2,5,7};
insertSort(arr);
System.out.println(Arrays.toString(arr));
}
}
快速排序
快速排序：排序算法跟名字一样，快速排序时间复杂度为O（nlogn）。
主要的思想在于：
- 设置一个初始的参考值，然后设置一个前指针和一个后指针进行比较
- 如果后指针指向的数字小于参考值的话，那么便交换前指针和后指针的值，然后考虑前指针
- 如果前指针指向的数字大于参考值的，那么同理也交换前指针和后指针的值。再考后指针
- 这样循环指导前指针与后指针重合，让当前指针的数字赋值为参考值，这样便得到一个数组在index前面都小于参考值，在index后面都大于当前值。通过二分的方法把指针变换就能得到一个排序的数组。
代码实现如下所示
import java.util.Arrays;
public class QuickSort {
public static void quickSort(int[] arr,int start,int end){
if(start >= end){
return;
}
int index = partation(arr,start,end);
quickSort(arr,start,index-1);
quickSort(arr,index+1,end);
}
public static int partation(int[] arr,int start,int end){
int key = arr[start];//base参考值
while(start < end){
while(arr[end] > key && start < end){
end--;
}
arr[start] = arr[end];
while(arr[start] <= key && start < end){
start++;
}
arr[end] = arr[start];
}
int index = end;
arr[end] = key;
return index;
}
public static void main(String[] args){
int[] arr = {3,4,2,1,7,6};
quickSort(arr,0,arr.length-1);
System.out.println(Arrays.toString(arr));
}
}
归并排序
递归排序的时间复杂度是O(nlogn),空间复杂度是O(n)
归并排序的主要的思想是分为两步：
1：先把所有的数字且分到最小的粒度，即两个数字
2：然后归并，递归的归并。
如图所示：参考的博客的地址
https://www.cnblogs.com/chengxiao/p/6194356.html
具体的代码实现如下：
public class MergeSort {
public static void sort(int[] arr,int start,int end,int[] temp){//利用temp数组来存储排序以后的数组。
if(start < end){
int mid = (end + start)/2;
sort(arr,start,mid,temp);
sort(arr,mid+1,end,temp);
mergeSort(arr,start,mid,end,temp);
}
}
public static void mergeSort(int[] arr,int start,int mid,int end,int[] temp){
int i=start;
int j=mid+1;
int t=0;
while(i<=mid && j<=end){
if(arr[i]<=arr[j]){
temp[t++] = arr[i++];
}else{
temp[t++] = arr[j++];
}
}
while(i<=mid){
temp[t++] = arr[i++];
}
while(j<=end){
temp[t++] = arr[j++];
}
t=0;
while(start<=end){
arr[start++] = temp[t++];
}
}
public static void main(String[] args){
int []arr = {9,8,7,6,5,4,3,2,1};
int[] temp = new int[arr.length];
sort(arr,0,arr.length-1,temp);
System.out.println(Arrays.toString(arr));
}
}