一、冒泡排序
1、比较相邻的元素。如果第一个比第二个大,就交换他们两个。
2、 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数。
3、针对所有的元素重复以上的步骤,除了最后一个。
4、持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。
public static void bubblesort(int[] array){
for(int j=0;j<array.length-1;j++){
for(int i = 0;i<array.length-1;i++){
if(array[i+1]<array[i]){
int tmp=array[i];
array[i]=array[i+1];
array[i+1]=tmp;
}
}
}
}
二、选择排序
选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。以此类推,直到所有元素均排序完毕。
public static void selection_sort(int[] unsort) {
for (int i = 0; i < unsort.length - 1; i++) {
int min = unsort[i];
int min_index = i;
for (int j = i + 1; j < unsort.length; j++) {
if (unsort[j] < min) {
min = unsort[j];
min_index = j;
}
}
if (min_index != i) {
int tmp = unsort[i];
unsort[i] = unsort[min_index];
unsort[min_index] = tmp;
}
}
}
三、插入排序
1、从第一个元素开始,该元素可以认为已经被排序
2、取出下一个元素,在已经排序的元素序列中从后向前扫描
3、如果该元素(已排序)大于新元素,将该元素移到下一位置
4、重复步骤3,直到找到已排序的元素小于或者等于新元素的位置
5、将新元素插入到该位置后
6、重复步骤2~5
public static void insertionsort(int[] array){
for(int i=1;i<array.length;i++){
int j=i-1;
int currentNumber=array[i];
while(j>=0&&array[j]>array[i]){
array[j+1]=array[j];
j--;
}
array[j + 1] = currentNumber;
}
}
四、快速排序
1、从数列中挑出一个元素,称为”基准”(pivot),
2、重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分区结束之后,该基准就处于数列的中间位置。这个称为分区(partition)操作。
3、递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子数列排序。
public static int partition(int[] array, int low, int high) {
if (low < high) {
return -1;
}
int tmp = array[low];// 枢轴记录
while (low < high) {
while (low < high && array[high] >= tmp) {
high--;
}
array[low] = array[high];// 交换比枢轴小的记录到左端
while (low < high && array[low] <= tmp) {
low++;
}
array[high] = array[low];// 交换比枢轴小的记录到右端
}
// 扫描完成,枢轴到位
array[low] = tmp;
// 返回的是枢轴的位置
return low;
}
public static void quicksort(int[] array, int low, int high) {
if (low < high) {
int dp = partition(array, low, high);// 将数组分为两部分
quicksort(array, low, dp - 1);// 递归排序左子数组
quicksort(array, dp + 1, high);// 递归排序右子数组
}
}
五、归并排序
1、将序列每相邻两个数字进行归并操作,形成 floor(n/2)个序列,排序后每个序列包含两个元素
2、将上述序列再次归并,形成 floor(n/4)个序列,每个序列包含四个元素
3、重复步骤2,直到所有元素排序完毕
归并排序其实就做两件事:
1、“分解”——将序列每次折半划分。
2、“合并”——将划分后的序列段两两合并后排序。
核心思想就是将两个已经各自排好顺序的数组合并成一个。这样我们递归的将一个大的数组,不断分成2段,直到每个数组只有一个元素。同时也不断合并已经排好顺序的数组,直到全都合并完成。过程如下图;
public class merge_sort {
public static void main(String[] args){
int arr[] = new int[]{10,9,12,4,11,7,8,3};
Sort(arr);
System.out.println(Arrays.toString(arr)); //将整型数组转换为String,打印出来
}
public static void Sort(int arr[]){
int tmpArray[] = new int[arr.length]; //创建一个临时的数组来存放临时排序的数组
mergeSort(arr,tmpArray, 0 ,arr.length-1); //开始对数组归并排序
}
//用递归的方法,对数组进行归并排序
private static void mergeSort(int arr[],int tmpArray[],int first ,int last){
if(first<last){ // 确定数组不是空的
int mid =(first+last)/2; //将数组分成两段
//下面是用递归的方法,不断分割数组。即1分2,2分4,以此类推。直到每个数组都只剩下2个元素。
mergeSort(arr,tmpArray,first,mid);
mergeSort(arr,tmpArray,mid+1,last);
// 下面是利用临时数组tmpArray[] 对分割后的数组排序和归并
merge(arr,tmpArray,first,mid,last);
System.out.println(Arrays.toString(arr));
}
}
// 合并两个有序子序列 a[first, ..., mid] 和 a[mid+1, ..., last]。tmpArray是辅助数组
private static void merge(int a[],int tmpArray[],int first,int mid,int last){
int beginHalf1 = first; // 第一段数组的起始元素下标
int endHalf1 = mid; // 第一段数组的末尾元素下表
int beginHalf2 = mid+1; // 第二段数组的起始元素下标
int endHalf2 = last; // 第二段数组的末尾元素下标
int index = beginHalf1; // 临时数组的索引
int num = last - first+1; // 将临时数组tmpArray中已经排好顺序的元素拷贝到数组arr[]需要的次数, (其中没有排好顺序的元素自然就不用复制过去,所以arr那些没有排序的元素还是原样。
while((beginHalf1 <= endHalf1) && (beginHalf2 <= endHalf2)){ // 确认分割后的两段数组是否都取到了最后一个元素
if(a[beginHalf1] <= a[beginHalf2]){ // 分别到两段数组中抽取两个元素的值进行比较
//哪那个元素值小,就复制到临时数组tmpArray对应的位置中,然后index++,同时将那段数组再去下一个元素
tmpArray[index++] = a[beginHalf1++];
}
else{
tmpArray[index++] = a[beginHalf2++];
}
}
//经过上面的while循环,必定有段数组的元素都取光了,即肯定还有一段数组是没有取光的,不但没取光,而且剩下的元素还已经排完序了。所以下面两个while只有一个会执行,就是将剩下的那段数组的已经排好顺序的元素都拷贝到临时数组tmpArray[]中对应的位置。
while(beginHalf1 <= endHalf1){
tmpArray[index++] = a[beginHalf1++];
}
while(beginHalf2 <= endHalf2){
tmpArray[index++] = a[beginHalf2++];
}
// 将临时数组tmpArray[]中的已经排好顺序的元素全都拷贝到原来的数组arr[]中
for(int i = 0 ; i < num ;i++,endHalf2--){
a[endHalf2] = tmpArray[endHalf2];
}
}
}
各种排序算法的时间复杂度和空间复杂度比较: