Java实现数据结构基本算法——排序——交换排序（Exchange Sort）

---

一、交换排序的定义及分类

交换排序的基本思想：交换排序主要根据序列中两个元素关键字的比较结果来交换这两个记录在序列中的位置
分类：冒泡排序、插入排序。

---

二、交换排序——冒泡排序

1. 基本思想：

冒泡排序算法是一种较简单的交换排序法，其具体思想为：
（1）将待排序的记录划分为有序区和无序区，初始有序区为空，无序区包括所有待排序的记录；
（2）对无序区从前向后依次将相邻记录的关键码进行比较，若反序则交换，从而使得关键码小的记录向前移动，关键码大的记录向后移动，这样无序区中关键码最大的记录就会移动到该无序区的最后一个位置，之后将该位置元素划到有序区中；
（3）重复执行（2），直到无序区中没有反序的记录。

---

2. 排序过程：

元素下标	0	1	2	3	4	5	6
初始序列	49	38	65	97	76	13	27
第1躺排序之后	38	49	65	76	13	27	【97】
第2躺排序之后	38	49	65	13	27	【76	97】
第3躺排序之后	38	49	13	27	【65	76	97】
第4躺排序之后	38	13	27	【49	65	76	97】
第5躺排序之后	13	27	【38	49	65	76	97】
第6躺排序之后	13	【27	38	49	65	76	97

---

3. 代码实现：

public class Bubbling_Sort {            //冒泡排序
    public static void main(String[] args){
        int[] arr = {49,38,65,97,76,13,27};
        int flag = 0 ;              //flag = 0 表示该序列为无序序列
        int i , j;
        System.out.println("初始序列："+ Arrays.toString(arr));
        for ( i = arr.length ; i >= 1 && flag == 0; i --){      //有元素交换时在进行下一趟，最多 n - 1 躺
            flag = 1;               //flag = 1 表示该序列为有序序列
            for ( j = 0 ; j < i - 1 ; j++){         //一次比较、交换
                int temp = 0;
                if(arr[j] > arr[j+1]) {             //反序时元素进行交换
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    flag = 0;               // 该序列暂时无序
                }
            }
            System.out.printf("第%d躺排序结果：",arr.length - i + 1);
            System.out.println(Arrays.toString(arr));
        }
        System.out.println("排序后结果："+ Arrays.toString(arr));
    }
}

---

4. 运行结果：

初始序列：[49, 38, 65, 97, 76, 13, 27]
第1躺排序结果：[38, 49, 65, 76, 13, 27, 97]
第2躺排序结果：[38, 49, 65, 13, 27, 76, 97]
第3躺排序结果：[38, 49, 13, 27, 65, 76, 97]
第4躺排序结果：[38, 13, 27, 49, 65, 76, 97]
第5躺排序结果：[13, 27, 38, 49, 65, 76, 97]
第6躺排序结果：[13, 27, 38, 49, 65, 76, 97]
排序后结果：[13, 27, 38, 49, 65, 76, 97]

---

三、交换排序——快速排序

1. 基本思想：

快速排序是通过比较关键码、交换记录，以某个记录为界（该记录称为支点，可以随机选取，但一般选取第一个记录），将待排序列分成两部分。其中一部分所有记录的关键码大于等于支点记录的关键码，另一部分所有记录的关键码小于支点记录的关键码。将待排序列按关键码以支点记录分成两部分的过程称为“划分”，对各部分不断划分，直到整个序列按关键码有序。
若 1 <= p < q <= n；设a[p]，a[p+1]，… ，a[q]为待排序列。则对待排序列进行一次划分的过程如下：
（1）初始化：取第一个记录作为基准，设置两个搜索变量low，high（类似于C语言中的指针）分别用来表示将要与基准记录进行比较的左侧记录位置（初始时为p）和右侧记录位置（初始时为q），也就是本次划分的区间。
（2）右侧扫描过程：将基准记录与high指向的记录进行比较，如果high指向记录的关键码大，则high前移一个位置（即high–），继续在右侧向前扫描，直到high所指记录关键码小于基准元素。若low < high，则将基准记录与high指向的记录进行交换。
（3）左侧扫描过程：将基准记录与low指向的记录进行比较，如果low指向记录的关键码小，则low后移一个位置（即low++），继续在左侧向后扫描，直到low所指记录关键码大于基准元素。若low < high，则将基准记录与low指向的记录进行交换。
（4）重复过程（2）和（3），直到low与high指向同一个位置，即基准记录最终的位置。

---

2. 排序过程：

---

3. 代码实现：

public class Quick_Sort {
    public static void main(String[] args){
        int[] arr = {38,26,97,19,66,1,5,49};
        System.out.println("初始序列："+ Arrays.toString(arr));
        quickSort(arr , 0 ,arr.length - 1);
        System.out.println("排序后结果："+ Arrays.toString(arr));
    }
    public static void quickSort(int[] arr, int low ,int high){
        if (low < high){        //序列有效
            int i = low , j = high;
            int vot = arr[i];           //第一个值作为基准值
            while (i != j){             //一趟排序
                while (i < j && vot <= arr[j])      //从后向前寻找较小值
                    j--;
                if (i < j ){
                    arr[i] = arr[j];                //较小元素向前移动
                    i++;
                }
                while (i < j && arr[i] < vot)       //从前向后寻找较大值
                    i++;
                if (i < j){
                    arr[j] = arr[i];
                    j--;
                }
                arr[i] = vot;                       //基准值最后位置
                System.out.print("low="+low+"\thigh="+high+"\t基准值="+vot+" ");
                System.out.println(Arrays.toString(arr));
                quickSort(arr , low , j - 1);           //前端子序列再排序
                quickSort(arr , i + 1 , high);           //后端序列再排序
            }
        }
    }
}

---

4. 运行结果：

初始序列：[38, 26, 97, 19, 66, 1, 5, 49]
排序后结果：[1, 5, 19, 38, 38, 49, 66, 97]

---

五、算法分析

一般应从以下几方面综合考虑：1. 时间复杂度；2. 空间复杂度；3. 稳定性；4. 算法简单性； 5. 待排序记录个数；6. 记录本身信息量大小；7. 关键码分布情况。

排序方法	平均时间	最坏情况	辅助空间	稳定性	不稳定举例
冒泡排序	O(n2)	O(n2)	O(1)	稳定
快速排序	O(nlog2n)	O(n2)	O(log2n)	不稳定	60，60’，50（60为支点）

---