常用排序算法

1.选择排序

1.1. 思想：选择数组中的最小值与数组中第一个数字交换，然后找剩余数的最小值与第二个数字交换，以此类推。

1.2. Java代码实现

 

  public void selectSort() {
        int a[] = { 1, 54, 6, 3, 78, 34, 12, 45 };
        int pos= 0;
        for (int i = 0; i < a.length; i++) {
            int j = i + 1;
            pos = i;
            int temp = a[i];
            for (; j < a.length; j++) {
                if (a[j] < temp) {
                    temp = a[j];
                    pos = j;
                }
            }
            a[pos] = a[i];
            a[i] = temp;
        }
        for (int i = 0; i < a.length; i++)
            //;仅仅用于分隔数字
            System.out.print(a[i]+";");
    }

2.冒泡排序

2.1. 思想：在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。每次冒出一个数，冒出的数不参与下一次冒泡。

2.2. java代码实现

public class MP {
    public static void main(String[] args) {
        int [] arr = { 18,49, 38, 65, 97, 76, 13,11,5};
        for(int i=0;i<arr.length-1;i++){
            for(int j=0;j<arr.length-1-i;j++){
                if(arr[j]>arr[j+1]){
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        for(int i:arr){
            System.out.print(i+",");
        }
    }
}

3.快速排序

3.1 思想：选择其中一个值作为基准值，一般选第一个或者最后一个，在此选第一个为基准值，第一组下来把比基准值小的放到左侧，大的放到右侧，然后利用递归再分别对小的一侧和大的一侧进行排序。

3.2 java代码实现

package demo;

import org.junit.Test;

/**
 * 快速排序升序
 * @author Administrator
 *
 */

public class KS {
    @Test
    public void test(){
        int [] arr = { 18,49, 38, 65, 97, 76, 13,11,5};
        quickSort(arr, 0, arr.length-1);
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+",");
        }
    }
    public int getMiddle(int[] arr,int low,int high){
        int temp=arr[low];//把第一个值作为基准
        while(low<high){//没有对比完
            while(low<high&&arr[high]>=temp){//高位的大于基准值
                high--;//向左一个数字对比
            }
            arr[low]=arr[high];//把高位的换到低位去
            while(low<high&&arr[low]<=temp){
                low++;
            }
            arr[high]=arr[low];
        }
        arr[low]=temp;
        return low;
    }
    public void quickSort(int[]arr,int low,int high){
        if(low<high){
            int middle = getMiddle(arr,low,high);
            quickSort(arr, low, middle-1);
            quickSort(arr, middle+1, high);
        }
    }

}

4.二分法排序

4.1.思想：在插入第i个元素时，对前面的0～i-1元素进行折半，先跟他们 中间的那个元素比，如果小，则对前半再进行折半，否则对后半 进行折半，直到left>right，然后再把第i个元素前1位与目标位置之间 的所有元素后移，再把第i个元素放在目标位置上。

package demo;

import org.junit.Test;

public class EF {
	@Test
	public void test1(){
		EF e = new EF();
		int [] arr = {5,45,12,5,36,2,1,8,9};
		e.DichotomySort(arr);
		for(int i:arr){
			System.out.println(i);
		}
	}
	public static void DichotomySort(int[] array)  
    {  
        for (int i = 0; i < array.length; i++)  
        {  
            int start = 0;  

            int end = i - 1;  

            int middle = 0;  

            int temp = array[i];  

            while (start <= end)  
            {  
                middle = (start + end) / 2;  

                if (array[middle] > temp)//要排序元素在已经排过序的数组左边  
                {  
                    end = middle - 1;  
                }  
                else  
                {  
                    start = middle + 1;  
                }  
            }  
            for (int j = i - 1; j > end; j--)//找到了要插入的位置，然后将这个位置以后的所有元素向后移动  
            {  
                array[j + 1] = array[j];  
            }  

            array[end + 1] = temp;  

        }  
    } 

}