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

int array[]=new int[]{9,2,3,1,0,5,8,4,7,6};//初始化一个数组，长度为10
                int temp;//定义一个临时变量，
                System.out.println("原有数组内容：");//输出这几个汉字
                printArray(array);//调用printArray方法，并将前面初始化的数组作为参数传递给该方法
                for(int i =1;i<array.length;i++){//这里应该是算法的核心了，但是如果想理解，还是先看看内层的循环，
                        for(int j =0;j<array.length-i;j++){//循环了0到数组长度10-1 一共10次
                                if(array[j]>array[j+1]){//数组的第一个元素a[0]与第二个元素a[1]做比较，如果大于，第2个元素
                                        temp=array[j];//那么将大的那个值a[0]的值赋值给临时变量
                                        array[j]=array[j+1];//再将a[1]的值赋值给a[0]
                                        array[j+1]=temp;//最后把临时变量中的值复制给a[1]
//看懂这里了吗？如果前面的数，或者形象点a[0] ,a[1],..依次往上排，那么就是如果排在下面的数组元素的值大于上面的数组元素的值那么就将这两个元素的位置换一下，大的放上面，也就是排在数组的后面，像不像冒泡，水中的气泡，越到上面越大；如果小的话当然就没关系了，还是小的在下面
                                }
//这一次内层循环做完之后，保证了最下面的气泡（数组元素的位置），它跟后面所有的元素都做了一次比较，如果它最大就能排到最上面
                        }
//最外层的循环保证了，从头到尾将所有的数组元素按照从前到后，或者从下到上的顺序都与后面的元素比较了一次，这就完成了所有元素的排序
                }
                System.out.println("从小到大排序后的结果：");
                printArray(array);
        }

        private static void printArray(int[] array) {//来看看，这个方法做了什么，在上面调用这个方法的时候已经将你初始化的那个长度为10的数组做为参数传递了进来
                // TODO Auto-generated method stub
                for(int i : array){//用增强for循环，遍历这个数组
                        System.out.print(i+" ");//一次打印i的值和空格
                }
                System.out.println("\n");//都遍历结束后，换行
        }

/**
* 演示各种排序方法
* @author 李见黎
*2012-3-17
*/
import java.util.*;

public class Sort {

        /**
         * @param args
         */
        public static void main(String[] args) {
//                int arr[]={1,3,4,2,0,-5,6,7};  //最开始测试数组
               
                /**
                 * 产生数组的过程
                 */
                int len=30;
                int arr[]=new int[len];
                for(int i=0;i<len;i++)
                {
                        //让程序随机产生数，也是很实用的小技巧
                        //math.Random产生的是0~1的数
                        int r=(int)(Math.random()*len);
                        arr[i]=r;                       
                }
               
                /**
                 * 各种排序实例化
                 */
                Bubble bubble=new Bubble();  //冒泡排序
                SelectSort selectSort=new SelectSort();  //选择排序
                InsertSort iSort=new InsertSort();  //插入排序
               
                /**
                 * 实现排序，并且显示时间
                 */
                Calendar calendar=Calendar.getInstance(); //掌握系统时间，很实用的小技巧
                System.out.println("开始前的时间:"+calendar.getTime());
               
//                selectSort.Sort(arr);
               
//                bubble.bubbleSort(arr);
               
                iSort.Sort(arr);
                //重新获得实例，刷新时间
                calendar=Calendar.getInstance();
                System.out.println("开始后的时间:"+calendar.getTime());
       
                /**
                 * 显示排序结果，打印是最费时间的
                 */
                for(int i=0;i<arr.length;i++)
                {
                        System.out.println(arr[i]);
                }
       
        }

}

/**
* 插入排序
* @author 李见黎
*2012-3-18
*/
class InsertSort
{
        public void Sort(int []arr)
        {
                for(int i=0;i<arr.length;i++)
                {
                        int insertValue=arr[i];  //待插入的数
                        //insertValue与前一个数比较
                        int index=i-1;
                       
                        while(index>=0&&insertValue<arr[index])
                        {//保证index不能使负数，越界
                                //满足条件则把arr[index]向前移动
                                arr[index+1]=arr[index];
                                //将index向后移动
                                index--;
                        }
                        //将insertValue插入到适当的位置
                       
                        arr[index+1]=insertValue;
                       
                }
        }
}

