排序算法第一篇(简单桶排、选择排序、冒泡排序、快速排序)

简单桶排序

 1 /**
 2  * @author: 攻城狮小白
 3  * @creationTime:2017年11月24日 下午10:37:59
 4  * @description: 桶排序(这个不是真正的桶排，真正的桶排比这个稍微复杂些。但是是桶排的思想，就叫它简单桶排吧)
 5  * @questionDesc:一个班上有6名同学，考试成绩如下arr数组(满分10分)，如何快速将学生成绩从小到大排列？
 6  */
 7 public class BucketSortDemo {
 8     public void bucketSort(int[] arr){
 9         int[] array = new int[11];
10         for (int i = 0; i < arr.length; i++) {
11             array[arr[i]]++;
12         }
13         System.out.print("简单桶排输出：");
14         for (int i = 0; i < array.length; i++) {
15             for(int j=0; j<array[i]; j++){
16                 System.out.print(i + " ");
17             }
18         }
19     }
20     public static void main(String[] args) {
21         int[] arr = {5,3,9,5,2,8};
22         new BucketSortDemo().bucketSort(arr);;
23     }
24 }

选择排序

 1 import java.util.Arrays;
 2 /**
 3  * @author: 攻城狮小白
 4  * @creationTime:2017年11月24日 下午10:39:06
 5  * @description: 选择排序(此处按照升序实现,降序只需将>改为<即可)
 6  */
 7 public class SelectionSortDemo {
 8     public void selectionSort(int[] arr){
 9         int temp;
10         int n = arr.length;
11         for(int i=0; i<n-1; i++){
12             for(int j=i+1; j<n; j++){
13                 if(arr[i] > arr[j]){
14                     temp = arr[i];
15                     arr[i] = arr[j];
16                     arr[j] = temp;
17                 }
18             }
19         }
20         System.out.println("选择排序输出：" + Arrays.toString(arr));
21     }
22     public static void main(String[] args) {
23         int[] arr = {6,2,1,7,9,3,4,5,0,8};
24         new SelectionSortDemo().selectionSort(arr);
25     }
26 }

冒泡排序

 1 /**
 2  * @author: 攻城狮小白
 3  * @creationTime:2017年11月24日 下午10:38:40
 4  * @description: 冒泡排序(此处按照升序实现,降序只需将>改为<即可)
 5  */
 6 public class BubbleSortDemo {
 7     public void bubbleSort(int[] arr){
 8         int temp;
 9         int n = arr.length;
10         for(int i=0; i<n-1; i++){
11             for(int j=0; j<n-1-i; j++){
12                 if(arr[j] > arr[j+1]){
13                     temp = arr[j];
14                     arr[j] = arr[j+1];
15                     arr[j+1] = temp;
16                 }
17             }
18         }
19         System.out.println("冒泡排序输出：" + Arrays.toString(arr));
20     }
21     public static void main(String[] args) {
22         int[] arr = {6,2,1,7,9,3,4,5,0,8};
23         new BubbleSortDemo().bubbleSort(arr);
24     }
25 }

快速排序

 1 import java.util.Arrays;
 2 /**
 3  * @author: 攻城狮小白
 4  * @creationTime:2017年11月24日 下午10:32:47
 5  * @description: 快速排序：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，
 6  *                       然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
 7  *               通俗的讲：就是在数组中随便选择一个目标数(一般都选arr[0]比较好理解)，然后拿两个变量i和j分别放到数组索引的0位置
 8  *                       和length-1的位置，然后将小于目标数的都放到左边，大于目标数的都放到右边，经过该操作后就找到了目标数的
 9  *                       位置，然后将目标数放到该位置。此时原数组就会被目标数分为两个数组，再递归按照上面的步骤进行，最终就能将原
10  *                       整个数组变成有序序列。
11  */
12 public class QuickSortDemo {
13     public void quickSort(int[] arr, int left, int right){
14         if(left>=right){
15             return;
16         }
17         int i = left;
18         int j = right;
19         int target = arr[left];
20         while(i<j){
21             while(arr[j] >= target && j>i){
22                 j--;
23             }
24             while(arr[i] <= target && i<j){
25                 i++;
26             }
27             //一般情况下都是走这个分支，交换两个数的位置，将大于基准数的放后面，小于基准数的放前面
28             if(i != j){
29                 int temp;
30                 temp = arr[j];
31                 arr[j] = arr[i];
32                 arr[i] = temp;
33             }
34         }
35         //跳出上面外层循环的条件就是i刚好等于j,需要将目标数和当前ij所在位置(表示同一个位置)的数进行交换
36         if(i == j){
37             arr[left] = arr[i];
38             arr[i] = target;
39         }
40         quickSort(arr, left, i-1);
41         quickSort(arr, i+1, right);
42     }
43     public static void main(String[] args) {
44         int[] arr =  {6,2,1,7,9,3,4,5,0,8};
45         QuickSortDemo quickSortDemo = new QuickSortDemo();
46         quickSortDemo.quickSort(arr, 0, arr.length-1);
47         System.out.println("快排输出结果：" + Arrays.toString(arr));
48     }
49 }