冒泡排序快速排序

冒泡排序

        int a[] = {-2,10, 5,1,9,-8,4,6,7,8,2,3};
        
        //冒泡排序
        for (int i = 0; i < a.length-1; i++) {
            for (int j = 0; j < a.length-i; j++) {
                if (a[j]>a[j+1]){
                    int temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                }
            }
        }

结束条件:在任何一趟进行过程中，未出现交换。

    public void bubble(int a[],int n){
        int i,j,swap;//当swap为0则停止排序
        for ( i = 0; i < n; i++) {
            swap = 0; 
            for (j = 0; j < n-i; j++) {
                if (a[j]>a[j+1]){
                    int temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                    swap = 1; 
                }
            }
            if (swap==0){ //未出现交换,排序完成结束循环
                break;
            }
        }
    }

动画更容易理解，相邻的比较然后把大的放在后边，每次循环最后一位就固定
每一趟进行的过程:从第一个元素开始，比较两个相邻的元素。
若相邻的元素的相对位置不正确,则进行交换;否则继续比较下面两个相邻的元素。

冒泡排序的效率
从冒泡排序的算法可以看出，若待排序的元素为正序，则只需进行一趟排序，比较次数为(n-1)次，移动元素次数为0;
若待排序的元素为逆序，则需进行n-1趟排序，比较次数为(n²-n)/2，移动次数为3(n²-n)/2，因此冒泡排序算法的 时间复杂度为O（n²) 。由于其中的元素移动较多，所以属于内排序中速度较慢的一种。
因为冒泡排序算法只进行元素间的顺序移动，所以是一个稳定的算法。

快速排序（分区交换排序）

快速排序(Quick Sorting）是迄今为止所有内排序算法中速度最快的一种。它的基本思想是:任取待排序序列中的某个元素作为标准（也称为支点、界点，一般取第一个元素)，通过一次划分，将待排元素分为左右两个子序列，左子序列元素的排序码均小于基准元素的排序码，右子序列的排序码则大于或等于基准元素的排序码。然后分别对两个子序列继续进行划分，直至每一个序列只有一个元紊为止。最后得到的序列便是有序序列。

内部排序：数据不是很大在内存中完成
外部排序：涉及到磁盘，数据量太大了，一次加载不过来，需要借助于磁盘

数组的sort排序的底层

Arrays.sort(arr1);//底层用的快排

数组的逆序

    public static void main(String[] args){

        int arr[] = {9,8,7,6,5,4,3,2,1};
        for (int i = 0; i < arr.length/2; i++) {
            int temp = arr[i];
            arr[i] =arr[arr.length-1-i];
            arr[arr.length-1-i] = temp;
        }
        System.out.println(Arrays.toString(arr));

    }

结果输出：
[1, 2, 3, 4, 5, 6, 7, 8, 9]

举例

//1.实现冒泡排序
//2.实现数组的逆序
//3.二分查找

    //1.实现冒泡排序
    //2.实现数组的逆序
    //3.查找
    public static void main(String[] args) {
        int a[] = new int[]{-1,-2,5, 4, 3, 2, 1, 0};
        System.out.println("逆序之前的"+ Arrays.toString(a));
        reverse(a, a.length);
        System.out.println("逆序之后的"+ Arrays.toString(a));

        System.out.println("========================");
        System.out.println("排序之前："+Arrays.toString(a));
        sort(a,a.length);
        System.out.println("排序之后："+Arrays.toString(a));

        find(a,a.length,-2);
    }

    public static void reverse(int a[], int n) {
        for (int i = 0; i < n / 2; i++) {
            int temp = a[i];
            a[i] = a[n-1-i];
            a[n-1-i] = temp;
        }
    }

    public static void sort(int[] a, int n) {
        int swap = 0;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - 1 - i; j++) {
                if (a[j] > a[j + 1]) {
                    int temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                    swap=1;
                }
            }
            if (swap==0){
                System.out.println("排序结束");
                break;
            }
        }
    }
    public static void find(int a[],int n,int desc){
        int start=0;
        int end = n-1;
        int mid;
        while (start<=end){
            mid = (start+end)/2;
            if (a[mid]==desc){
                System.out.println("找到了，"+desc+"的下标为"+mid);
                break;
            }else if (a[mid]>desc){
                end = mid-1;
            }else {
                start = mid+1;
            }
        }
        if (start>end){
            System.out.println("抱歉没有找到！");
        }
    }

逆序之前的[-1, -2, 5, 4, 3, 2, 1, 0]
逆序之后的[0, 1, 2, 3, 4, 5, -2, -1]
========================
排序之前：[0, 1, 2, 3, 4, 5, -2, -1]
排序之后：[-2, -1, 0, 1, 2, 3, 4, 5]
找到了，-2的下标为0