1. package com.itheima;
   
2. 
   
3. /**
   
4. * 第3题： 请列举您了解的一些排序算法，并用Java语言实现一个效率较高的。
   
5. *
   
6. * 目前了解的排序方法有冒泡排序、选择排序、插入排序和快速排序
   
7. *
   
8. * @author hp-pc
   
9. * */
   
10. public class Test3
    
11. {
    
12.         public static void main(String[] args)
    
13.         {
    
14.                 // 定义一个int数组并且初始化
    
15.                 int[] arr =
    
16.                 { 23, 45, 12, 9, 78, 26 };
    
17.                 System.out.println("冒泡排序：");
    
18.                 bubbleSort(arr);
    
19.                 print(arr);
    
20.                 System.out.println("\n---------------------");
    
21.                 System.out.println("选择排序：");
    
22.                 selectSort(arr);
    
23.                 print(arr);
    
24.                 System.out.println("\n---------------------");
    
25.                 System.out.println("插入排序");
    
26.                 insertSort(arr);
    
27.                 print(arr);
    
28.                 System.out.println("\n---------------------");
    
29.                 System.out.println("快速排序");
    
30.                 quickSort(arr, 0, arr.length - 1);
    
31.                 print(arr);
    
32. 
    
33.         }
    
34. 
    
35.         // 冒泡排序
    
36.         public static void bubbleSort(int[] arr)
    
37.         {
    
38.                 for (int i = 0; i < arr.length - 1; i++)
    
39.                 {
    
40.                         for (int j = 0; j < arr.length - i - 1; j++)
    
41.                         {
    
42.                                 if (arr[j] > arr[j + 1])
    
43.                                         swap(arr, j, j + 1);
    
44.                         }
    
45.                 }
    
46. 
    
47.         }
    
48. 
    
49.         // 选择排序
    
50.         public static void selectSort(int[] arr)
    
51.         {
    
52.                 for (int i = 0; i < arr.length - 1; i++)
    
53.                 {
    
54.                         for (int j = i + 1; j < arr.length; j++)
    
55.                         {
    
56.                                 if (arr[i] > arr[j])
    
57.                                         swap(arr, i, j);
    
58.                         }
    
59.                 }
    
60.         }
    
61.        
    
62.         // 插入排序
    
63.                 public static void insertSort(int[] a)
    
64.                 {
    
65.                         for (int i = 1; i < a.length; i++)
    
66.                         {
    
67.                                 int temp = a[i];// 待插入的值
    
68.                                 int index = i;// 待插入的位置
    
69.                                 while (index > 0 && a[index - 1] > temp)
    
70.                                 {
    
71.                                         a[index] = a[index - 1];// 把更大的值赋给待插入的位置，待插入的位置是移动的
    
72.                                         index--;// 待插入位置前移
    
73.                                 }
    
74.                                 a[index] = temp;
    
75.                         }
    
76.                 }
    
77. 
    
78. 
    
79.         // 快速排序
    
80.         public static int partition(int a[], int low, int height)
    
81.         {
    
82.                 int key = a[low];
    
83.                 while (low < height)
    
84.                 {
    
85.                         while (low < height && a[height] >= key)
    
86.                                 height--;
    
87.                         a[low] = a[height];
    
88.                         while (low < height && a[low] <= key)
    
89.                                 low++;
    
90.                         a[height] = a[low];
    
91.                 }
    
92.                 a[low] = key;
    
93.                 return low;
    
94.         }
    
95. 
    
96.         public static void quickSort(int a[], int low, int height)
    
97.         {
    
98.                 if (low < height)
    
99.                 {
    
100.                         int result = partition(a, low, height);
     
101.                         quickSort(a, low, result - 1);
     
102.                         quickSort(a, result + 1, height);
     
103.                 }
     
104.         }
     
105. 
     
106.         // 定义一个交换变量值的函数
     
107.         public static void swap(int[] arr, int x, int y)
     
108.         {
     
109.                 int temp = arr[x];
     
110.                 arr[x] = arr[y];
     
111.                 arr[y] = temp;
     
112.         }
     
113. 
     
114.        
     
115.         // 打印函数
     
116.         public static void print(int[] arr)
     
117.         {
     
118.                 System.out.print("{");
     
119.                 for (int i = 0; i < arr.length; i++)
     
120.                 {
     
121.                         if (i == arr.length - 1)
     
122.                                 System.out.print(arr[i] + "}");
     
123.                         else
     
124.                                 System.out.print(arr[i] + ",");
     
125.                 }
     
126.         }
     
127. }
     

复制代码

Mark，看看。

小黑子 发表于 2014-8-23 22:15
Mark，看看。

:handshake，哥们要去哪一期？？？该面试了吧

男人你得有范 发表于 2014-8-23 22:16
，哥们要去哪一期？？？该面试了吧

没有，还不确定呢，基础视频才看一半

不错，支持下

不错！！！！

快速法比较难搞

挺好。。。。

楼主上图学习下啊

楼主够认真详细的！收藏ing