九大排序算法之代码实现

一：冒泡排序法
Java代码：
public class bubble_sort {
public static void main(String args[]){
int[] number = {23,12,48,17,36};
bubble_sort(number);

    for(int i=0;i<number.length;i++){
        System.out.println(number[i]);
    }   
}

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

        }
    }
}

二：简单选择排序
Java代码
package rankDemo;

public class SimpleSort {

public static void main(String[] args) {
    int[] number = {23,12,47,18,36};

    SimpleSort(number);
    for(int k=0;k<number.length;k++){
        System.out.println(number[k]);
    }   
}

private static void SimpleSort(int[] number) {
    int temp,min = 0;
    for(int i=0;i<number.length-1;i++){
        temp = number[i];
        for(int j=i+1;j<number.length;j++){
            if(number[j]<temp){         //找到最小的值  记录下最小值得索引
                min = j;
                temp = number[j];
            }
        }

    if(min!=i){                      //交换顺序
        temp = number[min];
        number[min] = number[i];
        number[i] = temp;
        }
    }   
}

}

三：希尔排序
package rankDemo;
public class shellSort {
public static void main(String[] args) {
int[] number = {13,14,94,33,82,25,59,94,65,23,45,27,73,25,39,10};

    shellSort(number);
    for(int k=0;k<number.length;k++){
        System.out.println(number[k]);
    }   
}

public static void shellSort(int[] a) {
    int gap = 1, i, j, len = a.length;
    int temp;//插入排序交换值的暂存
    //确定初始步长
    while (gap < len / 3){
        gap = gap * 3 + 1;
    }
    for (; gap > 0; gap /= 3){//循环遍历步长，最后必为1
        for (i = gap; i < len; i++) {//每一列依次向前做插入排序
            temp = a[i];
            //每一列中在a[i]上面且比a[i]大的元素依次向下移动
            for (j = i - gap; j >= 0 && a[j] > temp; j -= gap){
                a[j + gap] = a[j];
            }
            //a[i]填补空白，完成一列中的依次插入排序
            a[j + gap] = temp;
        }
    }   
}

}

四：归并排序
Java代码
package rankDemo;

public class merge_sort {

public static void main(String[] args) {
    int [] arr ={6,5,3,1,8,7,2,4};
    merge_sort(arr);
    for(int i : arr){
        System.out.println(i);
    }
}

public static void merge_sort(int[] arr) {
int len = arr.length;
//用于合并的临时数组
int[] result = new int[len];
int block, start;

  //两两合并后块大小变大两倍 (注意最后一次block等于len)
    for(block = 1; block <=len ; block *= 2) {
        //把整个数组分成很多个块，每次合并处理两个块
        for(start = 0; start <len; start += 2 * block) {
            int low = start;
            int mid = (start + block) < len ? (start + block) : len;
            int high = (start + 2 * block) < len ? (start + 2 * block) : len;
            //两个块的起始下标及结束下标
            int start1 = low, end1 = mid;
            int start2 = mid, end2 = high;
            //开始对两个block进行归并排序
            while (start1 < end1 && start2 < end2) {
            result[low++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];
            }
            while(start1 < end1) {
            result[low++] = arr[start1++];
            }
            while(start2 < end2) {
            result[low++] = arr[start2++];
            }
        }
     //每次归并后把结果result存入arr中，以便进行下次归并
    int[] temp = arr;
    arr = result;
    result = temp;
    }
}

}

五：快速排序
Java代码：
package rankDemo;

public class quickSort {
public static void main(String[] args) {
int [] arr = {8,1,0,4,6,2,7,9,5,3};
quickSort(arr,0,arr.length-1);
for(int i :arr){
System.out.println(i);
}
}
public static 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);
}
}
public static int getMiddle(int[] list, int low, int high) {
int tmp = list[low];
while (low < high) {
while (low < high && list[high] >= tmp) {
high–;
}
list[low] = list[high];
while (low < high && list[low] <= tmp) {
low++;
}
list[high] = list[low];
}
list[low] = tmp;
return low;
}
}

