桶排序、冒泡排序、快速排序 -- 算法学习 小结篇

// 桶排序  原理：使用数组实现，参与排序的数与数组下标相同，数字排序后所在位置即为对应数组下标所在，初始化时，整个数组均为0，每有一个数找到对应下标，则对应下标所在数组单元内容+1，由于是用数组下标“标记”数字所在位置，所以在一定范围内排序，且数字密度较大时，这个算法是比较可行的，比如班级同学的成绩统计，只需创建成绩上限分值大小的数组即可。但是当参与数的数值较大，且数字密度小的时候就不划算了，比如给63335，23，2排序时，需要创建一个63335的小的数组，是在是有点浪费资源。

  简单数组实现  开销大  桶小时 速度快 

              Scanner scanner = new Scanner(System.in);

            System.out.println("请输入排序的人数：");

            int n = scanner.nextInt();

            System.out.println("请输入各同学的成绩：");

            int[] a = new int[1001];

            int tem;

            for(int ii=1;ii<=1001;ii++)

                  a[ii-1]=0;

            for(int i=1;i<=n;i++)

                  {

                        a[scanner.nextInt()]++;

                  }

            for(int j=0;j<=1000;j++)

                  for(int k=1;k<=a[j];k++)

                              System.out.println(j);

                        

            for(int m=1;m<=5;m++){

                  System.out.println("成绩排列："+a[m-1]);

            }

          

//冒泡排序    原理：是交换排序的一种，按照一定顺序，从起始点开始，依次和下一个数进行比较，每次都把相对大或者小的数放在后面位置上，再和下一个数进行比较....重复上述步骤(每一趟即可确定最后一个位置的数，下一趟即不用与前面确定的数进行比较)，如果有N个数，理论上进行N-1趟，即可完成排序。

            Scanner   scanner   =   new   Scanner(System. in );

            System. out .println( "请输入参与排序的人数：" );

             int   n   =   scanner .nextInt();

            System. out .println( "请输入参与排序的人的成绩与姓名：" );

            Map<Integer, String>   map   =   new   HashMap<Integer, String>();

             int   temInt ;

             int   temInt2 , temCount   = 0, temChange ;

            String   temString ;

             for ( int   i =1; i <= n ; i ++){

                   temInt   =   scanner .nextInt();

                   temString   =   scanner .next();

                   map .put( temInt ,   temString );

            }

             int []   keySet   =   new   int [ map .size()];

            System. out .println( keySet . length + "lebgth" );

             //(int j=1;j<=map.size();j++)

            Iterator<Integer>   iterator   =   map .keySet().iterator();

                   while   ( iterator .hasNext()) {

                         temInt2   =   iterator .next();

                         keySet [ temCount ] =   temInt2 ;

                         temCount ++;

                  }

             for ( int   m =1; m < n ; m ++)

                   for ( int   mn =0; mn < n - m ; mn ++){

                         if ( keySet [ mn ]> keySet [ mn +1]){

                               temChange = keySet [ mn ];

                               keySet [ mn ]= keySet [ mn +1];

                               keySet [ mn +1]= temChange ;

                        }

                  }

             for ( int   nm   =1; nm <= n ; nm ++){

                  System. out .println( keySet [ nm -1]+ ":" + map .get( keySet [ nm -1]));

            }

// 快速排序  

 list数组实现 类似与二分法  

public   class   QuicksortTest {

       private   List<Integer>   a   =   new   ArrayList<Integer>();

       private   void   quickSort( int   left , int   right ) {

             //   TODO   Auto-generated method stub

             int   i , j , temp , tempChange ;

             if ( left >= right ){

                   return ;

            }

             temp = a .get( left );

             i = left ;

             j = right ;

             while ( i != j ){

                   while ( a .get( j )>= temp && i < j )

                         j --;

                   while ( a .get( i )<= temp && i < j )

                         i ++;

                   if ( i < j ){

                         tempChange   =   a .get( i );

                         a .set( i ,   a .get( j ));

                         a .set( j ,   tempChange );

                  }

            }

             a .set( left ,   a .get( i ));

             a .set( i ,   temp );

            quickSort( left ,   i -1);

            quickSort( i +1,   right );

      }

       public   static   void   main(String[]   args ) {

            QuicksortTest   quicksortTest   =   new   QuicksortTest();

            Scanner   scanner   =   new   Scanner(System. in );

             //quicksortTest.a.add(0);

            System. out .println( "begain!" );

             int   n   =   scanner .nextInt();

             for ( int   i =1; i <= n ; i ++){

                   quicksortTest . a .add( scanner .nextInt());

            }

             for   ( int   i   = 0;   i   < n ;   i ++) {

                  System. out .println( "排序前：第" +( i +1)+ "个数=" + quicksortTest . a .get( i ));

            }

             quicksortTest .quickSort(0,   n -1);

            System. out .println( "数组的长度：" + quicksortTest . a .size());

             for   ( int   i   = 0;   i   < n ;   i ++) {

                  System. out .println( "排序后：第" +( i +1)+ "个数=" + quicksortTest . a .get( i ));

            }

      }

}