/**
* 冒泡排序法
* @author 李见黎
*2012=3-17
*/

class Bubble
{
        public void bubbleSort(int []arr)
        {
               
                int tempt=0;//中间变量
               
                //排序
                //外层排序，决定走几趟
                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])
                                {//前一个数比后一个数大，交换位置，把最大的放在最前面
                                        tempt=arr[j];
                                        arr[j]=arr[j+1];
                                        arr[j+1]=tempt;                                                                               
                                }
                        }
                }
        }
}

/**
* 选择排序，速度比冒泡快点
* @author Administrator
*2012-3-17
*/
class SelectSort
{
        public void Sort(int []arr)
        {//将最小的数放到最前面
                int tempt=0;  //临时变量
                for(int i=0;i<arr.length-1;i++)
                {
                        int min=arr[i];//第一数最小
                        int minIndex=i;//记录最小数的下标
                       
                        //第一个数不参与比较，从第二个数开始比较
                       
                        for(int j=i+1;j<arr.length;j++)
                        {
                                if(min>arr[j])
                                {//修改最小值
                                        min=arr[j];
                                        minIndex=j;
                                }
                        }
                       
                //当退出for循环时就找到最小值，交换最小值
               
                        tempt=arr[i];
                        arr[i]=arr[minIndex];
                        arr[minIndex]=tempt;
                }
        }
}

/**
* 演示各种排序方法
* @author 李见黎
*2012-3-17
*/
import java.util.*;

public class Sort {

        /**
         * @param args
         */
        public static void main(String[] args) {
//                int arr[]={1,3,4,2,0,-5,6,7};  //最开始测试数组
               
                /**
                 * 产生数组的过程
                 */
                int len=30;
                int arr[]=new int[len];
                for(int i=0;i<len;i++)
                {
                        //让程序随机产生数，也是很实用的小技巧
                        //math.Random产生的是0~1的数
                        int r=(int)(Math.random()*len);
                        arr[i]=r;                       
                }
               
                /**
                 * 各种排序实例化
                 */
                Bubble bubble=new Bubble();  //冒泡排序
                SelectSort selectSort=new SelectSort();  //选择排序
                InsertSort iSort=new InsertSort();  //插入排序
               
                /**
                 * 实现排序，并且显示时间
                 */
                Calendar calendar=Calendar.getInstance(); //掌握系统时间，很实用的小技巧
                System.out.println("开始前的时间:"+calendar.getTime());
               
//                selectSort.Sort(arr);
               
//                bubble.bubbleSort(arr);
               
                iSort.Sort(arr);
                //重新获得实例，刷新时间
                calendar=Calendar.getInstance();
                System.out.println("开始后的时间:"+calendar.getTime());
       
                /**
                 * 显示排序结果，打印是最费时间的
                 */
                for(int i=0;i<arr.length;i++)
                {
                        System.out.println(arr[i]);
                }
       
        }

}

/**
* 插入排序
* @author 李见黎
*2012-3-18
*/
class InsertSort
{
        public void Sort(int []arr)
        {
                for(int i=0;i<arr.length;i++)
                {
                        int insertValue=arr[i];  //待插入的数
                        //insertValue与前一个数比较
                        int index=i-1;
                       
                        while(index>=0&&insertValue<arr[index])
                        {//保证index不能使负数，越界
                                //满足条件则把arr[index]向前移动
                                arr[index+1]=arr[index];
                                //将index向后移动
                                index--;
                        }
                        //将insertValue插入到适当的位置
                       
                        arr[index+1]=insertValue;
                       
                }
        }
}

/**
* 冒泡排序法
* @author 李见黎
*2012=3-17
*/

class Bubble
{
        public void bubbleSort(int []arr)
        {
               
                int tempt=0;//中间变量
               
                //排序
                //外层排序，决定走几趟
                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])
                                {//前一个数比后一个数大，交换位置，把最大的放在最前面
                                        tempt=arr[j];
                                        arr[j]=arr[j+1];
                                        arr[j+1]=tempt;                                                                               
                                }
                        }
                }
        }
}

