交换排序-Java版

交换排序

所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。

1：冒泡排序

它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。

交换排序-冒泡排序:

• 不针对优化：时间复杂度：$O(N^2)$

• 空间复杂度：$O(N)$

• 稳定性：稳定

  public class 冒泡排序 {
  
      public static void main(String[] args) {
          int[] array = new int[]{4, 2, 6, 7, 8, 1, 22, 11, 44, 24, 13};
          func(array);
          System.out.println(Arrays.toString(array));
      }
  
      private static void func(int [] array){
  
          //标志是否发生交换
          boolean flag=false;
          int temp;
          //到倒数第二个元素即可
          for (int i = 0; i < array.length-1; i++) {
  
              flag=false;
  
              for (int j = 0; j < array.length-1; j++) {
                      if(array[j]>array[j+1]){
                          temp=array[j];
                          array[j]=array[j+1];
                          array[j+1]=temp;
                          flag=true;
                      }
              }
              if(flag=false){
                  break;
              }
          }
      }
  }
  

2：快速排序

快速排序(Quicksort)是对冒泡排序的一种改进，使用分治思想。

交换排序-快速排序:

• 时间复杂度：
  • 最坏情况：当数据有序(正/逆)则为$O(N^2)$
  • 最好情况：每次均匀分割待排序数据 $O(N\ast lo{g}_2^n)$
• 空间复杂度：
  • 最坏情况：当数据有序则为$O(N)$
  • 最好情况：$O(lo{g}_2^n)$
• 稳定性：不稳定

方式1：递归实现_挖坑法

左边递归完毕后，在递归右边

public class 快速排序递归_挖坑法 {

    public static void main(String[] args) {
        int[] array = new int[]{4, 2, 6, 7, 8, 1, 22, 11, 44, 24, 13};
        func(array);
        System.out.println(Arrays.toString(array));
    }

    private static void func(int[] array){
        quick(array,0,array.length-1);
    }

    private static void quick(int[] array , int start ,int end){

        if(start>=end){
            return;
        }


        int mid = getMid(array,start,end);

        quick(array, start, mid-1);
        quick(array,mid+1,end);

    }
    //得到中间数下标
    private static int  getMid(int[] array , int left , int right){

        int temp=array[left];

        while (left<right){
            //如果右边大则--
            while (left<right && array[right]>=temp){//此次必须存在=，没有=如果数组两边的值相同则会陷入死循环
                right--;
            }

            //小的交换到左边
            array[left]=array[right];

            //如果左边小则++
            while (left<right && array[left]<=temp){
                left++;
            }
            //大的交换到右边
            array[right]=array[left];

        }

        array[left]=temp;

        return left;
    }
}

方式2：递归实现_Hoare法

public class 快速排序递归_Hoare法 {


    public static void main(String[] args) {
        int[] array = new int[]{4, 2, 6, 7, 8, 1, 22, 11, 44, 24, 13};
        func(array);
        System.out.println(Arrays.toString(array));
    }

    private static void func(int[] array){
        quick(array,0,array.length-1);
    }

    private static void quick(int[] array , int start ,int end){

        if(start>=end){
            return;
        }


        int mid = getMid(array,start,end);

        quick(array, start, mid-1);
        quick(array,mid+1,end);

    }
    //得到中间数下标
    private static int  getMid(int[] array , int left , int right){

        int i = left;
        int j = right;
        int pivot = array[left];
        while (i < j) {
            while (i < j && array[j] >= pivot) {
                j--;
            }
            while (i < j && array[i] <= pivot) {
                i++;
            }
            swap(array, i, j);
        }
        
        swap(array, i, left);

        return i;
    }

    private static void swap(int[] array , int i , int j ){

        int temp=array[i];

        array[i]=array[j];

        array[j]=temp;
    }
}

方式3：快速排序递归_优化_三数取中法_快速排序

如果待排数组有序，则不能均匀分割分组

三数取中：在left right 以及中间下标 三个下标对应的数字，找到数值为中间值的数的下标

当分组后剩余数据等于XXX则使用直接插入排序

