8.13Java之排序算法

8.13Java之排序算法

十种经典的排序算法

如图所示：

时间复杂度

概念：

• 对数据操作的次数(可以简单理解为：某段代码的执行次数)

  • 常数时间复杂度：O(1)

  • 对数时间复杂度：O(log n)--->对数n的结果的函数

  • 线性时间复杂度：O(n)--->n是指操作次数

空间复杂度

概念：

• 某段代码每次执行时需要开辟的内存大小

几种排序方式的理解

内部排序

• 不依赖外部的空间，直接在数据内部进行排序；

外部排序

• 数据的排序，不能通过内部空间来完成，需要依赖外部空间。

稳定排序

• 若两个元素相等：a=b，排序前a排在b前面，排序后a仍然在b后面，称为稳定排序。

不稳定排序

• 若两个元素相等：a=b，排序前a排在b前面，排序后a有可能出现在b后面，称为不稳定排序。

冒泡排序(Bubble Sort)

特点：

• 多次遍历数据

步骤：

• 相邻元素进行比较，前一个比后一个大那么交换两个元素的位置。依次遍历到最后两个元素

• 将除了最后一个元素的剩下的元素，重复执行上面的比较

• 一直重复到剩下最后两个数的比较

动图演示：

代码实现--->Java

    /*
    因为是两两比较，所以需要两个循环
    始终与内层循环的长度要比外层循环短，所以要-1
    因为每次排序完成以后将最大的数放在最后面，下次排序的时候不会用来排序，所以要剪掉外层循环的次数
     */
    public static void bubble(int[] arr){
        //如果只有没有长度或者长度为1
        if (arr.length==0){
            System.out.println("输入错误!!!");
        }else if (arr.length==1){
            System.out.println(arr[0]);
        }else {
            for (int i=0; i<arr.length; i++){
                for (int j=0; j<arr.length-1-i; j++){
                    if (arr[j]>arr[j+1]){
                        int temp = arr[j];
                        arr[j] = arr[j+1];
                        arr[j+1] = temp;
                    }
                }
            }
        }
        for (int num : arr){
            System.out.println(num);
        }
    }

代码实现--->go

package main
​
import "fmt"
​
var (
    temp int
)
​
func bubbleSort(arr []int) {
    if len(arr)==0 {
        fmt.Println("输入错误!!!")
    }else if len(arr)==1 {
        fmt.Println(arr[0])
    }else {
        for i:=0; i<len(arr); i++ {
            for j:=0; j<len(arr)-1-i; j++ {
                if arr[j]>arr[j+1] {
                    temp = arr[j]
                    arr[j] = arr[j+1]
                    arr[j+1] = temp
                }
            }
        }
    }
    for i, num := range arr{
        fmt.Println("The sorting result is:" , i, num)
    }
}
​
func main() {
    arr := []int{6,3,2,7,9}
    bubbleSort(arr)
}