排序

如何分析一个“排序算法”？

排序算法的执行效率
1.1 最好情况、最坏情况、平均情况时间复杂度
1.2 时间复杂度的系数、常数、低阶
1.3 比较次数和交换（或移动）次数
排序算法的内存消耗
排序算法的稳定性

为什么要考察排序算法的稳定性呢？
答：在真正软件开发中，我们要排序的往往不是单纯的整数，而是一组对象，我们需要按照对象的某个key来排序。比如有下单时间和商品价格两个属性，对价格排序后还需要在相同价格内保证下单时间有序的话，就需要稳定排序算法了。

冒泡排序
在这里插入图片描述

冒牌排序代码
isOrderly用于在发现数组已经有序时进行提前结束排序

static void bubbleSort(int[] arr){
        int len=arr.length;
        for(int i=0;i<len;i++){
            boolean isOrderly=true;
            for(int j=0;j<len-i-1;j++){
                if(arr[j]>arr[j+1]){
                    isOrderly=false;
                    int tmp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=tmp;
                }
            }
            if(isOrderly){ break; }
        }
    }

算法分析：
1、空间复杂度：只有交换操作和几个临时变量即O(1)
2、稳定性：代码中相邻两数相等时不会进行交换，维护了稳定性
3、时间复杂度：
最好情况O(n) （至少也要一次遍历）
最坏情况O(n^2) （纯粹的倒序）

插入排序

在这里插入图片描述

思想：将数组中的数据分为两个区间，已排序区间和未排序区间，取未排序区间中的元素，在已排序区间中找到合适的插入位置将其插入，并保证已排序区间数据一直有序。重复这个过程，直到未排序区间中元素为空，算法结束。

static void insertionSort(int[] arr){
        int len=arr.length;
        for(int i=1;i<len;i++){
            int temp=arr[i];
            int j=i-1;
            for(;j>=0;j--){
                if(arr[j]<=temp){
                    break;
                }
                arr[j+1]=arr[j];
            }
            //注意这里必须写在外面，不能写在break前一句
            arr[j+1]=temp;
        }
    }

算法分析：
1、空间复杂度：O(1)
2、稳定性：对于值相同的元素，我们可以选择将后面出现的元素，插入到前面出现元素的后面，这样就可以保持原有的前后顺序不变，所以插入排序是稳定的排序算法。
3、时间复杂度：最好O(n)，最坏和平均O(n^2)

选择排序

也是把数组分为有序和无序的两部分，但是每次是从无序中选取最值，放在有序部分的尾部，但是因为这个“放在”其实是交换操作，使得选择排序不具有稳定性
在这里插入图片描述

static void selectionSort(int[] arr){
  	int len=arr.length;
    for(int i=0;i<len-1;i++){
        int min=Integer.MAX_VALUE;
        int tag=i;
        //得到无序部分最小值
        for(int j=i;j<len;j++){
            if(min>arr[j]){
                min=arr[j];
                tag=j;
            }
        }
        if(tag!=i){
            int temp=arr[tag];
            arr[tag]=arr[i];
            arr[i]=temp;
        }
    }
}

算法分析：
1、空间复杂度：O(1)
2、稳定性：不稳定
3、时间复杂度：最好O(n)，最坏和平均O(n^2)

这里作者还说了一下

然后翻出来我以前写的希尔排序（算是插入排序的优化吧）
空间复杂度O(1)，平均时间复杂度O(nlogn)
下面是我从别人博客那复制过来的演示动图
在这里插入图片描述

void ShellSort(int N,int *a)
{
	int gap,temp;
	int i,j;
	for(gap=N/2;gap>0;gap/=2)
	{
		for(i=gap+1;i<=N;i++)
		{
			temp=a[i];
			for(j=i-gap;j>=0&&a[j]>temp;j-=gap)
			{
				a[j+gap]=a[j];
			}
			a[j+gap]=temp;
		}
	}
}