Java版各种排序算法 (冒泡，快速，选择，插入)

package com.test4;
import java.util.*; //Calendar 显示时间
/**
 * @author qingfeng
 * 功能：排序算法
 */
public class Bubble {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //int arr[] = {10,1,-20,89,-1,78,-45};
        
        //随机产生大量数据
        
        int len = 5000000;//500万个数 1秒
        int[] arr = new int[len]; 
        
        
        for(int i=0; i<len; i++)
        {
            //产生1到1000的数
            arr[i] = (int)(Math.random()*10000);
        }
        /*
        for(int i=0; i<len; i++)
        {
            System.out.print(arr[i]+" ");
        }
        System.out.println();
        */
        
        //显示排序前的时间
        Calendar time = Calendar.getInstance();//获取时间实例
        System.out.println("排序前的时间为："+time.getTime());
        
        /*InsertSort is = new InsertSort();//50000个数3秒
        is.sort(arr);*/
        /*
        BubbleSort bs = new BubbleSort();//50000个数9秒
        bs.sort(arr);*/
        
        /*
        SelectSort  ss = new SelectSort(); //50000个数排序3秒
        ss.sort(arr);*/
        QuickSort qs = new QuickSort();
        qs.sort(0, arr.length-1, arr);
        
        /*
        int a = 1; 
        bs.test(a);
        System.out.println("a的值为："+a);//a的值为1 并不是2 因为是值传递
        */
        
        /*
        System.out.println("-----------------------------");
        for(int i=0; i<arr.length; i++)
        {
            System.out.print(arr[i]+" ");
        }
        System.out.println();
        */
        //显示排序前的时间
        Calendar time2 = Calendar.getInstance();//获取时间实例
        System.out.println("排序后的时间为："+time2.getTime());
    }
}
//冒泡排序
class BubbleSort
{
    public void test(int a)//测试值传递
    {
        a++;
    }
    public void sort(int arr[]) //引用传递（复合类型）
    {
        int temp;
        
        //冒泡排序
        //外层循环：n个数  n-1趟排序
        for(int i=0; i<arr.length-1; i++)
        {
            //内层循环：若前比后打则交换   （每趟比前一趟少排一个数:所以"-i")
            for(int j=0; j<arr.length-1-i; j++)
            {
                if(arr[j]>arr[j+1])
                {
                    temp = arr[j+1];
                    arr[j+1] = arr[j];
                    arr[j] = temp;            
                }
            }
        }
    }
}
//选择排序
class SelectSort
{
    public void sort(int arr[])//引用传递
    {
        //外层循环:n个数 n-1趟排序  最后一个数不要再次排序
        for(int i=0; i<arr.length-1; i++)
        {
            int min=arr[i];
            int minIndex = i;
            
            int j;
            int temp;
            //内层循环：选择min值
            for(j=i+1; j<arr.length; j++)
            {
                if(min > arr[j])
                {
                    min = arr[j];
                    minIndex = j;
                }    
            }
            //最小值和每趟第一个值交换
            temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
    }
        
}
//插入排序
class InsertSort
{
    public void sort(int[] arr)
    {
        //控制趟数  从第2个数开始 无序表每次插入一个数到有序表
        for(int i=1; i<arr.length; i++)
        {
            int insertVal = arr[i]; //记录待插入数字
            int index  = i-1;//初始插入位置：为无序表的前一个位置!
            
            //搜索插入位置
            while(index>=0 && insertVal < arr[index])
            {
                //从待插入元素的前一个位置开始扫描   如果大于待插入元素arr[index]后移！
                arr[index+1] = arr[index];
                index--; //往前搜索
            }
            //将insertVal插入到适当位置
            arr[index+1] = insertVal; 
        }
    }
}
//快速排序
class QuickSort
{
    public void sort(int left, int right, int[] arr)
    {
        int i = left; //左运动指针初值
        int j = right;//右运动指针初值
        
        
        if(i < j) //递归结束条件
        {
            int key = arr[i];//每趟分割点为左边第一个数并用key做记录；必须判断i<j,否则再次调用下标i+1即a[i+1]可能越界
            while(i<j)
            {
                while( i<j && arr[j]>=key)//左右指针不碰面且右边的数若>=分割值
                {
                    j--;//右边从后往前搜索
                }
                if(i<j)//若找到右边的数小于分割值
                {
                    arr[i] = arr[j];//交换
                    i++;//左指针右移一位
                }
                
                while(i<j && arr[i]<=key)//左右指针不碰面且左边的数若>=分割值
                {
                    i++;//左边到右边搜索
                }
                if(i<j)//若左边找到比分割值大的数
                {
                    arr[j] = arr[i];//左右指针不碰面且右边的数若>=分割值
                    j--;//右指针左移一位
                }
            }
            arr[i] = key;//分割值放入最终位置
            sort(left, i-1, arr);
            sort(i+1, right, arr);
        }
    }
}