package 八大排序.交换排序;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

/**
 * ClassName:三数取中
 * Package:八大排序.交换排序
 * Description:
 *
 * @date:2022/5/18 17:27
 * @author:LiaoKe
 */
public class 快速排序递归优化_三数取中 {

    public static void main(String[] args) {
        int[] array = new int[]{4, 2, 6, 7, 8, 1, 22, 11, 44, 24, 13};
        func(array);
        System.out.println(Arrays.toString(array));
    }

    //获取数组首部 尾部 以及中间元素  的中间值的下标  三数取中法
    private static int threeMid(int [] array , int left , int right){

        int mid = left + right >>> 1;

        if(array[left]>array[right]){
            if(array[mid]>array[right]){
                return mid;
            }else{
                return right;
            }
        }else {
            if(array[mid]>array[left]){
                return mid;
            }else{
                return left;
            }

        }
    }


    private static void swap(int[] array,int i , int j){
        int temp=array[i];
        array[i]=array[j];
        array[j]=temp;
    }

    //直接插入排序
    private static void sort (int [] array,int start , int end) {

        int temp;
        int j;

        for (int i = start+1; i <=end; i++) {

            temp = array[i];
            j = i - 1;

            for (; j >= start; j--) {
                if (array[j] > temp) {
                    array[j + 1] = array[j];
                } else {
                    break;
                }
            }

            array[j + 1] = temp;
        }
    }

    private static void func(int[] array){
        quick(array,0,array.length-1);
    }

    private static void quick(int[] array , int start ,int end){

        if(start>=end){
            return;
        }

        //直接插入排序 如果区间剩余数字数量小于等于100使用直接插入排序
        if(end-start+1<=100){
            sort(array, start, end);
            return;
        }


        //三数取中 start end  mid找到中间
        int index = threeMid(array, start, end);

        swap(array,index,start);

        int part = partition(array,start,end);

        quick(array, start, part-1);
        quick(array,part+1,end);

    }
    //得到中间数下标
    private static int  partition(int[] array , int left , int right){

        int temp=array[left];

        while (left<right){
            //如果右边大则--
            while (left<right && array[right]>=temp){
                right--;
            }

            //小的交换到左边
            array[left]=array[right];

            //如果左边小则++
            while (left<right && array[left]<=temp){
                left++;
            }
            //大的交换到右边
            array[right]=array[left];

        }

        array[left]=temp;

        return left;
    }

}

非递归利用栈实现：

栈中放置每一组的start和end下标。

public class 快速排序非递归 {

    public static void main(String[] args) {
        int[] array = new int[]{4, 2, 6, 7, 8, 1, 22, 11, 44, 24, 13};
        func(array);
        System.out.println(Arrays.toString(array));
    }

    private static void func(int[] array){

        Stack<Integer> stack=new Stack<>();

        int start=0;
        int end=array.length-1;
        int pivot=getMid(array,start,end);



        //第一次划分并且入栈
        //左边有两个元素及以上
        if(pivot>start+1){
            stack.push(start);//先放左边
            stack.push(pivot-1);//再放右边
        }
        //右边有两个元素及以上
        if(pivot<end-1){
            stack.push(pivot+1);
            stack.push(end);
        }

        //栈不为空
        while (!stack.isEmpty()){
            end=stack.pop();//先取右边
            start=stack.pop();//再取左边
            pivot=getMid(array,start,end);
            //左边有两个元素及以上
            //当第一次分组后继续分组入栈，直到分组只有一个元素
            if(pivot>start+1){
                stack.push(start);
                stack.push(pivot-1);
            }
            //右边有两个元素及以上
            if(pivot<end-1){
                stack.push(pivot+1);
                stack.push(end);
            }
        }

    }

    private static int getMid(int [] array , int left ,int right) {


        int temp = array[left];


        while (left<right){

            while (left<right && array[right]>=temp){
                right --;
            }

            array[left]=array[right];

            while (left<right && array[left]<=temp){
                left ++;
            }

            array[right]=array[left];

        }

        array[left]=temp;

        return left;

    }
}