排序算法及对应的时间复杂度

目录

1.插入排序

2.冒泡排序

3.快速排序

4.归并排序

5.选择排序

6.堆排序

---

1.插入排序

 public static  void insertSort(int[] arr){
        for(int i = 1; i < arr.length; i++){
            int temp = arr[i];
            int j = i-1;
            for(; j >=0; j--){
                if(arr[j] > temp){
                    arr[j+1] = arr[j];
                } else{
                    break;
                }
            }
            arr[j+1] = temp;
        }

    }
    public static void main(String[] args) {
        int[] arr = {1,5,2,3,6,9,3,22,55,12};
        System.out.println(Arrays.toString(arr));
        insertSort(arr);
        System.out.println(Arrays.toString(arr));

    }

2.冒泡排序

package com.Interview;

import java.util.Arrays;

/**
 * @program: sixiang
 * @description
 * @author: wenwen
 * @create: 2021-08-13 21:17
 **/
public class BubbleSort {
    public static void BubbleSort(int[] arr){
        for(int i =0; i < arr.length; i++){
            boolean flag = false;
            for(int j = 0; j < arr.length - 1 - i; j++){
                if(arr[j] > arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                    flag = true;
                }
            }
            if(flag == false){
                return;
            }
        }

    }
    public static void main(String[] args) {
        int[] arr = {1,2,3,66,2,9,0,23,8,9,36,0,2};
        BubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

3.快速排序

package com.Interview;

import java.util.Arrays;

/**
 * @program: sixiang
 * @description
 * @author: wenwen
 * @create: 2021-08-13 20:05
 **/
public class QuickSort {
    public static int partion(int[] arr,int left,int right){
        int temp = arr[left];
        while(left < right){
            while(left < right && arr[right] >= temp){
                right--;
            }
            arr[left] = arr[right];
            while(left < right && arr[left] <= temp){
                left++;
            }
            arr[right] = arr[left];
        }
        arr[left] = temp;
        return left;

    }
    public static void quickSort(int[] arr,int left,int right){
        if(left >= right) return;
        int par = partion(arr,left,right);
        quickSort(arr,left,par-1);
        quickSort(arr,par+1,right);

    }

    public static void main(String[] args){
        int[] arr = {1,2,3,66,2,9,0,23,8,9,36,0,2};
        quickSort(arr, 0,arr.length-1);
        System.out.println(Arrays.toString(arr));
    }
}

4.归并排序

package com.Interview;

import java.util.Arrays;

/**
 * @program: sixiang
 * @description
 * @author: wenwen
 * @create: 2021-08-13 20:21
 **/
public class mergeSort {
    public static void merge(int[] arr,int left,int right,int mid){
        int s1 = left;
        int s2 = mid + 1;
        int index = 0;
        int[] ret = new int[right - left + 1];
        while(s1 <= mid && s2 <= right){
            if(arr[s1] <= arr[s2]){
                ret[index++] = arr[s1++];
            }else{
                ret[index++] = arr[s2++];
            }
        }
        while(s1 <= mid){
            ret[index++] = arr[s1++];
        }
        while(s2 <= right){
            ret[index++] = arr[s2++];
        }
        for(int i =0; i < ret.length; i++){
            arr[left + i] = ret[i];
        }
    }
    public static void mergeSort(int[] arr,int left,int right){
        if(left >= right) return;
        int mid = (right + left)/2;
        mergeSort(arr,left,mid);
        mergeSort(arr,mid+1, right);
        merge(arr,left,right,mid);

    }
    public static void main(String[] args) {
        int[] arr = {1,2,3,66,2,9,0,23,8,9,36,0,2};
        mergeSort(arr, 0,arr.length-1);
        System.out.println(Arrays.toString(arr));
    }
}

5.选择排序

package com.Interview;

import java.util.Arrays;

/**
 * @program: sixiang
 * @description
 * @author: wenwen
 * @create: 2021-08-13 21:27
 **/
public class selectSort {
    public static void selectSort(int[] arr){
        for(int i =0; i < arr.length; i++){
            for(int j =i; j < arr.length; j++){
                if(arr[i] > arr[j]){
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
    }
    public static void main(String[] args) {
        int[] arr = {1,2,3,66,2,9,0,23,8,9,36,0,2};
        selectSort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

6.堆排序

package com.bite.Sort;

import java.util.Arrays;

/**
 * @program: bite
 * @description
 * @author: wenwen
 * @create: 2021-07-17 13:24
 **/
public class HeapSort {
    public static void adjustDown(int[] arr,int parent,int len){
        int child = 2*parent+1;
        while(child < len){
            if(child+1 <len && arr[child] < arr[child+1]){
                child++;
            }
            if(arr[child] > arr[parent]){
                int temp = arr[child];
                arr[child] = arr[parent];
                arr[parent] = temp;
                parent = child;
                child = 2*parent+1;
            } else{
                break;
            }

        }

    }
    public static void createHeap(int[] arr)
    {
        for(int i = (arr.length-1-1)/2; i >= 0; i--){
            adjustDown(arr,i, arr.length);
        }
    }

    public static void heapSort(int[] arr){
        createHeap(arr);
        int end = arr.length-1;
        while(end > 0){
            int temp = arr[0];
            arr[0] = arr[end];
            arr[end] = temp;
            adjustDown(arr, 0, end);
            end--;

        }

    }
    public static void main(String[] args) {
        int[] array = {12,5,9,34,6,8,33,56,89,0,7,4,22,55,77};
        heapSort(array);
        System.out.println(Arrays.toString(array));

    }
}

（1）直接插入排序 是稳定的排序

特点：越有序越快  

最好的情况下【数组中的元素有序】，时间复杂度为O（N）

最坏的情况下【数组中的元素无需】，时间复杂度为O（N*N）

空间复杂度：O（1）

（2）选择排序

时间复杂度：O（N*N）

空间复杂度：O（1）

稳定性：不稳定

（3）堆排序

时间复杂度：O（n*logn）

空间复杂度：O（1）

稳定性：不稳定

（4）快速排序

时间复杂度：O（n*logn）【最好】

时间复杂度：O（N*N）【最坏】

空间复杂度：O（logn）

稳定性：不稳定

（5）堆排序

时间复杂度：O（n*logn）

空间复杂度：O（1）

稳定性：不稳定

（6）归并排序

时间复杂度：O（n*logn）

空间复杂度：O（N）

稳定性：稳定

① 稳定性排序：冒泡排序，插入排序、归并排序

② 不稳定性排序：选择排序、快速排序、希尔排序、堆排序