桶排序冒泡排序和快速排序

　　看过的这方面的书籍也是够多了，不实践下感觉根基不牢固。今天开始写写几种基本算法，全当自己练手。

　　这台笔记本上的Visual Studio2008、Qt5.7都罢工了，代码只能用Java （eclipse ide）来写了，不过这也不重要。

　　1、桶排序法：

 1 package nelson.paixu;
 2 import java.util.Arrays;
 3 import java.util.Scanner;
 4 
 5 public class PaiXu {
 6 
 7     public static void main(String[] args) {
 8         
 9         Scanner sc = new Scanner(System.in);
10         System.out.println("请先输入数据个数:");
11         int num = sc.nextInt();
12         int [] array = new int[num];
13         for(int i=0;i<num;i++)
14         {
15             array[i] = sc.nextInt();
16             sc.nextLine();
17         }
18         
19         System.out.println("您输入的数据如下：");
20         for(int i : array)
21             System.out.print(i+" ");
22         System.out.println();
23         
24         //排序
25         int [] container = ContainerPaixu(array);
26         
27         System.out.println("经过桶排序后的结果如下：");
28         //输出排序后的结果
29         for(int i=0;i<container.length;i++)
30         {
31             if(container[i]!= 0)
32             {
33                 for(int j=0;j<container[i];j++)
34                 {
35                     System.out.print(i+" ");
36                 }
37             }
38         }
39         System.out.println();
40     }
41     
42     private static int [] ContainerPaixu(int [] array)
43     {
44         int num = array.length;
45         int [] container = new int[1000];  //输入数据在1000以内
46         Arrays.fill(container, 0);
47         
48         for(int i=0;i<num;i++)
49         {
50             int index = array[i];
51             container[index] ++;
52         }
53         
54         return container;
55     }
56 }

View Code

　　结果如下:

　　桶排序法非常快速简洁，用被排序的值作为数组索引，直接去标记对应数组字段，优点就是：以数组索引去访问数组非常快。缺点之一就是待排序的数中如果有非常大的数，非常耗内存。

　　2、冒泡排序

 1 package nelson.paixu;
 2 import java.util.Arrays;
 3 import java.util.Scanner;
 4 
 5 public class PaiXu {
 6 
 7     public static void main(String[] args) {
 8         
 9         Scanner sc = new Scanner(System.in);
10         System.out.println("请先输入数据个数:");
11         int num = sc.nextInt();
12         int [] array = new int[num];
13         for(int i=0;i<num;i++)
14         {
15             array[i] = sc.nextInt();
16             sc.nextLine();
17         }
18         
19         System.out.println("您输入的数据如下：");
20         for(int i : array)
21             System.out.print(i+" ");
22         System.out.println();
23         
24         //排序
25         int [] container = BubblePaixu(array);
26         
27         System.out.println("经过桶排序后的结果如下：");
28         //输出排序后的结果
29         for(int i=0;i<container.length;i++)
30         {
31             System.out.print(container[i]+" ");
32         }
33         System.out.println();
34     }
35     
36     private static int [] ContainerPaixu(int [] array)
37     {
38         int num = array.length;
39         int [] container = new int[1000];  //输入数据在1000以内
40         Arrays.fill(container, 0);
41         
42         for(int i=0;i<num;i++)
43         {
44             int index = array[i];
45             container[index] ++;
46         }
47         
48         return container;
49     }
50     
51     private static int [] BubblePaixu(int [] array)
52     {
53         int num = array.length;
54         
55         for(int i=0;i<num-1;i++)  //要比较相邻两个数 i=0时是第一个数和第二个数 
56                                   //i=num-2时是array[num-2]和array[num-1]最后两个数
57         {
58             for(int j=0;j<num-i;j++)  //外面的一个大循环只能保证把一组数中最小的那个移动到了最后,
59                                       //一次循环后，最小的一个数已经在最后，
60                                       //第j次循环时，最小的j个数已经在最后，就不要再比较了（已经比较过了，当前数肯定比后面的大）
61             {
62                 if(array[i]<array[i+1])
63                 {
64                     int t = array[i];
65                     array[i]=array[i+1];
66                     array[i+1] = t;
67                 }
68             }
69             
70             //外层循环控制里程循环中比较数的个数和次数，确保每次内层循环少比较一个数（每次循环确定一个最小的数）
71         }
72         
73         return array;
74     }
75 }

View Code

　　结果如下：

