几种简单排序算法（Java实现）

一：选择排序

思想：在待排数组中，选出最小的一个数与第一个位置的数交换，再在余下的数中找最小的与第二个数交换。循环至倒数第二个数与最后一个数比较为止。

过程：

代码实现：

public static int[] SelectSort(int[]N) {
	int n=N.length;
	for(int i=0;i<n-1;i++) {
		for(int j=i+1;j<n;j++) {
			if(N[j]<N[i]) {
				int tmp=N[i];
				N[i]=N[j];
				N[j]=tmp;
			}
		}
	}
	return N;
}

二：冒泡排序

思想：

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。

2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

3. 针对所有的元素重复以上的步骤，除了最后一个。

4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较

代码实现：

public static int[] bubbleSort(int a[]){  
    int n=a.length;
	for(int i =0 ; i< n-1; ++i) {  
        for(int j = 0; j < n-i-1; ++j) {  
            if(a[j] > a[j+1])  
            {  
                int tmp = a[j] ; a[j] = a[j+1] ;  a[j+1] = tmp;  
            }  
        }  
    }
	return a;
}

三：插入排序

思想：每步将一个待排序的记录，按其关键码值的大小插入前面已经排序的文件中适当位置上，直到全部插入完为止。

过程：

代码实现：

public static int[] InsertSort(int[]N) {
	for(int i=1;i<N.length;i++) {
		int t=N[i];
		int k=i-1;
		while(k>=0&&N[k]>t) {
			N[k+1]=N[k];
			k--;
		}
		N[k+1]=t;
	}
	return N;
}

四：快速排序

思想：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

一趟快速排序的算法是：

1）设置两个变量i、j，排序开始的时候：i=0，j=N-1；

2）以第一个数组元素作为关键数据，赋值给key，即key=A[0]；

3）从j开始向前搜索，即由后开始向前搜索(j--)，找到第一个小于key的值A[j]，将A[j]和A[i]互换；

4）从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和A[j]互换；

5）重复第3、4步，直到i=j； (3,4步中，没找到符合条件的值，即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。找到符合条件的值，进行交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i+或j-完成的时候，此时令循环结束）。

过程：

代码实现：

public static int quickSort(int[] a, int i, int j) {
    int temp = a[i];//此时我们选择数组里的第一个数作为基准
    while (i < j)
    {
        while (i < j && a[j] >= temp)//从数组末尾开始向前遍历寻找比基准小的元素
        {
            j--;
        }
        if (i < j) 
        {
            a[i++] = a[j];//找到后将其填入所选的基准元素所在处（因为此时第一个数已经拿出来被当做基准，so无须担心元素丢失）
        }
        while (i < j && a[i] <= temp) //从数组前面开始向后遍历寻找比基准大的元素
        {
            i++;
        }
        if (i < j)
        {
            a[j--] = a[i];//找到后将其填入上面遍历到的比基准小的元素一开始所在处
        }
    }
    /*此时你会发现i=j，循环跳出*/
    a[i] = temp;//再将基准元素填入所剩下的空缺
    return i;
}

public static void sort(int[] a, int i, int j){
    /*为了防止，当下标i和j被递归遍历比基准元素大的一部分时，所返回的i（赋值给s作为下一次遍历的j）可能被减到比i小*/
    if (i > j)
    {
        return;
    }
    int s = quickSort(a, i, j);//通过返回的基准元素最后所填入的数组下标，将数组分为俩部分
    sort(a, i, s-1);//遍历比基准元素大的一部分
    sort(a, s+1, j);//遍历比基准元素小的一部分
}

名称	稳定性	平均时间复杂度	空间复杂度	描述
冒泡排序	稳定	O（n^2）	O(1)
选择排序	数组（不稳定） 链表（稳定）	O(n^2)	O(1)
插入排序	稳定	O(n^2)	O(1)
堆排序	不稳定	O(n log2 n)	O(1)
快速排序	不稳定	O(n log2 n)	O(log2 n)~O(n)