常用的排序算法-java

冒泡排序： 时间复杂度o(n^2)

原理是临近的数字两两进行比较,按照从小到大或者从大到小的顺序进行交换,这样一趟过去后,最大或最小的数字被交换到了最后一位,然后再从头开始进行两两比较交换,直到倒数第二位时结束

public void  sort(int [] a){  for(int i =0;i < a.length;i++ ){      for(int j =1;i< a.length-1;j++){          if(a[j]< a[j-1]){         //相邻两个元素的遍历，每次只能得到一个最小值或者最大值              swap(a[j] , a[j-1]);          }      }  } }

选择排序 o(n^2)

第1趟，在待排序记录r[1]~~r[n]中选出最小的记录，将它与r[1]交换；第2趟，在待排序记录r[2]~r[n]中选出最小的记录，将它与r[2]交换；以此类推，第i趟在待排序记录r[i]~r[n]中选出最小的记录，将它与r[i]交换，使有序序列不断增长直到全部排序完毕。

void sort(int [] a){    for(int i =0;i < a.length ; i++){        int min =i;//        for (int j =i+1; j < a.length ;j++){            if(a [j] > a[min]){             //一次遍历得到最小值的坐标。和之前的最小值交换                min =j;            }                        }        swap(a[i], a[min]);    }}

插入排序 o(n^2)

给定序列，存在一个分界线，分界线左边默认有序，右边默认无序（初始时默认第一个元素有序），每次取右边无序的第一个元素和左边有序的比较，并插入到左边合适的位置，分界线右移一位。

public void sort( int [] a){    int j =0;     for (int i =1 ;i < a.length ; i++){    //默认a[i] 之前为有序序列        if(a[i] <a[i-1]){            int  temp =a[i];           //把 a[i] 插入到a[i-1]之前有序序列的合适位置上去-->            for( j=i-1;j >0&& a[j]>temp ;j--){                a[j+1] =a[j];            }            a[j+1] =temp;        }     }}

希尔排序

定义一个增量，把序列按增量分组，对每组使用直接插入排序算法排序，然后增量递归的进行递减；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

public void sort(int [] a){    int j =0,split =a.length;    //split 为定义的增量，每次排序完成后split/2 直至split 为0时排序结束    while(split>0){        split =split/2;        for( int i =split ;i <a.length ;i++){            if(a[i] <a[i -split]){                int temp =a[i];                for( j =i-split ; j>0&& a[j]>temp ;j=j-split){                    a[j+split] =a[j];                }                a[j+split] =temp;                    }        }    }}

堆排序 o(nlog^n)

堆排序利用的数据结构是完全二叉树，对于一颗完全二叉树 ，他的任意一个节点i的左右子节点是 2*i+1 2*i+2(如果节点存在的话) 堆分为大根堆和小根堆，是完全二叉树。大根堆的要求是每个节点的值都不大于其父节点的值。
基本思路是，构建一个完全二叉树，把他变成大根堆，然后每次把根节点（即最大值）移除，用最后的节点替代，这时数组长度减一继续构建大根堆。

public void sort( int [] a){    //最后一个节点的坐标是 a[a.length/2-1],一次添加构建大根堆    for( int j =a.length/2-1 ;j>0 ;j--){//先把数组构建成大根堆        makeMax(a,j,a,length)    }    for (int i =a.length-1 ;i > 1;i--){         swap(a[i],a[0]); //把大根堆的最大元素取出，放在数组末尾        makeMax(a,0 ,i); //重新构建大根堆    }}//构建大根堆，从根节点遍历，如果左右子叶大于根节点，则交换。//publci void makeMax(int [] a ,int start,int end){    int temp=a[start]; //根节点    int j =2*start+1;  //左子叶    while(j< end){        if(j+1 < end && a[j]< a[j+1]){ //找到左右子叶中比较大的            j++;        }        if(temp > a[j]){            break;  //当前节点大于左右子叶，跳出        }        a[start] =a[j];        start =j;  //节点和子叶均指向交换后的下一个节点和子叶        j=2*j+1;     }    a[start] =temp;}

归并排序 o(nlog^n)

将数组分成二组，如果这两组，如果这两组组内的数据都是有许多，那么就可以很方便的将这二组排序。如果这二组无序，就将这二组继续分成两组排序，当组里只有一个元素时是有序的，可以和相邻的元素合并

public void sort(int [] a ){    int temp=new int[a.length];    mergesort(a,0,a.length,temp);}public void mergesort(int [] a,int start ,int end ,int []temp){    if(end >start){        int  middle =(end-start)/2;        mergesort(a,start,middle,temp);        mergesort(a,middle,end,temp);        mergearray(a,start,middle,end,temp);    }}public void metgearray(int [] a,int start,int middle,int end,int temp){    int i=j=k=l;    whle(i < start &&j< end){        if(a[j]>a[i]){            temp[k++]=a[j++];        }else{            temp[k++]=a[i++];        }    }    if(i< start ){        temp[k++]=a[i++];    }    if(j< end){        temp [k++]=a[k++];    }    for (i =0;i< k;i++){        a[start+i]=temp[i];    }}

快速排序 o(nlog^n -n^2)

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

public void sort(int []a){    mergesort(a,0,a.length);}public void mergesort(int [] a ,int start ,int end){    while(start <end){    //得到中间数，数组左边的数比他小，右边的比他大        int middle =mergearray(a,start,end);        mergesort(a,start,middle);        mergesort(a,middle,end);    }}public void mergearray(int [] a,int start ,int end){    int mid=a[start];  //默认第一个      int i=stat;j=end;    while(i<j){        while (i<j&&a(j)>mid){        //从后向前遍历，找到第一个小于mid的元素，放在i处            j--;        }        if(j>i){            a[i]=a[j];            i++;        }        while(i<j&&a(i)<mid){        //从前向后遍历，找到第一个大于mid的元素，放在j处            i++;        }         if(j>i){            a[j]=a[i];            j--;        }    }    a[i]=temp; //此时 i=j    return i;}