【图解算法】-CH2排序算法

目录

冒泡排序

选择排序

插入排序

快速排序

---

---

冒泡排序

解题思路

1. 循环比较相邻元素，若前方元素大于后方，将前方元素与后方元素交换，每一次循环比较后，最大元素往后冒泡。
2. 第n次循环比较从0位置比较到第最大数组长度-(n-1)个元素，重复1步骤比较交换。
3. 当循环n-1次，或者一次比较后未交换元素。退出循环，排序结束。

图解示例

代码实现

    public void bubbleSort(int[] arr) {
                int temp;
                for (int i = 1; i < arr.length; i++) {
                        boolean change = false;
                        for (int j = 0; j < arr.length - i; j++) {
                                if(arr[j] > arr[j+1]){
                                        change = true;
                                        temp = arr[j];
                                        arr[j] = arr[j+1];
                                        arr[j+1] = temp;
                                }
                        }
                        if(!change){
                                break;
                        }
                        System.out.print(String.format("第 %s 次排序结果",i));
                        for(int k = 0;k<arr.length;k++){
                                System.out.print(" "+arr[k]);
                        }
                        System.out.print("\n");
                }
        }

性能评估

时间复杂度

O(N^2)

---

选择排序

解题思路

1. 初始化第一个数为最小数，循环比较后续元素与最小数，以此循环比较结束后，交换最小数，即第一位为整个数组中最小数。
2. 第n次循环比较从n-1位置开始，并设置n-1位置数为最小数，重复1步骤比较交换，每次循环比较结束后，第n-1位置为最小数。
3. 当循环n-1次后。退出循环，排序结束。

图解示例

代码实现

public void selectSort(int [] arr){
                int index;
                int temp;
                for(int i=0;i<arr.length-1;i++){
                        index = i;
                        for(int j=i+1;j< arr.length;j++){
                                if(arr[j] < arr[index]){
                                        index = j;
                                }
                        }
                        if(index != i){
                                temp = arr[i];
                                arr[i] = arr[index];
                                arr[index] = temp;
                        }
                        System.out.print(String.format("第 %s 次排序结果",i));
                        for(int k = 0;k<arr.length;k++){
                                System.out.print(" "+arr[k]);
                        }
                        System.out.print("\n");
                }
        }

性能评估

时间复杂度

O(N^2)

---

插入排序

解题思路

1. 初始化第一个元素为排好序部分
2. 获取未排序部分第一个元素，将其插入已排序部分合适的位置，保证已排序部分排好序
3. 重复步骤2，直至所有元素都插入已排序部分。排序结束

图解示例

代码实现

public void insertionSort(int[] arr) {
                int temp;
                for (int i = 1; i < arr.length; i++) {
                        temp = arr[i];
                        int j = i - 1;
                        while (j >= 0 && temp < arr[j]) {
                                arr[j + 1] = arr[j];
                                j--;
                        }
                        arr[j + 1] = temp;

                        System.out.print(String.format("第 %s 次排序结果", i));
                        for (int k = 0; k < arr.length; k++) {
                                System.out.print(" " + arr[k]);
                        }
                        System.out.print("\n");
                }
        }

性能评估

时间复杂度

O(N^2)

---

快速排序

解题思路

1. 选择基础点，定义两个游标从左右向中间靠拢，每次位移与基础base值比较，交换左右值。将小于base值放在左边，大于base值放在右边。
2. 将小于base值部分重复步骤1，将大于base值部分重复步骤1。
3. 直至递归到最小部分都排序完毕。

图解示例

代码实现

public void quickSort(int[] arr, int left, int right) {
		int base, temp;
		int ltemp, rtemp;
		ltemp = left;
		rtemp = right;
		base = arr[(left + right) / 2];
		while (ltemp < rtemp) {
			while (arr[ltemp] < base) {
				++ltemp;
			}
			while (arr[rtemp] > base) {
				--rtemp;
			}
			if (ltemp <= rtemp) {
				temp = arr[ltemp];
				arr[ltemp] = arr[rtemp];
				arr[rtemp] = temp;
				++ltemp;
				--rtemp;
			}
		}
		if (ltemp == rtemp) {
			if(arr[ltemp] <base){
				ltemp++;
			}
			if(arr[rtemp] > base){
				rtemp--;
			}
		}
		if (left < rtemp) {
			quickSort(arr, left, rtemp);
		}
		if (ltemp < right) {
			quickSort(arr, ltemp, right);
		}
	}

性能评估

时间复杂度

O(nlogn)

---