常见排序算法
浙江大学数据结构课程
时间复杂度
- what：评价算法好坏（读big O）
- 计算方法是：要高阶去低阶
- 运行时间不是指实际程序运行的时间 而是程序执行的操作数
- 运行时间比较的角度是随着时间的增大函数曲线的变化的幅度
空间复杂度
- what：评价算法好坏（读big O）
- 计算方法是：要高阶去低阶
- O（1）：自己建几个变量
- O（n）：自己建一个数组或者该数组是目标数组的一半（忽略系数）
常见排序算法性能
| 算法 | 时间复杂度 | 空间复杂度 | 稳定性 |
|---|---|---|---|
| 冒泡排序 | O(N^2) | O(1) | 稳定 |
| 插入排序 | O(N^2) | O(1) | 稳定 |
| 选择排序 | O(N^2) | O(1) | 不稳定 |
| 归并排序 | O(nlogn) | O(n) | 稳定 |
| 快速排序 | O(nlogn) | O(logn) | 不稳定 |
| 堆排序 | O(nlogn) | O(1) | 不稳定 |
0 BaseSort
package 常见排序算法.练习;
import java.util.Arrays;
/**
* @Description:
* @Author: boolean
* @Date: 2019/11/17 18:14
*/
public abstract class BaseSort {
// for test
public static void comparator(int[] arr) {
Arrays.sort(arr);
}
public static void swap(int[] arr, int i, int j) {
//其实就是交换
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
// for test
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) ((maxValue + 1) * Math.random());
}
return arr;
}
// for test
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;
}
// for test
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;
}
// for test
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 void testSort(BaseSort sort){
int testTime = 500000;
int maxSize = 100;
int maxValue = 100;
boolean succeed = true;
for (int i = 0; i < testTime; i++) {
int[] arr1 = generateRandomArray(maxSize, maxValue);
int[] arr2 = copyArray(arr1);
sort.sort(arr1);
comparator(arr2);
if (!isEqual(arr1, arr2)) {
succeed = false;
break;
}
}
System.out.println(succeed ? "Nice!" : "Fucking fucked!");
int[] arr = generateRandomArray(maxSize, maxValue);
printArray(arr);
sort.sort(arr);
printArray(arr);
}
protected abstract void sort(int[] arr);
}
1.冒泡排序（BubbleSort）
思想：
https://www.cnblogs.com/kkun/archive/2011/11/23/bubble_sort.html
代码1
import java.util.Arrays;
/**
* Created by buer on 2018/8/13.
*/
//冒泡排序
public class BubbleSort {
/**
* 进行冒泡函数
* @param arr
*/
public static void bubbleSort(int[] arr){
if (arr == null || arr.length < 2){
return;
}
for (int end = arr.length - 1; end > 0; end--){ //控制队列尾部位置，不断向前
for (int i = 0; i < end; i ++){ //从头到尾两两比较
if (arr[i] > arr[i + 1]){
swap(arr, i, i+1);
}
}
}
}
/**
* 交换函数
*/
public static void swap( int[] arr, int i, int j){
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
//其实就是交换
//arr[i] = arr[i] ^ arr[j];
//arr[j] = arr[i] ^ arr[j];
//arr[i] = arr[i] ^ arr[j];
}
}
2.选择排序（SelectSort）
思想：
- 1 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，
- 2 然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
- 3 以此类推，直到所有元素均排序完毕。
代码1
public class SelectSort extends BaseSort {
@Override
protected void sort(int[] arr) {
for (int i = 0; i < arr.length -1 ; i++) {
int min = i;
for (int j = i + 1; j < arr.length; j++) {
if (arr[min] > arr[j]){
min = j;
}
}
swap(arr, i, min);
}
}
@Test
public void test(){
BaseSort sort = new SelectSort();
sort.testSort(sort);
}
}
3.插入排序（InsertSort）
思想：
和打牌一样,后来的牌与前面相比，如果前面的牌大，就将大的牌向后移动
代码：
import java.util.Arrays;
/**
* Created by buer on 2018/8/15.
*/
public class InsertSort extends BaseSort {
@Override
protected void sort(int[] arr) {
for (int i = 1; i < arr.length; i++) {
for (int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j --) {
swap(arr, j, j + 1);
}
}
}
@Test
public void test( ){
BaseSort sort = new InsertSort();
sort.testSort(sort);
}
}
4.归并排序
思想：
https://www.cnblogs.com/chengxiao/p/6194356.html
- 1.按中间位置左右递归划分模块
- 2.申请一个辅助数组
- 2.比较两个数组元素的大小，按小到大放进辅助数组中
- 3.比较后剩余元素直接放在辅助数组后面
- 4.将辅助数组放进原来的数组
代码
import java.util.Arrays;
public class Code_05_MergeSort {
public static void mergeSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
mergeSort(arr, 0, arr.length - 1);
}
public static void mergeSort(int[] arr, int l, int r) {
if (l == r) {
return;
}
int mid = l + ((r - l) >> 1); //l r中点 位运算
mergeSort(arr, l, mid); //左部分有序
mergeSort(arr, mid + 1, r); //有部分有序
merge(arr, l, mid, r);
}
public static void merge(int[] arr, int l, int m, int r) {
int[] help = new int[r - l + 1];
int i = 0;
int p1 = l; //左部分第一个数
int p2 = m + 1; //有部分第一个数
while (p1 <= m && p2 <= r) {
help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++]; //填的数字加1之前的数
}
//下面两个循环只发生一个
while (p1 <= m) {
help[i++] = arr[p1++];
}
while (p2 <= r) {
help[i++] = arr[p2++];
}
for (i = 0; i < help.length; i++) {
arr[l + i] = help[i];
}
}
}
5 快速排序
思想
- 1 找出基准（选中间值）
- 2 移动左边数字直到数字大于基准
- 3 移动右边数字直到数字小于基准
- 4 交换左右数字(与基准值相等的数可以到任何一边)
- 5 左边递归
- 6 右边递归
public class QucikSort {
public static void quickSort(int[] arr, int left, int right){
if ( left >= right||arr == null || arr.length <= 1){
return;
}
int pivot = arr[left + ((right - left) >> 1)];
int i = left;
int j = right;
while (i <= j ){
while (arr[i] < pivot){
++i ;
}
while (arr[j] > pivot){
-- j ;
}
if (i < j) {
int t = arr[i];
arr[i] = arr[j];
arr[j] = t;
++i;
--j;
} else if (i == j) {
++i;
}
}
quickSort(arr, left, j);
quickSort(arr,i, right);
}
}
tip
快速排序适合大数据排序，小数据的话插入排序更为适合
6.堆排序
思想：
- 1.从右到左，从下到上创建大顶堆
- 2.将堆顶元素放到数组最后，调整大顶堆
图例：
代码：
public class HeapSort extends BaseSort {
@Override
protected void sort(int[] arr) {
//1.构建大顶堆
for(int i=arr.length/2-1;i>=0;i--){
//从第一个非叶子结点从下至上，从右至左调整结构
adjustHeap(arr,i,arr.length);
}
//2.调整堆结构+交换堆顶元素与末尾元素
for(int j=arr.length-1;j>0;j--){
swap(arr,0,j);//将堆顶元素与末尾元素进行交换
adjustHeap(arr,0,j);//重新对堆进行调整
}
}
/**
* 调整大顶堆（仅是调整过程，建立在大顶堆已构建的基础上）
* @param arr
* @param i
* @param length
*/
public static void adjustHeap(int []arr,int i,int length){
int temp = arr[i];//先取出当前元素i
for(int k=i*2+1;k<length;k=k*2+1){//从i结点的左子结点开始，也就是2i+1处开始
if(k+1<length && arr[k]<arr[k+1]){//如果左子结点小于右子结点，k指向右子结点
k++;
}
if(arr[k] >temp){//如果子节点大于父节点，将子节点值赋给父节点（不用进行交换）
arr[i] = arr[k];
i = k;
}else{
break;
}
}
arr[i] = temp;//将temp值放到最终的位置
}
private void swap(int[] arr, int i, int j) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
public static void main(String[] args) {
BaseSort sort = new HeapSort();
sort.testSort(sort);
}
}