六：堆排序
Java代码：
package rankDemo;

public class HeapSort {
    private static int[] sort = new int[]{1,0,10,20,3,5,6,4,9,8,12,17,34,11};
    public static void main(String[] args) {
        buildMaxHeapify(sort);
        heapSort(sort);
        print(sort);
    }

    private static void buildMaxHeapify(int[] data){
        //没有子节点的才需要创建最大堆，从最后一个的父节点开始
        int startIndex = getParentIndex(data.length - 1);
        //从尾端开始创建最大堆，每次都是正确的堆
        for (int i = startIndex; i >= 0; i--) {
            maxHeapify(data, data.length, i);
        }
    }

    /**
     * 创建最大堆
     * @param data
     * @param heapSize需要创建最大堆的大小，一般在sort的时候用到，因为最多值放在末尾，末尾就不再归入最大堆了
     * @param index当前需要创建最大堆的位置
     */
    private static void maxHeapify(int[] data, int heapSize, int index){
        // 当前点与左右子节点比较
        int left = getChildLeftIndex(index);
        int right = getChildRightIndex(index);

        int largest = index;
        if (left < heapSize && data[index] < data[left]) {
            largest = left;
        }
        if (right < heapSize && data[largest] < data[right]) {
            largest = right;
        }
        //得到最大值后可能需要交换，如果交换了，其子节点可能就不是最大堆了，需要重新调整
        if (largest != index) {
            int temp = data[index];
            data[index] = data[largest];
            data[largest] = temp;
            maxHeapify(data, heapSize, largest);
        }
    }

    /**
     * 排序，最大值放在末尾，data虽然是最大堆，在排序后就成了递增的
     * @param data
     */
    private static void heapSort(int[] data) {
        //末尾与头交换，交换后调整最大堆
        for (int i = data.length - 1; i > 0; i--) {
            int temp = data[0];
            data[0] = data[i];
            data[i] = temp;
            maxHeapify(data, i, 0);
        }
    }

    /**
     * 父节点位置
     * @param current
     * @return
     */
    private static int getParentIndex(int current){
        return (current - 1) >> 1;
    }

    /**
     * 左子节点position注意括号，加法优先级更高
     * @param current
     * @return
     */
    private static int getChildLeftIndex(int current){
        return (current << 1) + 1;
    }

    /**
     * 右子节点position
     * @param current
     * @return
     */
    private static int getChildRightIndex(int current){
        return (current << 1) + 2;
    }

    private static void print(int[] data){
        for (int i = 0; i < data.length; i++) {
            System.out.print(data[i] + " |");
        }
    }
}

七：桶排序
Java代码
package rankDemo;

import java.util.ArrayList;
import java.util.Iterator;

public class BucketSort  {
    /** 
     * 对arr进行桶排序，排序结果仍放在arr中 
     */  
    public static void bucketSort(double arr[]){  
  //-------------------------------------------------分桶-----------------------------------------------      
        int n = arr.length;  
        //存放桶的链表
        ArrayList bucketList[] = new ArrayList [n];  
        //每个桶是一个list，存放此桶的元素   
        for(int i =0;i<n;i++){  
            //下取等
            int temp = (int) Math.floor(n*arr[i]);  
            //若不存在该桶，就新建一个桶并加入到桶链表中
            if(null==bucketList[temp])  
                bucketList[temp] = new ArrayList();  
            //把当前元素加入到对应桶中
            bucketList[temp].add(arr[i]);            
        }  
//-------------------------------------------------桶内排序-----------------------------------------------    
        //对每个桶中的数进行插入排序   
        for(int i = 0;i<n;i++){  
            if(null!=bucketList[i])  
                insert(bucketList[i]);  
        }  
//-------------------------------------------------合并桶内数据-----------------------------------------------    
        //把各个桶的排序结果合并   
        int count = 0; 
        for(int i = 0;i<n;i++){  
            if(null!=bucketList[i]){  
                Iterator iter = bucketList[i].iterator();  
                while(iter.hasNext()){  
                    Double d = (Double)iter.next();  
                    arr[count] = d;  
                    count++;  
                }  
            }  
        }  
    }  

