常用排序算法动图学习（冒泡、插入）

 

排序算法是《数据结构与算法》中最基本的算法之一。

排序算法可以分为内部排序和外部排序。

内部排序是数据记录在内存中进行排序。

而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。

常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。

用一张图概括：

关于时间复杂度：

1. 平方阶 (O(n2)) 排序 各类简单排序：直接插入、直接选择和冒泡排序。

2. 线性对数阶 (O(nlog2n)) 排序 快速排序、堆排序和归并排序；

3. O(n1+§)) 排序，§ 是介于 0 和 1 之间的常数。 希尔排序

4. 线性阶 (O(n)) 排序 基数排序，此外还有桶、箱排序。

关于稳定性：

1. 稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序。

2. 不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序。

 冒泡排序

 

public void bubbleSort(int[] score) {
//第一种：
for(int i =0;i < score.length - 1;i++)
        {
            for(int j = 0;j <  score.length - 1-i;j++)// j开始等于0，
            {
                if(score[j] < score[j+1])
                {
                    int temp = score[j];
                    score[j] = score[j+1];
                    score[j+1] = temp;
                }
            }
        }
//第二种：

   boolean exchange;
   for(int i = score.length - 1; i > 0; i--) {
       exchange = false; //此处为了减少循环次数
       for(int j = 0; j < i; j++) {
           if(a[j] > score[j+1]) {
               swap(score, j, j+1);
               exchange = true;
           }
       }
       if(!exchange) return;
   }
}

 

选择排序

 

//每一趟从待排序的记录中选出最小的元素，顺序放在已排好序的序列最后，直到全部记录排序完毕。

//选择排序
public class SelectionSort {
    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+" ");
        }
    }

}



//选择排序的时间复杂度：简单选择排序的比较次数与序列的初始排序无关。 假设待排序的序列有 N 个元
//素，则比较次数永远都是N (N - 1) / 2。而移动次数与序列的初始排序有关。当序列正序时，移动次数最
//少，为 0。当序列反序时，移动次数最多，为3N (N - 1) /  2。

//所以，综上，简单排序的时间复杂度为 O(N2)。

插入排序

//在每次迭代过程中从输入序列中取出一个元素插入到一个有序序列中，形成新的有序序列。重复该过程，直
//到序列中所有元素都被取出


static void insertionSort(int[] array){
		int n = array.length;
		int i,j,v;
		for (i = 1; i < n; i++) {
			/**
			 * v = array[i]： 表示将要插入到已经排序好的序列中的元素
			 * 例如：array[2]   将要插入到array[0],array[1]这个有序序列中
			 */
			v = array[i];
			j = i;
			while(j>=1 && array[j-1]>v){
				//为将要插入的新元素腾出空间。
				array[j] = array[j-1];
				j--;
			}
			//将新元素插入到已排序序列中。
			array[j] = v;
			/**
			 * 这是为了显示排序结果，自创建的方法，封装在SortUtil中
			 */
			SortUtil.restOfEach(array, i);
		}
		/**
		 * 这是为了显示排序结果，自创建的方法，封装在SortUtil中
		 */
		SortUtil.afterSort(array);
	}

 

   参考：https://blog.csdn.net/done_followmyheart/article/details/81413003

希尔排序

 归并排序

 快速排序

堆排序

计数排序

桶排序

 基数排序

 

 参考：https://mp.weixin.qq.com/s/9yRcEDptxfbJZnXVl_sA3Q