基础算法整理

这段时间准备笔试面试，得重新巩固一下基础算法，虽然很基础，但还是要get hands dirty！

1.排序

非常好的可视化算法网站

发现更大的世界

1.插入排序

思路：比较相邻的数，在index=i时，保证[0,i]区间上是有序的。则index=length时，整个区间有效。

import java.util.Random;

public class Main {

    public static void main(String[] args) {
        System.out.println("Hello World!");
        int length = 100;
        int[] input = new int[length];
        Random rand = new Random();
        for (int i = 0; i < input.length; i++) {
            input[i] = rand.nextInt(100);
        }
        int[] result = insertionSort(input);
        for (int i = 0; i < result.length-1; i++) {
            if(result[i]>result[i+1]){
                System.out.println(false);
                return;
            }
        }
        System.out.println(true);
    }

    public static int[] insertionSort(int[] input){
        for (int i = 1; i < input.length; i++) {
            while(i>=1&&(input[i]<input[i-1])){
                int tmp = input[i];
                input[i] = input[i-1];
                input[i-1] = tmp;
                i--;
            }
        }
        return input;
    }
}

2.冒泡排序

思路：每一次将最大的数移动到末尾。

public static int[] bubbleSort(int[] input){
        for (int j = input.length-1; j>=0; j--) {
            for (int i = 0; i <= j-1; i++) {
                if(input[i]>input[i+1]){
                    int tmp = input[i];
                    input[i] = input[i+1];
                    input[i+1] = tmp;
                }
            }
        }
        return input;
    }

3.选择排序

思路：跟冒泡排序差不多，每次循环都将一个最小的前置。在过程中不做值交换，只是记录最小值的index，一次循环结束后再交换。

public static int[] selectSort(int[] input){
        for (int j = 0; j<input.length; j++) {
            int index = Integer.MIN_VALUE,min=Integer.MAX_VALUE;
            for (int i = j; i < input.length; i++) {
                if(input[i]<min){
                    min = input[i];
                    index = i;
                }
            }
            int tmp = input[j];
            input[j] = input[index];
            input[index] = tmp;
        }
        return input;
    }

4.归并排序

思路：归并排序就是两步，1.分部排序，2.归并之。

public static int[] mergeSort(int[] input){
        sort(input,0,input.length-1);
        return input;
    }

    public static void sort(int[] input,int l,int r){
        if(l>=r){
            return;
        }
        int m = l+(r-l)/2;
        sort(input,l,m);
        sort(input,m+1,r);
        merge(input,l,m,r);
    }

    public static void merge(int[] input,int l,int m,int r){
        int[] tmp = new int[r-l+1];
        int i=l,j=m+1,k=0;
        while ((i<=m)&&(j<=r)){
            if(input[i]<=input[j]){
                tmp[k] = input[i];
                k++;
                i++;
            }else{
                tmp[k] = input[j];
                k++;
                j++;
            }
        }
        while (i<=m){
            tmp[k] = input[i];
            k++;
            i++;
        }
        while(j<=r){
            tmp[k] = input[j];
            k++;
            j++;
        }
        int mm =0;
        int nn = l;
        while(nn<=r){
            input[nn] = tmp[mm];
            mm++;
            nn++;
        }
    }

5.快速排序

public static int[] quickSort(int[] input){
        quickSortRecursive(input,0,input.length-1);
        return input;
    }

    public static void quickSortRecursive(int[] input,int l,int r){
        if(r-l<=0){
            return;
        }
        //random pick
//        Random rand = new Random();
//        int index = rand.nextInt(r-l+1)+l;
//        int num = input[index];
        //这种写法num只能取第一个元素的值
        //可以试试将l换成l+1或者其他随机数，将不会得到正确答案
        //当然其实可以实现随机取数，只要在排序前将随机数与
        //第一个数交换即可
        int num = input[l];
        int i=l,j=r;
        while(i<j){
            //i与j一边一次
            while((i<j)&&(input[j]>=num)){
                j--;
            }
            if(i<j){
                int tmp = input[i];
                input[i] = input[j];
                input[j] = tmp;
                i++;
            }
            while((i<j)&&(input[i]<=num)){
                i++;
            }
            if(i<j){
                int tmp = input[i];
                input[i] = input[j];
                input[j] = tmp;
                j--;
            }
        }
        //assert i==j
        if(i>l){
            quickSortRecursive(input,l,i-1);
        }
        if(i<r){
            quickSortRecursive(input,i+1,r);
        }
    }

6.shell排序

是对插入排序的改进，当增量为1时，弱化为插入排序。并且在增量不为1时，也是利用插入排序来计算的。

增量的取值规则为第一次取总长度的一半,第二次取一半的一半,依次累推直到1为止。

6.堆排序
7.计数排序
8.桶排序

4.shell排序