交换排序

交换排序

冒泡排序

• 思路：(两两相邻比较)，每一次循环确定一个最大/最小值
• 特性：
  • 时间复杂度：O(n2)
  • 空间复杂度：O(1)
  • 稳定性：稳定
• .java

public class SortExcahngeBubble {
    public static void main(String[] args) {
        int arr[]={5,12,8,9,6,30,22,-1};
        bubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    private static void bubbleSort(int[] arr) {
      //外层循环确定扫描的趟数(arr.length-1次)
        for (int i = 0; i < arr.length-1; i++) {
        //内层循环确定每一趟扫描需要比较的次数(需要比较的元素个数比上一趟少一个)
         //增加判断位
            boolean flag=true;
            for (int j=0; j<arr.length-1-i;j++) {
                if(arr[j]>arr[j+1]){
                 //中间变量,用于两个元素交换位置
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                    flag=false;
                }
            }
             //如果上面没有执行直接退出
            if(flag){
                break;
            }
        }
    }
}

快速排序

• 思路：分治法：比大小，再分区

• 步骤：1、从数组取出一个数作为基准数
  2、将大于等于这个数的数全部放到它的右边，小于这个数的数全部放到它的左边
  3、再对左右区间重复第二步，直到各区间的数只有一个

• 特性：

  • 时间复杂度：O(n2)
  • 空间复杂度：O(1)
  • 稳定性：稳定

• 图解
  
  
  
  

  
  
  
  

• .java

public class SortExcahngeQuick {
        public static void main(String[] args) {
            int arr[]={6,1,2,7,9,3,4,5,10,8};
            int start=0,end=arr.length-1;
            quickSort(arr,start,end);
            System.out.println(Arrays.toString(arr));
        }
        private static void quickSort(int[] arr, int start, int end) {
            int i,j,indexValue;
            if(start>end)
                return;
            i=start;j=end;
            //indexValue就是基准位
            indexValue=arr[start];
            while(i<j){
                //先看右边，依次往左递减
                while(arr[j]>=indexValue&&i<j){
                    j--;
                }
                //再看左边，依次往右递增
                while(arr[i]<=indexValue&&i<j){
                    i++;
                }
                //如果满足条件则交换
                if(i<j){
                    int temp=arr[i];
                    arr[i]=arr[j];
                    arr[j]=temp;
                }
            }
            //此时，i和j肯定是相等的，因为上面循环的条件是i&lt;j，所以，跳出循环时，i和j是相等的
            //最后将基准为与i和j相等位置的数字交换
            arr[start]=arr[i];
            arr[i]=indexValue;
            //递归调用左半数组
            quickSort(arr,start,j-1);
            //递归调用右半数组
            quickSort(arr,j+1,end);
        }
    
    }