算法基础（1）

目录

引言

算法时间复杂度 

排序算法

冒泡排序

选择排序

插入排序

希尔排序

归并排序

---

引言

主要内容：时间复杂度，二分查找，常见排序算法 

算法时间复杂度 

表示方法：（大O表示法），通常是表示一个算法最坏情况下所需“消耗的最大时间”；

注：算法的速度并非指所消耗的时间，而是指随输入数量的增加，计算所耗费时间的增速

常见的大O运行时间

排序算法

冒泡排序

public class BubbleSort {

    static int[] bubbleSort(int[] arrays){

        for (int i=0; i<arrays.length; i++){
            for (int j=i+1; j<arrays.length; j++){
                if (arrays[i]>arrays[j]){
                    int tmp = arrays[i];
                    arrays[i] = arrays[j];
                    arrays[j] = tmp;
                }
            }
        }

        return arrays;
    }

    public static void main(String[] args) {
        int[] ret = bubbleSort(new int[]{4,5,29,41,2,17});

        for (int t : ret){
            System.out.println(t);
        }
    }
}

选择排序

package org.example.algrithms;

import java.util.Arrays;


public class SelectionSort {

    static Integer[] selectionSort(Integer[] arrays){

        for (int i=0; i< arrays.length; i++){
            int minIndex = i;
            for (int j=i+1; j<arrays.length; j++){

                if (arrays[j] < arrays[minIndex]){
                    minIndex = j;

                }
            }
            if (minIndex != i){
                int tmp = arrays[i];
                arrays[i] = arrays[minIndex];
                arrays[minIndex] = tmp;
            }
        }

        return arrays;
    }

    public static void main(String[] args) {

        Integer[] arrays = new Integer[]{4,5,29,41,2,17};
        Integer[] result = selectionSort(arrays);
        Arrays.asList(result).forEach(System.out::println);
    }
}

插入排序

public class InsertionSort {

    static int[] insertionSort(int[] arrays){

        for (int i=1; i<arrays.length; i++){
            int tmp = arrays[i];
            int j=i;

            while (j>0 && tmp < arrays[j-1]){
                arrays[j] = arrays[j-1];
                j--;
            }

            if (i!=j){
                arrays[j] = tmp;
            }
            
        }
        return arrays;
    }

    public static void main(String[] args) {

        int[] elements = new int[]{30, 34, 33,  17, 4, 6, 10, 31};
        int[] result = insertionSort(elements);

        for (int e: result){
            System.out.println(e);
        }
    }
}

希尔排序

todo

归并排序

public class MergeSort {

    static int[] mergeSort(int[] arrays){

        if (arrays.length < 2){
            return arrays;
        }

        int[] left = Arrays.copyOfRange(arrays, 0, (int)Math.floor(arrays.length/2));
        int[] right = Arrays.copyOfRange(arrays, (int)Math.floor(arrays.length/2), arrays.length);

        return merge(mergeSort(left), mergeSort(right));
    }

    static int[] merge(int[] left, int[] right){

        int[] ret = new int[left.length + right.length];

        int i=0;
        while (left.length > 0 && right.length>0){
            if (left[0] <= right[0]){
                ret[i++] = left[0];
                left = Arrays.copyOfRange(left, 1, left.length);
            }else {
                ret[i++] = right[0];
                right = Arrays.copyOfRange(right, 1, right.length);
            }
        }

        while (left.length > 0){
            ret[i++] = left[0];
            left = Arrays.copyOfRange(left, 1, left.length);
        }

        while (right.length > 0){
            ret[i++] = right[0];
            right = Arrays.copyOfRange(right, 1, right.length);
        }
        return  ret;
    }

    public static void main(String[] args) {

        int[] elements = new int[]{30, 34, 33,  17, 4, 6, 10, 31};
        int[] result = mergeSort(elements);

        for (int e: result){
            System.out.println(e);
        }
    }
}

Reference: [1] 1.0 十大经典排序算法 | 菜鸟教程