【数据结构】交换排序

⭐ 作者：小胡_不糊涂

🌱 作者主页：小胡_不糊涂的个人主页

📀 收录专栏：浅谈数据结构

💖 持续更文，关注博主少走弯路，谢谢大家支持 💖

冒泡、快速排序

[1. 冒泡排序](#1. 冒泡排序)
[2. 快速排序](#2. 快速排序)

1. 冒泡排序

交换排序基本思想：所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置。

代码实现：

java 复制代码

    /*
    *冒泡排序
    *1.时间复杂度：O(N^2)
    *2.空间复杂度：O(1)
    *3.稳定性：稳定
    * @param array
     */
    public static void bubbleSort(int[] array){
    //i:记录躺数
    //j<array.length-i-1: -1 为了防止越界
        for(int i=0;i<array.length;i++){
            for(int j=0;j<array.length-i-1;j++){
                if(array[j+1]<array[j]){
                    int tmp=array[j+1];
                    array[j+1]=array[j];
                    array[j]=tmp;
                }
            }
        }
    }

2. 快速排序

快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其**基本思想为：**任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

代码实现：

java 复制代码

/**
     * 快速排序-》
     * 时间复杂度：
     *       最好的情况下：O(N*logN)
     *       最坏情况下：O(N^2) 逆序/有序
     * 空间复杂度：
     *       最好的情况下：O(logN)
     *       最坏情况下：O(N) 逆序/有序
     * 稳定性：不稳定
     * @param array
     */
// 假设按照升序对array数组中[left, right)区间中的元素进行排序
void QuickSort(int[] array, int left, int right)
{
	if(right - left <= 1)
	return;
	// 按照基准值对array数组的 [left, right)区间中的元素进行划分
	int div = partion(array, left, right);
	// 划分成功后以div为边界形成了左右两部分 [left, div) 和 [div+1, right)
	// 递归排[left, div)
	QuickSort(array, left, div);
	// 递归排[div+1, right)
	QuickSort(array, div+1, right);
}
private static void swap(int[] array,int i,int j) {
    int tmp = array[i];
    array[i] = array[j];
    array[j] = tmp;
}

上述为快速排序递归实现的主框架，发现与二叉树前序遍历规则非常像，在写递归框架时可想想二叉树前序遍历规则即可快速写出来，后序只需分析如何按照基准值来对区间中数据进行划分的方式即可。

将区间按照基准值划分为左右两半部分的常见方式有：
1. Hosre版

java 复制代码

/**
     * @param array
     * @param left
     * @param right
     * @return
     */
    public static int partion(int[] array,int left,int right){
        int i=left;
        int privot=array[left];//基准元素
        while(left<right){
        //大于privot的放在右边，小于的放在左边
            while(left<right&&array[right]>=privot){
                right--;
            }
            while(left<right && array[left]<=privot){
                left++;
            }
            swap(array,right,left);//right<privot<left
        }
        swap(array,i,left);//将基准元素放回
        return left;
    }

2. 挖坑法

先将一个数据存放在临时变量key中，形成一个空缺位。一般选取第一个元素。

java 复制代码

/**
     * 挖坑法
     * @param array
     * @param left
     * @param right
     * @return
     */
    public static int partion(int[] array,int left,int right){
        int privot=array[left];
        while(left<right){
            //从右边开始
            while(left<right&&array[right]>=privot){
                right--;
            }
            array[left]=array[right];
            while(left<right&&array[left]<=privot){
                left++;
            }
            array[right]=array[left];
        }
        array[left]=privot;//将基准元素填入空位
        return left;
    }

3. 前后指针法

初始时，设置两个指针。prev指向序列开头，cur指针指向prev的后一个位置

java 复制代码

/**
     * 前后指针法：
     * @param array
     * @param left
     * @param right
     * @return
     */
    public static int partion(int[] array,int left,int right){
        int prev=left;
        int cur=left+1;
        while(cur<=right){
            while(array[cur]<array[left] &&array[cur]!=array[++prev]){
                swap(array,prev,cur);
            }
            cur++;
        }
        swap(array,prev,left);
        return prev;
    }

以上3种方式，每次划分之后的前后顺序有可能是不一样的