面试排序算法

总的时间复杂度

冒泡排序

//平均时间复杂度o（n^2） 最坏时间复杂度 o（n^2）
//思路双层for循环，然两个数依次比较大小，大的放后面，每次循环后都会把一个大数放后面，

public class BubbleSort {
    public static void main(String[] args) {
        int a[]={3,-4,0,8,4,10,7};
        int temp=0;  //临时变量用于交换数
        
        for (int i=0;i<a.length;i++){
            for (int j=0;j<a.length-1;j++){
                //因为要和后一位比较，所以必须是length-1
                if (a[j]>a[j+1]){
                    temp=a[j+1];
                    a[j+1]=a[j];
                    a[j]=temp;
                }
            }
        }
        System.out.println(Arrays.toString(a));
    }
}

选择排序

//平均时间复杂度o（n^{2）最坏时间复杂度o（n}2）

//双层for循环，每次选择出最小的和放前面，双层循环结束后排序结束

public class SelectSort {
    public static void main(String[] args) {
        int a[] = {2, 5, -4, 0, 9, 3, 76};
        for (int i = 0; i < a.length; i++) {
            int min = i;
            //必须是j=i+1；确保原先比较过的数不能再次加入比较！ 不然一只是一个最小数！
            for (int j = i+1; j <a.length; j++) {
                if (a[min] > a[j]) {
                    min = j;
                }
            }
            if (i != min) {
                int temp = a[min];
                a[min] = a[i];
                a[i] = temp;
            }
        }
        System.out.println(Arrays.toString(a));
    }
}

插入排序

//平均时间复杂度o（n^{2）最坏时间复杂度o（n}2）
//将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。
//从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）

public class InsertSort {

    public static void main(String[] args) {

        int a[]={3,-4,0,8,4,10,7};

        //i从1开始，为无须数组第一个，  因为0是有序数组
        for (int i=1;i<a.length;i++){

            //无须数组要插入的数
            int temp=a[i];

            // 从已经排序的序列最右边的开始比较，找到比其小的数
            int j=i;
            while (j>0&&temp<a[j-1]){
                //要插入的数从右向左和有序的数组比较，如果比较小，就依次前移比较过的数（因为有序数组新加入了一个数，多了一位）
                a[j] = a[j - 1];
                j--;
            }
            //当上面的循环结束后说明找到了要插入数的位置，并且为原来的有序数组后半（比要插入数大的数）向后移了一位
            if (i!=j){
                a[j]=temp;
            }
        }
        System.out.println(Arrays.toString(a));
    }
}

快速排序

时间复杂度O(nlogn)。最坏时间复杂度o（n^2）

//快速排序：小的放左边-A-大的放右边，A就排好序了
//主流的划分法：交换法、挖空法
//交换法：左边的大数和右边的小数交换一下就好啦
//挖空法：碰到一个不好的数就换一下
//这个正宗合理

 public static void quickSort(int[] arr,int left,int right){
        if (left>=right){
            //递归结束的条件
            return;
        }
        //key为基准数
       int key =arr[left];
        int i=left;
        int j=right;
        while (i<j){
            //因为基数是左，所以要从右边先找
            //第一个位置的值被保存了，所以可以覆盖掉，最后一步再将第一个值给填回来。
            while (i<j&&arr[j]>=key){
                //从最右向左找到第一个小于p的位置j
                j--;
            }
            while (i<j&&arr[i]<=key){
                //从最左向右找到第一个大于p的位置j
                i++;
            }
            if (i<j){
                //交换i和j
                swap(arr,i,j);
            }
        }
//当i和j相遇时，说明temp的左边数都小于等于key，右边的数都大于等于key

       //交换key和结束时的值
       swap(arr,i,left);
//temp位置已经确定，递归快速排序左右两边的数
       quickSort(arr,left,i-1);  //i-1排除中间的基数
       quickSort(arr,j+1,right);

   }
    public static void swap(int[] arr,int i,int j){
        int temp=0;
        temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }

未完待续。。。。。。。。。。。。