java 排序算法小结

1）冒泡排序

原理：
比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

 

冒泡排序是一种稳定排序算法，即相等的元素的顺序不会改变。

java代码实现

public void bubbleSort(int []arr) {
 
        for(int i =1;i<arr.length;i++) { 
            for(int j=0;j<arr.length-i;j++) {
                if(arr[j]>arr[j+1]) {
                    int temp = arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
              }
            }    
        }
    }

2）选择排序

原理：
第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，
然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。
以此类推，直到全部待排序的数据元素的个数为零。

选择排序是不稳定的排序方法：如果一个元素比当前元素小，而该小的元素又出现在一个和当前元素相等的元素后面，那么交换后稳定性就被破坏了。如序列5 8 5 2 9，我们知道第一遍选择第1个元素5会和2交换，那么原序列中两个5的相对前后顺序就被破坏了。

java代码实现

public void selectionSort(int[] arr){
        
       for (int i = 0; i < arr.length - 1; i++) {    
            int  min = i;
            for (int j = i + 1; j < arr.length; j++) {
                  if (arr[min] > arr[j]) {
                       min = j;
                  }
            }
            if (min != i) {
               int tmp = arr[min];
               arr[min] = arr[i];
               arr[i] = tmp;
            }             
      }
 }

3）归并排序

是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；
即先使每个子序列有序，再使子序列段间有序。
若将两个有序表合并成一个有序表，称为二路归并。
原理：

第一步：申请空间，使其大小为两个已经 排序序列之和，该空间用来存放合并后的序列

第二步：设定两个 指针，最初位置分别为两个已经排序序列的起始位置

第三步：比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置重复步骤3直到某一指针超出序列尾将另一序列剩下的所有元素直接复制到合并序列尾

归并 排序是稳定的排序，即相等的元素的顺序不会改变。

 java代码实现 

    public int[] merge(int[] arr,int start, int end) {
        if(start==end) {
            return new int[] {arr[start]};
        }
        int mIndex = (end+start)/2;//中间index
        int[] lArr = merge(arr,start,mIndex);//左边
        int[] rArr = merge(arr,mIndex+1,end);//右边
        int[] newArr=new int[lArr.length+rArr.length];
        int i=0,j=0,k=0;
        while(i<lArr.length&&j<rArr.length) {
            if(lArr[i]<rArr[j]) {
                newArr[k++]=lArr[i++];
            }else {
                newArr[k++]=rArr[j++];
            }
        }
        while(j<rArr.length) {
            newArr[k++]=rArr[j++];
        }
        while(i<lArr.length) {
            newArr[k++]=lArr[i++];
        }
        return newArr;
    }

	@Test
	public void mSort() {
		int[] arr = {36,67,42,34,33,56,32,55,78,989,22};
		int[] merge = merge(arr,0,arr.length-1);
		System.out.println(Arrays.toString(merge));
	}

 

4）计数排序

计数排序（Counting sort）是一种稳定的线性时间排序算法。计数排序使用一个额外的数组，其中第i个元素是待排序数组中值等于的元素的个数。然后根据数组来将中的元素排到正确的位置。

计数排序算法是一个稳定的排序算法。

算法的步骤如下：

1、找出待排序的数组中最大和最小的元素

2、统计数组中每个值为的元素出现的次数，存入数组的第项

3、对所有的计数累加（从中的第一个元素开始，每一项和前一项相加）

4、反向填充目标数组：将每个元素放在新数组的第项，每放一个元素就将减去1

java代码实现

public static int[] countSort(int[]a){
        int b[] = new int[a.length];
        int max = a[0],min = a[0];
        for(int i:a){
            if(i>max){
                max=i;
            }
            if(i<min){
                min=i;
            }
        }//这里k的大小是要排序的数组中，元素大小的极值差+1
        int k=max-min+1;
        int c[]=new int[k];
        for(int i=0;i<a.length;++i){
            c[a[i]-min]+=1;//优化过的地方，减小了数组c的大小
        }
        for(int i=1;i<c.length;++i){
            c[i]=c[i]+c[i-1];
        }
        for(int i=a.length-1;i>=0;--i){
            b[--c[a[i]-min]]=a[i];//按存取的方式取出c的元素
        }
    return b;
    }

 

5）快速排序

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

快速排序是一种不稳定的排序算法。

java代码实现

public static int[] qsort(int arr[],int start,int end) {        
    int pivot = arr[start];        
    int i = start;        
    int j = end;        
    while (i<j) {            
        while ((i<j)&&(arr[j]>pivot)) {                
            j--;            
        }            
        while ((i<j)&&(arr[i]<pivot)) {                
            i++;            
        }            
        if ((arr[i]==arr[j])&&(i<j)) {                
            i++;            
        } else {                
            int temp = arr[i];                
            arr[i] = arr[j];                
            arr[j] = temp;            
        }        
    }        
    if (i-1>start) arr=qsort(arr,start,i-1);        
    if (j+1<end) arr=qsort(arr,j+1,end);        
    return (arr);    
}