七、排序方法：冒泡排序，快速排序，选择排序

1 方法分类

• 选择排序: 直接选择排序、 堆排序
• 交换排序: 冒泡排序、 快速排序
• 插入排序: 直接插入排序、 折半插入排序、 Shell排序
• 归并排序
• 桶式排序
• 基数排序

2 冒泡排序

2.1 方法

1. 比较相邻的元素。如果第一个比第二个大，就交换它们两个。（从第一个元素开始，两两比较）
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

2.2 思路

int[] arr = {4,85,24,36,7,56};  //定义数组
//以下程序并非最终结果，仅供组织思路
//1. 比较相邻的元素。如果第一个比第二个大，就交换它们两个。
	if(arr[i] < arr[i + 1]){
		int temp = arr[i];
		arr[i] = arr[i + 1];
		arr[i + 1] = temp;
	}
//2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
	//从第一个数字开始，进行第一轮排序
	for(i = 0;i < arr.length - 1;i++){   
	//因为数组定义是从0开始的，所以i的范围为i <= arr.length - 1，即i < arr.length
	//又因为for循环中如果第i个比第i+1个大，故i < arr.length - 1
		if(arr[i] < arr[i + 1]){
			int temp = arr[i];
			arr[i] = arr[i + 1];
			arr[i + 1] = temp;
		}
	}

	//输出数组arr
	for(int j : arr){
		System.out.println(j);
	}

//3. 针对所有的元素重复以上的步骤，除了最后一个。
//4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
	//因为每次排序后，数组中未排序好的都会少一位，所以要循环嵌套，每次循环的都减少一位
	for(int x = arr.length - 1;x >= 0;x--){
		for(i = 0;i < x;i++){
			if(arr[i] < arr[i + 1]){
				int temp = arr[i];
				arr[i] = arr[i + 1];
				arr[i + 1] = temp;
			}
		}
	}

组合起来：

public class maopao {
    public static void main(String[] args) {
        int[] arr = {4,85,24,36,7,56};
        for(int x = arr.length - 1;x >= 0;x--){
            for(int i = 0;i < x;i++){
                if(arr[i] > arr[i + 1] ){
                    int temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                }
            }
        }
        for(int j : arr){
            System.out.println(j);
        }
    }
}

4
7
24
36
56
85

3 快速排序

3.1 方法

（1）首先设定第一个数为基数，通过该基数将数组分成左右两部分。
（2）将大于或等于分界值的数据集中到数组右边，小于分界值的数据集中到数组的左边。此时，左边部分中各元素都小于或等于分界值，而右边部分中各元素都大于或等于分界值。
（3）然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个基数，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。
（4）重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左、右两个部分各数据排序完成后，整个数组的排序也就完成了。

3.2 示例

3.3 思路

// 1.定义数据并初始化
	int[] arr = {7,1,5,6,3,9,13,11};
// 2.快速排序的入口  该方法针对数组排序,所以需要你传递给该方法一个数组
    public static void  quick(int[] arr){
        if(arr  == null || arr.length == 0 || arr.length == 1){
        //当数组为空或长度为0或1时，无需排序，返回return
            return;
        }else{
        //当数组不符合上述时，执行sort函数
            sort(arr,0,arr.length -1);
        }
    }
//3.定义sort函数:sort函数：对指定区间所有元素进行排序
//快速排序的核心算法
public static void sort(int[] arr,int left,int right){
	if(left > right){
		return;
	}
	int base = arr[left];
	int i = left;
	int j = right;
	while(i != j){
		//从右边开始，将元素挨个与基准元素进行比较，直到找到比基准元素小的元素
		wlile(arr[j] > base && i < j){
			j--;
		}
		//从左边开始，将元素挨个与基准元素进行比较，直到找到比基准元素大的元素
		while(arr[i] < base && i < j){
			i++;
		}
		//如果i<j,将i与j对应的元素互换
		if(i < j){
			int temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
		}
	}
	//将a[i]与基本元素（base）互换
	arr[left] = arr[i];
    arr[i] = base;
	//将数组分为两部分，分别再进行上述过程
	sort(arr,0,i);
	sort(arr,i + 1;right);
}

程序整合：

public class kuaisu {
    public static void main(String[] args) {
        int[] arr = {7,1,5,6,3,9,13,11};
        quick(arr);
        for(int x : arr){
            System.out.println(x);
        }
    }
    //快速排序的入口  该方法针对 数组排序 所以需要你传递给该方法一个数组
    public static void  quick(int[] arr){
        if(arr  == null || arr.length ==0 || arr.length == 1){
            return;
        }else{
            sort(arr,0,arr.length -1);
        }
    }
    // 快速排序的核心算法
    public static void sort(int[] arr,int left,int right){
        int len  = arr.length;
        if(left > right){
            return;
        }
        int base = arr[left];
        int i = left;
        int j = right;
        while(i != j ){
            // 从左开始  依次使用左边的元素和基准元素进行比较 直到找到比基准元素大的元素
            while(arr[i] <= base && i < j){
                i++;
            }
            // 从右边开始  依次使用右边的元素和基准元素进行比较 直到找到比基准元素小的 元素
            while(arr[j] >= base && i < j){
                j--;
            }
            if(i < j ){
                int temp = arr[i];
                arr[i]= arr[j];
                arr[j] = temp;
            }
        }
        arr[left] = arr[i];
        arr[i] = base;
        sort(arr,0,i -1);
        sort(arr,i + 1 , right);
    }
}

1
3
5
6
7
9
11
13

4 选择排序

4.1 方法

• 选择排序是一种简单直观的排序算法，工作原理为：在未排序的序列中找出最小(大)元素与第一个位置的元素交换位置
• 注意选择排序与冒泡排序的区别：冒泡排序通过依次交换相邻两个顺序不合法的元素位置，从而将当前最小（大）元素放到合适的位置；而选择排序每遍历一次都记住了当前最小（大）元素的位置，最后仅需一次交换操作即可将其放到合适的位置。
  然后在剩下的元素中再找最小(大)元素与第二个元素的位置交换，依此类推，直到所有元素排序排序完成。根据上述描述，一共进行n-1趟比较后，就能完成整个排队过程。我们可以知道，第k趟比较需要进行的数组元素的两两比较的次数为n-k次，所以共需要的比较次数为n*(n-1) / 2，因此选择排序算法的时间复杂度与冒泡排序一样，也为O(n^2)。
• 算法简介：
  1.初始状态：序列为无序状态。
  2.第1次排序：从n个元素中找出最小(大)元素与第1个记录交换
  3.第2次排序：从n-1个元素中找出最小(大)元素与第2个记录交换
  4.第i次排序：从n-i+1个元素中找出最小(大)元素与第i个记录交换
  5.以此类推直到排序完成
  
  选择排序可以看作时冒泡排序的一个改进，减少了交换次数 ，而比较的趟数是一样的。

4.2实现

public class test {
    public static void main(String[] args) {
        int[] arr = {21, 35, 12, 20, 65, 5, 56};
        for (int j = 0; j < arr.length - 1; j++) {
            int min = j; // min来记录当前最小的元素所在的位置
            for (int i = j; i < arr.length; i++) {
                if (arr[i] < arr[min]) {
                    min = i;
                }
            }
            // 比较结束之后，min记录的就是当前最小的
            // 将最小的元素和当前元素进行位置进行交换
            int temp = arr[j];
            arr[j] = arr[min];
            arr[min] = temp;
        }
        // 遍历数组
        for (int x : arr) {
            System.out.println(x);
        }
    }
}

实验结果：

5
12
20
21
35
56
65