　　冒泡排序看代码结构也是非常简单的，用了两层循环，一层循环控制比较个数，一层循环比较相邻数，把数小的移到后面。缺点是效率不高，数据量非常大时，两层循环消耗非常多的时间。

　　3、快速排序

  1 package nelson.paixu;
  2 import java.util.Arrays;
  3 import java.util.Scanner;
  4 
  5 public class PaiXu {
  6 
  7     static int [] arr;
  8     
  9     public static void main(String[] args) {
 10         
 11         Scanner sc = new Scanner(System.in);
 12         System.out.println("请先输入数据个数:");
 13         int num = sc.nextInt();
 14         int [] array = new int[num];
 15         for(int i=0;i<num;i++)
 16         {
 17             array[i] = sc.nextInt();
 18             sc.nextLine();
 19         }
 20         
 21         arr = Arrays.copyOf(array, num);
 22         
 23         System.out.println("您输入的数据如下：");
 24         for(int i : arr)
 25             System.out.print(i+" ");
 26         System.out.println();
 27         
 28         //排序
 29         QuickPaixu(0,num-1);
 30         
 31         System.out.println("经过桶排序后的结果如下：");
 32         //输出排序后的结果
 33         for(int i=0;i<arr.length;i++)
 34         {
 35             System.out.print(arr[i]+" ");
 36         }
 37         System.out.println();
 38     }
 39     
 40     private static int [] ContainerPaixu(int [] array)
 41     {
 42         int num = array.length;
 43         int [] container = new int[1000];  //输入数据在1000以内
 44         Arrays.fill(container, 0);
 45         
 46         for(int i=0;i<num;i++)
 47         {
 48             int index = array[i];
 49             container[index] ++;
 50         }
 51         
 52         return container;
 53     }
 54     
 55     private static int [] BubblePaixu(int [] array)
 56     {
 57         int num = array.length;
 58         
 59         for(int i=0;i<num-1;i++)  //要比较相邻两个数 i=0时是第一个数和第二个数 
 60                                   //i=num-2时是array[num-2]和array[num-1]最后两个数
 61         {
 62             for(int j=0;j<num-i;j++)  //外面的一个大循环只能保证把一组数中最小的那个移动到了最后,
 63                                       //一次循环后，最小的一个数已经在最后，
 64                                       //第j次循环时，最小的j个数已经在最后，就不要再比较了（已经比较过了，当前数肯定比后面的大）
 65             {
 66                 if(array[i]<array[i+1])
 67                 {
 68                     int t = array[i];
 69                     array[i]=array[i+1];
 70                     array[i+1] = t;
 71                 }
 72             }
 73             
 74             //外层循环控制里程循环中比较数的个数和次数，确保每次内层循环少比较一个数（每次循环确定一个最小的数）
 75         }
 76         
 77         return array;
 78     }
 79     
 80     private static void QuickPaixu(int from,int to)
 81     {
 82         int i,j;
 83         
 84         i= from;                  //快速排序的思想是 找一个基准值，保证其左边的数据小于它 右边的数据大于它
 85         j= to;
 86         
 87         if(from > to)
 88             return ;
 89         
 90         int temp = arr[from];   //比较基准，取待比较数组的第一个点
 91         
 92         while(i!=j)
 93         {
 94             //从右边开始找第一个小于基准的数
 95             while((arr[j] >= temp)&& (j>i))  //直到找到<temp的数退出
 96                 j--;
 97             while((arr[i] <= temp) && (i<j))   //直到找到>temp的数退出
 98                 i++;
 99             
100             if(i<j)
101             {
102                 int t = arr[j];
103                 arr[j] = arr[i];
104                 arr[i] = t;
105             }
106         }
107         
108         //运行到这里i一定等于j
109         arr[from] = arr[i];
110         arr[i]=temp;
111         
112         QuickPaixu(from,i-1);
113         QuickPaixu(i+1,to);
114         
115         return ;
116     }
117 }

View Code

　　冒泡排序的基本思想：取第一个数为基准点，用移动左右指针的方式，找到右边第一个小于基准点的数，再找到左边第一个大于基准的数，运用循环，把大于基准点的数都移到右边，把小于基准点的数都移到左边，再递归此方法排序左边的数和右边的数（注意递归退出的条件）。

　　结果如下：

　　以上代码参照《啊哈！算法》。

转载于:https://www.cnblogs.com/kanite/p/7749566.html