    /** 
     * 用插入排序对每个桶进行排序 
     * 从小到大排序
     */  
    public static void insert(ArrayList list){  

        if(list.size()>1){  
            for(int i =1;i<list.size();i++){  
                if((Double)list.get(i)<(Double)list.get(i-1)){  
                    double temp = (Double) list.get(i);  
                    int j = i-1;  
                    for(;j>=0&&((Double)list.get(j)>(Double)list.get(j+1));j--)  
                        list.set(j+1, list.get(j));  //后移
                    list.set(j+1, temp);  
                }  
            }  
        } 
    }
}

测试代码：
public static void main(String[] args) {
double arr [] ={0.21,0.23,0.76,0.12,0.89};
BucketSort.bucketSort(arr);
for(double a:arr){
System.out.println(a);
}
}

八：基数排序
Java代码
package rankDemo;

import java.awt.List;
import java.util.ArrayList;

public class radixSort {
public static void main(String[] args) {

    int[] array = {278,109,63,930,589,184,505,269,8,83};  
    radixSort(array);  
    for(double a : array){
        System.out.println(a);
    }
}

public static void radixSort(int[] array){

    //------------------------------------------确定排序的趟数----------------------------------
    int max=array[0];
    for(int i=1;i<array.length;i++){
        if(array[i]>max){
            max=array[i];
        }
    }
    int time=0;
    while(max>0){
        max/=10;
        time++;
    }
    //----------------------------------------初始化10个链表用户分配时暂存-------------------------------
    List<List<Integer>> list=new ArrayList<List<Integer>>();
    for(int i=0;i<10;i++){
        List<Integer> item=new ArrayList<Integer>();
        list.add(item);
    }

    //-----------------------------------------进行time次分配和收集-------------------------------------
  for(int i=0;i<time;i++){
        //分配元素;
        for(int j=0;j<array.length;j++){
            int index = array[j]%(int)Math.pow(10, i+1)/(int)Math.pow(10, i);
            list.get(index).add(array[j]);
        }
        //收集元素;
        int count=0;
        for(int k=0;k<10;k++){
            if(list.get(k).size()>0){
                for(int a : list.get(k)){
                    array[count]=a;
                    count++;
                }
                //清除数据，以便下次收集
                list.get(k).clear();
            }
        }
    }
}

}

九：插入排序
Java代码
package rankDemo;
public class insertSort{
public static void main(String[] args) {
int[] number = {23,12,47,18,36};

    insertSort(number);
    for(int k=0;k<number.length;k++){
        System.out.println(number[k]);
    }   
}

public static void insertSort(int a[]){
int j; //当前要插入值的位置
int preJ; //依次指向j前的位置
int key; //后移时来暂存要插入的值

    //从数组的第二个位置开始遍历值  
    for(j=1;j<a.length;j++){  
        key=a[j];  
        preJ=j-1;  
        //a[preJ]比当前值大时，a[preJ]后移一位  
        while(preJ>=0 && a[preJ]>key){  
            a[preJ+1]=a[preJ]; //将a[preJ]值后移   

 //这里注意:  a[preJ+1]=a[j]=key,把插入值已经存在了 key中
//等于说, 留出来一个空白位置来实现依次后移（不会造成数据丢失问题）

            preJ--;         //preJ前移  
        }
        //找到要插入的位置或已遍历完成（(preJ=0）
        a[preJ+1]=key;    //将当前值插入 空白位置
    }  
} 

}