经典排序算法

1、冒泡排序

public class MaopaoSort {
    public static void main(String[] args) {
        int[] numbers=new int[]{80,60,50};
        for(int i = 0;i < numbers.length - 1; i++)  //外层循环，表示要排多少轮。n个数，排n-1轮即可。当然，这里排n轮，n+1轮都是没问题的
        {   //冒泡排序，相邻两个数据比较大小，直到最大值放到最右边。然后下一次就比较最大值左边的数即可。所以内循环要循环的次数越来越少
            //将最值放到最右边，那么内循环j从0开始；如果将最值放到最左边，内循环j从数组长度开始
            for(int j=0; j < numbers.length - i - 1;j++)
            {
                if(numbers[j] > numbers[j+1])
                {
                    int temp = numbers[j];
                    numbers[j]=numbers[j+1];
                    numbers[j+1]=temp;
                }
            }
        }
    }
}

2、二分查找

public class TowfenSearch {
    int[] a = {1,3,5,8,10,20,31,32};
    public int search(int target) {
        int startPoint = 0;
        int endPoint = a.length -1; //要-1，否则临界点比如搜索33，查到的index就会是a.length=8，而此时数组是没有第8个元素的
        while (startPoint <= endPoint) {    //记得加相等条件
            int mid = (startPoint + endPoint)/2;
            int MiddleV = a[mid];
            if (MiddleV == target) {
                return mid;
            } else if (MiddleV < target){
                startPoint = mid +1;
            } else if (MiddleV > target) {
                endPoint = mid -1;
            }
        }
        return -1;
    }
}

3、归并排序java
归并排序算法有两个基本的操作，一个是分，也就是把原数组划分成两个子数组的过程。另一个是治，它将两个有序数组合并成一个更大的有序数组。
它将数组平均分成两部分: center = (left + right)/2，当数组分得足够小时—数组中只有一个元素时，只有一个元素的数组自然而然地就可以视为是有序的，此时就可以进行合并操作了。因此，上面讲的合并两个有序的子数组，是从 只有一个元素 的两个子数组开始合并的。

public class MergeSort {
    public static void mergeSort(int[] arr) {
        // 空数组 或 只有一个元素的数组，则什么都不做。
        if (arr == null || arr.length <= 1) return;
        mergeSort(arr, 0, arr.length - 1);
    }
 
    private static void mergeSort(int[] arr, int low, int high) {
        if (low >= high) return;
 
        // 计算出中间值，这种算法保证不会溢出。
        int mid = low + ((high - low) >> 1);
        // 先对数组左边排序
        mergeSort(arr, low, mid);
        // 再对数组右边排序
        mergeSort(arr, mid + 1,high);
        //上面两个排序完成后，得到两个排好序的左右子序列
        // 归并两个有序的子序列。其实还是只有一个数组，只是通过下标来划分为两个有序子数组
        merge(arr, low, mid, high);
 
        // 把每一趟排序的结果也输出一下。
        print(arr);
    }
 
    private static void merge(int[] arr, int low, int mid, int high) {
        // temp[]是临时数组，包左不包右，所以要额外 + 1。
        int[] temp = new int[high - low + 1];
        int left = low; // 左侧指针从low开始。
        int right = mid + 1;    // 右侧指针从mid+1开始。
        int index = 0;  // 此索引用于temp[]
        // 当两个子序列还有元素时，从小到大放入temp[]中。
        while (left <= mid && right <= high) {
            if (arr[left] < arr[right]) {
                temp[index++] = arr[left++];
            } else {
                temp[index++] = arr[right++];
            }
        }
 		//排完之后，可能左数组还有一部分数据。或者右数组还有一部分数据。直接添加到临时数组末尾即可
        // 要么左边没有元素
        while (left <= mid) {
            temp[index++] = arr[left++];
        }
 
        // 要么右边没有元素
        while (right <= high) {
            temp[index++] = arr[right++];
        }
 
        // 重新赋值给arr对应的区间。
        for (int i = 0; i < temp.length; i++) {
            arr[low + i] = temp[i];
        }
    }
 
    public static void main(String[] args) {
        int[] arr = {6, 9, 1, 4, 5, 8, 7, 0, 2, 3};
 
        System.out.print("排序前:  ");
        print(arr);
 
        mergeSort(arr);
 
        System.out.print("排序后:  ");
        print(arr);
    }
 
    // 打印数组
    public static void print(int[] arr) {
        if (arr == null)    return;
 
        for(int i : arr) {
            System.out.print(i + " ");
        }
        System.out.println();
    }
}
/*
排序前:  6 9 1 4 5 8 7 0 2 3 
6 9 1 4 5 8 7 0 2 3 
1 6 9 4 5 8 7 0 2 3 
1 6 9 4 5 8 7 0 2 3 
1 4 5 6 9 8 7 0 2 3 
1 4 5 6 9 7 8 0 2 3 
1 4 5 6 9 0 7 8 2 3 
1 4 5 6 9 0 7 8 2 3 
1 4 5 6 9 0 2 3 7 8 
0 1 2 3 4 5 6 7 8 9 
排序后:  0 1 2 3 4 5 6 7 8 9
*/

4、快速排序Java
快速排序是一种排序执行效率很高的排序算法，它利用分治法来对待排序序列进行分治排序，它的思想主要是通过一趟排序将待排记录分隔成独立的两部分，其中的一部分比关键字小，后面一部分比关键字大，然后再对这前后的两部分分别采用这种方式进行排序，通过递归的运算最终达到整个序列有序

public class QuickSort {
    public static void quickSort(int[] arr,int low,int high){
        int i,j,temp,t;
        if(low>high){
            return;
        }
        i=low;
        j=high;
        //temp就是基准位.如果以low作为基准位，那么while循环里面必须先写从右边开始的while循环
        temp = arr[low];
        while (i<j) {
            //先看右边，依次往左递减
            while (temp<=arr[j]&&i<j) {
                j--;
            }
            //再看左边，依次往右递增
            while (temp>=arr[i]&&i<j) {
                i++;
            }
            //如果满足条件则交换
            if (i<j) {
                t = arr[j];
                arr[j] = arr[i];
                arr[i] = t;
            }
        }
        //最后将基准位与i和j相等位置的数字交换
        //temp = arr[low];  这个写在上面了
        arr[low] = arr[j];
        arr[j] = temp;
        //递归调用左数组
        quickSort(arr, low, j-1);
        //递归调用右数组
        quickSort(arr, j+1, high);
    }

    public static void main(String[] args){
        int[] arr = {4,7,62,3,5};
        quickSort(arr, 0, arr.length-1);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}