Java面试中的排序算法

冒泡排序

通过与相邻元素的比较和交换来把小的数交换到最前面。这个过程类似于水泡上升一样，因而得名。例如，对5，3，8，6，4这个无序序列进行冒泡排序。首先从后向前冒泡，4和6比较，把4交换到前面，序列变成5，3，8，4，6。同理4和8交换，变成5，3，4，8，6。3和4无需交换。5和3交换，变成3，5，4，8，6。这样一次冒泡就完成了，把最小的数3排到最前面了。对剩下的序列依次冒泡就会得到一个有序序列。冒泡排序的时间复杂度为O(n^2)。

实现代码:

public class BubbleSort { 
    public static void bubbleSort(int[]arr) {  
        if(arr==null||arr.length==0)   
            return;   
        for(int i=0;i<arr.length-1;i++)  
        {   
            for(int j=arr.length-1;j>=i;j--)  
            {    
                if(arr[j]<arr[j-1])     
                    swap(arr,j-1,j);   
            }  
        } 
    } 
    public static void swap(int[]arr,int i,int j) 
    {  
        int temp=arr[i];  
        arr[i]=arr[j];  
        arr[j]=temp; 
    }
}

 

 

选择排序

在一次排序后把最小的元素放到最前面。选择排序是通过对整体的选择。举个例子，对5，3，8，6，4这个无序序列进行简单选择排序，首先要选择5以外的最小数来和5交换，也就是选择3和5交换，一次排序后就变成了3，5，8，6，4。对剩下的序列依次进行选择和交换，最终就会得到一个有序序列。选择排序的时间复杂度是O(n^2)。

实现代码：

public class SelectSort { 
    public static void selectSort(int[]arr) {  
        if(arr==null||arr.length==0)   
            return;  
        int minIndex=0;  
        for(int i=0;i<arr.length ;i++)  
        {   
            minIndex=i;   
            for(int j=i+1;j<arr.length;j++)   
            {    
                if(arr[j]<arr[minIndex])    
                {     
                    minIndex=j;    
                }           
            }   
            if(minIndex!=i)   
            {    
                int temp=arr[i];    
                arr[i]=arr[minIndex];    
                arr[minIndex]=temp;   
            }  
        }   
    }
}

 

 

插入排序

通过比较找到合适的位置插入元素来达到排序目的。例如，对5，3，8，6，4这个无序序列进行简单插入排序，首先假设第一个数的位置是正确的，然后3要插到5的前面，把5后移一位，变成3，5，8，6，4。然后8不用动，6插在8的前面，8后移一位，4插在5前面，从5开始都后移一位。注意在插入一个数的时候要保证这个数前面的数已经有序。简单插入排序的时间复杂度是O（n^2）。

实现代码：

public class InsertSort { 
    public static void insertSort(int []arr) {  
        if(arr==null||arr.length ==0)   
            return;  
        for(int i=1;i<arr.length ;i++)  
        {   
            int j=i-1;   
            int target=arr[i];   
            while(j>-1&&target<arr[j])   
            {    
                arr[j+1]=arr[j];    
                j--;   
            }   
            arr[j+1]=target;     
        } 
    }
}

 

快速排序

快速排序是对冒泡排序的改进。

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

实现代码：

public class QuickSort{
    public void sort(int arr[], int low, int high)
    {
        int l = low;
        int h = high;
        int povit = arr[low];
        while(l<h){
            while(l<h && arr[h]>=povit)
                h--;
            if(l<h){
                int temp = arr[h];
                arr[h] = arr[l];
                arr[l] = temp;
                l++;
            } 
            while(l<h && arr[l]<=povit)
                l++;
            if(l<h){
                int temp = arr[h];
                arr[h] = arr[l];
                arr[l] = temp;
                h--;
            }
        }
        if(l>low)sort(arr, low, l-1);
        if(h<high)sort(arr, l+1, high);
    }
}