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

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

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

　　结果如下：



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