(从小到大排序)
1.冒泡排序
冒泡排序类似于小鱼吐泡泡,大的泡泡往上走。每一趟排序都将当前排序范围中最大的元素放到最右侧的位置。
对 4 5 6 3 2 1 进行冒泡排序:
第一趟:4 5 3 2 1 6
第二趟:4 3 2 1 5 6
第三趟:3 2 1 4 5 6
第四趟:2 1 3 4 5 6
第五趟:1 2 3 4 5 6
相关代码如下:
import java.util.*; class test { public static void main (String[] args) throws java.lang.Exception { //实现冒泡算法 int[] array = {1,7,5,6,8,9,2,3,0}; for(int i=0;i<array.length;i++){ System.out.print(array[i]+" "); } System.out.println(); bubbleSort(array); for(int i=0;i<array.length;i++){ System.out.print(array[i]+" "); } System.out.println(); } public static void bubbleSort(int[] array){ int len = array.length; for(int i=0;i<len;i++){ boolean flag = false; for(int j=1;j<len-i;j++){ if(array[j]<array[j-1]){ int temp = array[j]; array[j] = array[j-1]; array[j-1] = temp; flag = true; } } if(flag == false) return; } } }
时间复杂度为O(n2)。
当相邻的两个元素相等的时候,是不用进行交换的,所以冒泡排序是稳定的排序算法!
2.选择排序
选择排序是从待排序的元素中选择最大/最小的,将其放在最合适的位置。
待排序序列:38,12,92,12,52,66,39,99
第一次选择排序结果:12,38,92,12,52,66,39,99
第二次选择排序结果:12,12,92,38,52,66,39,99
第三次选择排序结果:12,12,38,92,52,66,39,99
第四次选择排序结果:12,12,38,39,52,66,92,99
第五次选择排序结果:12,12,38,39,52,66,92,99
第六次选择排序结果:12,12,38,39,52,66,92,99
第七次选择排序结果:12,12,38,39,52,66,92,99
具体代码为:
import java.util.*; class test { public static void main (String[] args) throws java.lang.Exception { //实现选择排序 int[] array = {1,7,5,6,8,9,2,3,0}; for(int i=0;i<array.length;i++){ System.out.print(array[i]+" "); } System.out.println(); selectSort(array); for(int i=0;i<array.length;i++){ System.out.print(array[i]+" "); } System.out.println(); } public static void selectSort(int[] array){ int len = array.length; for(int i=0;i<len-1;i++){ int min = array[i]; int index = i; for(int j=i+1;j<len;j++){ if(array[j]<min){ min = array[j]; index = j; } } if(min!=array[i]){ int temp = array[index]; array[index] = array[i]; array[i] = temp; } } } }
时间复杂度为O(n2),由于选择之后可能会交换两个相同元素的前后位置,所以是不稳定的排序。
3.插入排序
把未排序的元素从后往前插入到已经排好序的序列中。 适用于处理数据量比较少或者序列部分有序的情况。
本文由 帅地玩编程(www.iamshuaidi.com) 辛苦整理,可以拿去当作本地笔记,但请勿抄袭发布在自家网站或者博客引流,否则必追究(原文来自:https://www.iamshuaidi.com/535.html)
import java.util.*; class test { public static void main (String[] args) throws java.lang.Exception { //实现插入排序 int[] array = {1,7,5,6,8,9,2,3,0}; for(int i=0;i<array.length;i++){ System.out.print(array[i]+" "); } System.out.println(); insertSort(array); for(int i=0;i<array.length;i++){ System.out.print(array[i]+" "); } System.out.println(); } public static void insertSort(int[] array){ int len = array.length; for(int i=1;i<len;i++){ int insert = array[i]; int j=i-1; for(;j>=0 && insert<array[j];j--){ array[j+1] = array[j]; } array[j + 1] = insert; } } }
时间复杂度为O(n2),从后往前插入的过程中,相等的话不需要移动,所以是稳定的排序算法。
4.希尔排序
希尔排序是插入排序的改进版,将元素以每k个为一组先进行分组,然后对这一组的数据实行插入排序,这样大的元素就靠后了,小的元素就靠前了。初始时k=n/2,分为两组,插入排序完成之后再将k除以2,直到k为1为止。
具体代码如下:
import java.util.*; class test { public static void main (String[] args) throws java.lang.Exception { //实现希尔排序 int[] array = {1,7,5,6,8,9,2,3,0}; for(int i=0;i<array.length;i++){ System.out.print(array[i]+" "); } System.out.println(); shellSort(array); for(int i=0;i<array.length;i++){ System.out.print(array[i]+" "); } System.out.println(); } public static void shellSort(int[] array){ int n = array.length; for(int gap=n/2;gap>0;gap/=2){ for(int i=gap;i<n;i++){ insert(array,gap,i); } } } public static void insert(int[] array,int gap,int i){ int inserted = array[i]; int j ; for(j=i-gap;j>=0&&array[j]>inserted;j-=gap){ array[j+gap] = array[j]; } array[j+gap] = inserted; } }
时间复杂度为O(n1.3),因为希尔排序是跳跃性插入,所以可能会破坏两个相同元素的前后位置,是不稳定的排序算法。
5.快速排序
先选取一个基准元素,基准元素左侧的都小于基准,基准右侧的都大于基准元素。每一趟排序都能够确定一个基准元素的位置,然后再对基准左右两侧的元素分别递归进行快排。
具体代码如下:
import java.util.*; class test { public static void main (String[] args) throws java.lang.Exception { //实现快速排序 int[] array = {1,7,5,6,8,9,2,3,0}; for(int i=0;i<array.length;i++){ System.out.print(array[i]+" "); } System.out.println(); quickSort(array,0,array.length-1); for(int i=0;i<array.length;i++){ System.out.print(array[i]+" "); } System.out.println(); } public static void quickSort(int[] array,int left,int right){ if(left>=right) return; int start = left; int end = right; int temp = array[left]; while(left<right){ while(left<right&&array[right]>=temp){ right--; } array[left] = array[right]; while(left<right&&array[left]<temp){ left++; } array[right] = array[left]; } array[left] = temp; quickSort(array,start,left-1); quickSort(array,left+1,end); } }
平均时间复杂度为O(nlogn),最坏时间复杂度是O(n2),不稳定。
6.归并排序
归并排序就是用的一个“分而治之”的思想,分----并
具体代码如下:
import java.util.*; class test { public static void main (String[] args) throws java.lang.Exception { //实现归并排序 int[] array = {1,7,5,6,8,9,2,3,0}; for(int i=0;i<array.length;i++){ System.out.print(array[i]+" "); } System.out.println(); int[] temp = new int[array.length]; mergeSort(array,temp, 0,array.length-1); for(int i=0;i<array.length;i++){ System.out.print(array[i]+" "); } System.out.println(); } public static void mergeSort(int[] array, int[] temp,int left,int right){ if(left<right){ int center = (left+right)/2; mergeSort(array,temp,left,center); mergeSort(array,temp,center+1,right); merge(array,temp,left,center,right); } } public static void merge(int[] array,int[] temp,int left,int center,int right){ int i=left,j=center+1; for(int k=left;k<=right;k++){ if(i>center) temp[k] = array[j++]; else if(j>right) temp[k] = array[i++]; else if(array[i]<array[j]) temp[k] = array[i++]; else temp[k] = array[j++]; } for(int k=left;k<=right;k++){ array[k] = temp[k]; } } }
时间复杂度为O(nlogn),是稳定的排序算法。