常见的排序算法_上篇

最新推荐文章于 2024-08-19 15:21:18 发布

枕上~诗书闲

最新推荐文章于 2024-08-19 15:21:18 发布

阅读量191

点赞数 1

分类专栏：数据结构算法篇文章标签：数据结构算法

本文链接：https://blog.csdn.net/qq_43705670/article/details/104810667

版权

数据结构同时被 2 个专栏收录

24 篇文章 0 订阅

订阅专栏

算法篇

22 篇文章 0 订阅

订阅专栏

排序算法分类

常见排序算法可以分为两大类：比较类排序和非比较类排序；

比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。
非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。

常见的排序算法图

时间、空间复杂程度速查表

时间空间复杂程度比较表图

时间、空间复杂程度图

比较公式： O(logN) < O(N) ∈ N(logN) < O(N²)

时间复杂程度图

具体实现操作

冒泡排序

冒泡排序（Bubble Sort）是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

实现原理

比较相邻的元素的大小，如果前面一个比后面一个大，就交换，直到不用比较。（反之）
动画演示

冒泡排序动态图

代码实现


import java.util.Arrays;

public class BubbleSort {
	static int[] array = {3,2,4,1,5,0};
    public static void maopaoSort(int[] a) 
    {
        for(int i=0;i<a.length-1;i++)  //外层循环，是需要进行比较的轮数，一共进行5次即可
        {
            for(int j=0;j<a.length-1;j++) //内存循环，是每一轮中进行的两两比较
            {
                if(a[j] > a[j+1]) 
                {
                    int temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp; 
                }
            }
            System.out.println("第"+(i+1)+"轮排序后的数组为: "+Arrays.toString(a));
        }
    }
    public static void main(String[] args) {
        maopaoSort(array);
    }
}

我们最常见的就是双重循环就搞定了，那我们来看看另外一道题。

// 1
// 12
// 123
// 1234
// 12345
那这个能不能用一个循环就搞定呢？

		
	public static void main(String[] args) {
		int n = 5;
		for (int i = 1, j =1; ;j++) {
			if(j > i) {
				i++;
				j = 1;
				System.out.println("");
			}
			if(i > n) {
				break;
			}
			System.out.print(j+" ");
		}
		
	}

那如果只是叫我们输出
1
12
123
1234
12345
就还有一种写法


	public static void main(String[] args) {
		StringBuilder sb = new StringBuilder();
		int k = 5;
		for(int i=1;i<=k;i++){
		    sb.append(i);
		    System.out.println(sb.toString());
		}
	}

这样也能输出同样的结果，而且次数循环的次数更加少。

快速排序

快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

实现原理
1. 从数列中挑出一个元素，称为 “基准”（pivot）；
2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
动图演示

快速排序动态图

代码实现

	// 快速排序
	public static void main(String[] args) {
		int[] array = {45,13,63,67,92,87,34,73};
		printArray(array);
		quickSort(array,0,array.length-1);
		printArray(array);
	}
	
	public static int getPivotIndex(int[] array,int start,int end){
		// 随机生成基准数下标
		int pivotIndex = (int)(Math.random()*(end-start+1)+start);
		int pivotNum = array[pivotIndex];		
		swap(array,pivotIndex,end);
		int move = 0;
		for(int i=start;i<end-move;i++){
			if(array[i]>array[end-move]){
				array[end-move] = array[i];
				array[i] = array[end-move-1];
				array[end-move-1] = pivotNum;
				move++;
				i--;
			}
		}
		pivotIndex = end-move;
		array[pivotIndex]=pivotNum;
//		System.out.println("\npivotNum = "+pivotNum);
//		for (int i = 0; i <array.length; i++) {
//			if(i<start || i>end){
//				System.out.print("_ ");
//			}else{
//				System.out.print(array[i]+" ");
//			}
//		}
//		System.out.println("\n------------------");
		return pivotIndex;
	}	

	public static void quickSort(int[] array,int start,int end){
		int pivotIndex = getPivotIndex(array, start, end);
		if(pivotIndex>start){
			quickSort(array, start, pivotIndex-1);
		}
		if(pivotIndex<end){
			quickSort(array, pivotIndex+1,end);
		}
	}
	// swap the value of index i and j in the array
	public static void swap(int[] array,int i,int j){
		int temp = array[i];
		array[i]= array[j];
		array[j] = temp;
	}
	// print the array
	public static void printArray(int[] array){
		for(int i : array){
			System.out.print(i+" ");
		}
		System.out.println("");
	}

拆入排序

插入排序就是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。就好像我们打扑克牌一样，摸一张牌，按照手中牌的大小顺序，插入到制定位置。

扑克牌图

实现原理
1. 将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。
2. 从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。
动图演示

拆入排序动图

代码实现


	public static void main(String[] args) {
		int[] array = {45,13,63,67,92,87,34,73};
		int[] insertionSort = insertionSort(array);
		System.out.println(insertionSort);
		printArray(array);
	}
	
    public static int[] insertionSort(int[] array) {
        if (array.length == 0) {
            return array;
        }
        int current;
        for (int i = 0; i < array.length - 1; i++) {
            current = array[i + 1];
            int preIndex = i;
            while (preIndex >= 0 && current < array[preIndex]) {
                array[preIndex + 1] = array[preIndex];
                preIndex--;
            }
            array[preIndex + 1] = current;
        }
        return array;
    }
    
    // print the array
 	public static void printArray(int[] array){
 		for(int i : array){
 			System.out.print(i+" ");
 		}
 		System.out.println("");
 	}

选择排序
选择排序是一种简单直观的排序算法，他的时间复杂程度都是O(n²)
好处：不用利用额外的内存空间
坏处：仅限于数据少的情况，数据多会浪费很多时间

实现原理
先全部找一遍，找出最小值，拿这个最小值放到最前面，再拿第二个数去跟后面的比较，如果有比这个数还小的数就放在开始比较的位置
动图演示

选择排序动态图

代码实现

 public static void main(String[] args) {
        int[] arr={1,3,2,45,65,33,12};
        System.out.println("交换之前：");
        for(int num:arr){
            System.out.print(num+" ");
        }        
        //选择排序的优化
        for(int i = 0; i < arr.length - 1; i++) {// 做第i趟排序
            int k = i;
            for(int j = k + 1; j < arr.length; j++){// 选最小的记录
                if(arr[j] < arr[k]){ 
                    k = j; //记下目前找到的最小值所在的位置
                }
            }
            //在内层循环结束，也就是找到本轮循环的最小的数以后，再进行交换
            if(i != k){  //交换a[i]和a[k]
                int temp = arr[i];
                arr[i] = arr[k];
                arr[k] = temp;
            }    
        }
        System.out.println();
        System.out.println("交换后：");
        for(int num:arr){
            System.out.print(num+" ");
        }
    }