/**
* 选择排序，速度比冒泡快点
* @author Administrator
*2012-3-17
*/
class SelectSort
{
        public void Sort(int []arr)
        {//将最小的数放到最前面
                int tempt=0;  //临时变量
                for(int i=0;i<arr.length-1;i++)
                {
                        int min=arr[i];//第一数最小
                        int minIndex=i;//记录最小数的下标
                       
                        //第一个数不参与比较，从第二个数开始比较
                       
                        for(int j=i+1;j<arr.length;j++)
                        {
                                if(min>arr[j])
                                {//修改最小值
                                        min=arr[j];
                                        minIndex=j;
                                }
                        }
                       
                //当退出for循环时就找到最小值，交换最小值
               
                        tempt=arr[i];
                        arr[i]=arr[minIndex];
                        arr[minIndex]=tempt;
                }
        }
}

/**
* 演示各种排序方法
* @author 李见黎
*2012-3-17
*/
import java.util.*;

public class Sort {

        /**
         * @param args
         */
        public static void main(String[] args) {
//                int arr[]={1,3,4,2,0,-5,6,7};  //最开始测试数组
               
                /**
                 * 产生数组的过程
                 */
                int len=30;
                int arr[]=new int[len];
                for(int i=0;i<len;i++)
                {
                        //让程序随机产生数，也是很实用的小技巧
                        //math.Random产生的是0~1的数
                        int r=(int)(Math.random()*len);
                        arr[i]=r;                       
                }
               
                /**
                 * 各种排序实例化
                 */
                Bubble bubble=new Bubble();  //冒泡排序
                SelectSort selectSort=new SelectSort();  //选择排序
                InsertSort iSort=new InsertSort();  //插入排序
               
                /**
                 * 实现排序，并且显示时间
                 */
                Calendar calendar=Calendar.getInstance(); //掌握系统时间，很实用的小技巧
                System.out.println("开始前的时间:"+calendar.getTime());
               
//                selectSort.Sort(arr);
               
//                bubble.bubbleSort(arr);
               
                iSort.Sort(arr);
                //重新获得实例，刷新时间
                calendar=Calendar.getInstance();
                System.out.println("开始后的时间:"+calendar.getTime());
       
                /**
                 * 显示排序结果，打印是最费时间的
                 */
                for(int i=0;i<arr.length;i++)
                {
                        System.out.println(arr[i]);
                }
       
        }

}

/**
* 插入排序
* @author 李见黎
*2012-3-18
*/
class InsertSort
{
        public void Sort(int []arr)
        {
                for(int i=0;i<arr.length;i++)
                {
                        int insertValue=arr[i];  //待插入的数
                        //insertValue与前一个数比较
                        int index=i-1;
                       
                        while(index>=0&&insertValue<arr[index])
                        {//保证index不能使负数，越界
                                //满足条件则把arr[index]向前移动
                                arr[index+1]=arr[index];
                                //将index向后移动
                                index--;
                        }
                        //将insertValue插入到适当的位置
                       
                        arr[index+1]=insertValue;
                       
                }
        }
}

/**
* 冒泡排序法
* @author 李见黎
*2012=3-17
*/

class Bubble
{
        public void bubbleSort(int []arr)
        {
               
                int tempt=0;//中间变量
               
                //排序
                //外层排序，决定走几趟
                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])
                                {//前一个数比后一个数大，交换位置，把最大的放在最前面
                                        tempt=arr[j];
                                        arr[j]=arr[j+1];
                                        arr[j+1]=tempt;                                                                               
                                }
                        }
                }
        }
}

/**
* 选择排序，速度比冒泡快点
* @author Administrator
*2012-3-17
*/
class SelectSort
{
        public void Sort(int []arr)
        {//将最小的数放到最前面
                int tempt=0;  //临时变量
                for(int i=0;i<arr.length-1;i++)
                {
                        int min=arr[i];//第一数最小
                        int minIndex=i;//记录最小数的下标
                       
                        //第一个数不参与比较，从第二个数开始比较
                       
                        for(int j=i+1;j<arr.length;j++)
                        {
                                if(min>arr[j])
                                {//修改最小值
                                        min=arr[j];
                                        minIndex=j;
                                }
                        }
                       
                //当退出for循环时就找到最小值，交换最小值
               
                        tempt=arr[i];
                        arr[i]=arr[minIndex];
                        arr[minIndex]=tempt;
                }
        }
}