常用算法

算法(algorithm)

是解决特定问题求解步骤的模板，在计算机中表现为指令的有限序列，并且每条指令表示一个或多个操作。

1，穷举和递归。

穷举是算法中最基础的的，依次访问所有的可能情况。

递归是自己直接的或者间接的调用自己，直到出现停止条件，才返回。（如：斐波那契数列）

public static int recursion(int n){
    if(n==1){
        return 0;
    }
    if(n==2){
        return 1;
    }
    return recursion(n-1)+recursion(n-2);
}

2，排序

选择排序

每一次循环找到最大或者最小的放到有序数列中。第二次循环接着放到有序数列中直到完成。

public static void toSort1(int[] date){
    int smaller;
    for (int i = 0; i <date.length-1 ; i++) {
        smaller=i;
        for (int j = i+1; j <date.length ; j++) {
            if(date[smaller]>date[j]){
                smaller=j;
            }
        }
        if(smaller!=i){
            int temp=date[smaller];
            date[smaller]=date[i];
            date[i]=temp;
        }
    }
}

冒泡排序（优化：为排序插入true或者false防止在后几次排序完成还循环）

将相邻的两个数比较，将大（小）的一直往后交换，直到最大（最小）到最后。第二次循环继续。

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

插入排序（优化，希尔排序）

从第二个数开始，将与前面有序的数字比较，放入其该放的位置。

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

快速排序

 从数列中挑出一个元素，称为 “基准”（pivot），重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

private static void quick_sort(int[] arr, int low, int high) {
    // 解决和合并
    if (low <= high) {
        int mid = partition(arr, low, high);
        // 递归
        quick_sort(arr, low, mid - 1);
        quick_sort(arr, mid + 1, high);
    }

}
private static int partition(int[] arr, int low, int high) {
    // 分解
    int pivot = arr[high];
    int i = low - 1;
    int temp;
    for (int j = low; j < high; j++) {
        if (arr[j] < pivot) {
            i++;
            temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }
    // 交换中间元素和privot
    temp = arr[i + 1];
    arr[i + 1] = arr[high];
    arr[high] = temp;
    return i + 1;
}

其他还有堆排序，归并排序等。

使用这个网站查看各种排序的过程动画http://www.webhek.com/post/comparison-sort.html；

3，查找

二分查找法（前提是有序的集合）

定义三个指针，min，max，mid，mid=（min+max）/2.

比较查找数和mid索引的值。

1，查找数大，则将min更正为mid+1.重新得到新的mid

2，查找数小，则将max更正为mid-1.重新得到新的mid

3，相等，查找到，得到查找数的索引。

如果没有找到返回-1.停止条件，min>max

public static int halfSearch(int[] arr, int number) {
    int min = 0;
    int max = arr.length-1;
    int mid = 0;
    while (min <= max) {
        mid = (min + max) / 2;
        if(arr[mid]>number){
            max=mid-1;
        }else if(arr[mid] < number){
            min = mid+1;
        }else{
            return mid ;
        }
    }
    return -1;
}