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

// 桶排序  原理：使用数组实现，参与排序的数与数组下标相同，数字排序后所在位置即为对应数组下标所在，初始化时，整个数组均为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));

            }

      }

}