冒泡排序
时间复杂度O(N^2)
空间复杂度O(1)
public class BubbleSort {
public static void main(String[] args) {
int []arr = {39,12,25,36,69,42,58,10,1};
for (int i = 0; i < arr.length - 1; i++) {
for (int j = i + 1; j < arr.length; j++) {
int temp = 0;
if(arr[i] > arr[j]){
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
}
快速排序 *()
时间复杂度O(nlogn)~O(n方)
最优的情况下空间复杂度为:O(logn),每一次都平分数组的情况
最差的情况下空间复杂度为:O( n ),退化为冒泡排序的情况下
public class QuickSort {
public static void main(String[] args) {
int[] arr = {39, 12, 25, 36, 69, 42, 58, 10, 1, -10, -30};
quickSort(arr, 0, arr.length - 1);
for (int i = 0; i < arr.length - 1; i++) {
System.out.print(arr[i] + " ");
}
}
public static void quickSort(int[] arr, int left, int right) {
int i = left;
int j = right;
if (i > j) {
return;
}
int base = arr[left]; //这句一定要在i>j的判断后,因为left会数组下标越界
while (i != j) {
while (i < j && arr[j] >= base) {
j--;
}
while (i < j && arr[i] <= base) {
i++;
}
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
arr[left] = arr[i];
arr[i] = base;
quickSort(arr, left, j - 1);
quickSort(arr, i + 1, right);
}
}
归并排序
时间复杂度O(n)
空间复杂度O(nlogN)
import java.util.Arrays;
public class MergeSort {
public static void main(String[] args) {
int[] arr = {39, 12, 25, 36, 69, 42, 58, 10, 1, -10, -30};
sort(arr);
System.out.println(Arrays.toString(arr));
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
public static void sort(int[] arr) {
int[] temp = new int[arr.length];
sort(arr, 0, arr.length - 1, temp);
}
public static void sort(int[] arr, int left, int right, int[] temp) {
if (left < right) {
int mid = (left + right) / 2;
sort(arr, left, mid, temp);
sort(arr, mid + 1, right, temp);
mergeSort(arr, left, mid, right, temp);
}
}
public static void mergeSort(int[] arr, int left, int mid, int right, int[] temp) {
int i = left;
int j = mid + 1;
int t = 0; //临时指针
while (i <= mid && j <= right) {
if (arr[i] < arr[j]) {
temp[t++] = arr[i++];
} else {
temp[t++] = arr[j++];
}
}
while (i <= mid) {//将左边剩余元素填充进temp中
temp[t++] = arr[i++];
}
while (j <= right) {//将右序列剩余元素填充进temp中
temp[t++] = arr[j++];
}
t = 0;//复位
while (left <= right) {
arr[left++] = temp[t++];
}
}
}
堆排序
时间复杂度O(nlogn)
空间复杂度O(1)
public class HeapSort {
public static void main(String[] args) {
int []arr = {39, 12, 25, 38, 69, 42, 58, 10, 20};
sort(arr);
for (int a : arr) {
System.out.print(a + " ");
}
}
public static void sort(int []arr){
//构建大顶堆
for (int i = arr.length/2 - 1; i >= 0; i--) {
adjustHeap(arr, i, arr.length);
}
//调整堆结构,将堆顶与末尾交换
for (int k = arr.length - 1; k > 0; k--) {
swap(arr, 0, k);
adjustHeap(arr, 0, k);
}
}
//调整大顶堆
public static void adjustHeap(int []arr, int i, int length){
int temp = arr[i];
for (int j = i*2 + 1; j < length; j = j*2+1) {
if(j + 1< length && arr[j] < arr[j + 1]){//如果左子结点小于右子结点,j指向右子结点
j++;
}
if(arr[j] > temp){
arr[i] = arr[j];
i = j;
}else {
break;
}
}
arr[i] = temp;
}
public static void swap(int []arr,int i, int j){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
插入排序
时间复杂度:最坏情况:O(N^2) 最好情况O(N)
空间复杂度:O(1)
public class InsertSort {
public static void main(String[] args) {
int[] arr = {39, 12, 25, 36, 69, 42, 58, 10, 1, -10, -30};
insertSort(arr);
}
public static void insertSort(int[] a) {
int temp = 0;
for (int i = 1; i < a.length; i++) {//从第二个数开始比较
if (a[i] < a[i - 1]) {
temp = a[i];//将当前数插入到已经有序的数组中
for (int j = i - 1; j >= 0; j--) {
if (a[j] > temp) {//如果前面的数大于当前数,将他后移
a[j + 1] = a[j];
} else {
break;
}
a[j] = temp;//将当前轮数的数放到应该在的位置
}
}
}
for (int i : a) {
System.out.println(i);
}
}
}