排序算法JAVA实现一

时间复杂度为 O（N^2）的算法：冒泡排序、选择排序、插入排序

题： 对于一个int数组，请编写一个排序算法，对数组元素排序。
给定一个int数组A及数组的大小n，请返回排序后的数组。
测试样例：
　　[1,2,3,5,2,3],6
　　[1,2,2,3,3,5]

一,冒泡排序：

冒泡排序算法的运作如下：
　　１.比较相邻的元素。如果第一个比第二个大，就交换他们两个。
　　２.对每一对相邻元素作同样的工作，从开始第一对到最后。这样一来最后的元素会是最大的数。
　　３.除了最后一个，针对位置０～Ｎ-２的所有的元素重复以上的步骤。
　　４持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较

JAVA代码实现：

package Sort;
import java.util.*;

public class BubbleSort {
    public int[] bubbleSort(int[] A, int n) {
        // write code here
        int tmp;
        for(int j=n;j>1;j--){
            for(int i=0;i<j-1;i++){
                if(A[i]>A[i+1]){
                    tmp=A[i];
                    A[i]=A[i+1];
                    A[i+1]=tmp;
                }
            }
        }
        return A;
    }

    public static void main(String[] args) {          
        int[] A = { 1, 2,  3, 5, 2, 6};  
        int n=6;
        BubbleSort bs = new BubbleSort();
        bs.bubbleSort(A, n);  
        System.out.println(Arrays.toString(A));  
    }  
}

二,选择排序：

　　选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法（比如序列[5， 5， 3]第一次就将第一个[5]与[3]交换，导致第一个5挪动到第二个5后面）。

　　思路：对比数组中第一个元素跟后面元素的大小，如果后面的元素比该元素小则用一个变量k来记住他的位置，并将前面“后面的元素”现变成了“第一个元素”，继续跟他的“后面的元素”进行比较，如果后面的元素比他要小则用变量k记住它在数组中的位置(下标)并交换，等到循环结束的时候，我们就找到整个数组中最小的数并放在第一个位置了。然后找到数组中第二小的数，让他跟数组中第二个元素交换一下值，以此类推。

JAVA代码实现：　

package Sort;
import java.util.Arrays;

public class SelectionSort {
    public int[] selectionSort(int[] A, int n) {
        // write code here
        int tmp;
        int k;
        int t;
        for(int j=0;j<n-1;j++){
                k=j;
                tmp=A[j];
                for(int i=j+1;i<n;i++){
                if(tmp>A[i]){
                    tmp=A[i];
                    k=i;
                }
            }
            t=A[j];
            A[j]=tmp;
            A[k]=t;
        }
         return A;
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] A = { 1, 2,  3, 5, 2, 6};  
        int n=6;
        SelectionSort ss = new SelectionSort();
        ss.selectionSort(A, n);  
        System.out.println(Arrays.toString(A));  
    }

}

三,插入排序：

直接插入排序具体算法描述如下：
　　⒈ 从第一个元素开始，该元素可以认为已经被排序
　　⒉ 取出下一个元素，在已经排序的元素序列中从后向前扫描
　　⒊ 如果该元素（已排序）大于新元素，将该元素移到下一位置
　　⒋ 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
　　⒌ 将新元素插入到下一位置中
　　⒍ 重复步骤2~5

JAVA代码实现：

package Sort;
import java.util.*;
public class InsertionSort {
    public int[] insertionSort(int[] A, int n) {
        // write code here
        int temp=0;   
        for (int i= 1;i<n;i++)    
            for(int j=i;j>0;j--){         
            if (A[j]<A[j-1]){               
                temp = A[j];                  
                A[j] = A[j-1];               
                A[j-1]= temp;             
            }
        }      
        return A;    
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] A = { 1, 2,  3, 5, 2, 6};  
        int n=6;
        InsertionSort is = new InsertionSort();
        is.insertionSort(A, n);  
        System.out.println(Arrays.toString(A)); 
    }

}

二分插入排序（Binary Insertion Sort）：
　　是对直接插入排序的改进，由于已排好序的部分是有序的，所以我们就能使用二分查找法确定我们的插入位置，而不是一个个找，除了这点，它跟插入排序没什么区别