使用JAVA直觀感覺快速排序與冒泡排序的性能差別
初學算法，確定會編寫排序算法java
其中兩個最爲有名的就是冒泡排序和快速排序node
理論上冒泡排序的時間複雜度爲O(N^2)，快速排序的時間複雜度爲O(NlogN)算法
下面本門使用JAVA，分別編寫三段排序程序xcode
-
對十萬個0-9999的整數進行一次冒泡排序數據結構
-
對十萬個0-9999的整數進行1000次快速排序，使用遞歸完成dom
-
對十萬個0-9999的整數進行1000次快速排序，使用堆棧完成函數
對十萬個0-9999的整數進行一次冒泡排序：性能
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
package
sort;
import
java.util.Date;
public
class
PopSort {
public
static
void
main(String[] args){
int
N=
100000
;
int
[] array=
new
int
[N];
for
(
int
i=
0
;i<N;i++)
array[i]=(
int
) (Math.random()*
9999
);
Date begin=
new
Date();
for
(
int
i=N-
1
;i>
1
;i--){
for
(
int
j=
0
;j<i;j++){
if
(array[j]>array[j+
1
]){
int
tmp=array[j];
array[j]=array[j+
1
];
array[j+
1
]=tmp;
}
}
}
Date end=
new
Date();
System.out.println(
"使用冒泡排序，對 "
+N+
"個整數進行排序，用時："
+String.valueOf(end.getTime()-begin.getTime())+
"毫秒"
);
for
(
int
i=
0
;i<
100
;i++)
System.out.print(array[i]+
" "
);
}
}
|
執行結果：ui
下面是使用遞歸方法的快速排序：this
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
|
package
sort;
import
java.util.Date;
public
class
QuickSort {
public
static
void
main(String[] args){
int
K=
1000
;
int
N=
100000
;
Date begin =
new
Date();
for
(
int
num=
0
;num<K;num++){
int
[] array=
new
int
[N];
for
(
int
i=
0
;i<N;i++)
array[i]=(
int
) (Math.random()*
9999
);
sort(array,
0
,array.length-
1
);
}
Date end=
new
Date();
long
time=end.getTime()-begin.getTime();
System.out.println(
"使用遞歸方式進行快速排序，對 "
+N+
"個整數進行排序 "
+K+
"次，用時："
+String.valueOf(time)+
"毫秒\n平均用時："
+time/K+
"毫秒"
);
}
private
static
void
sort(
int
[] array,
int
begin,
int
end){
int
right=end,left=begin;
while
(right!=left){
for
(;right>left;right--){
if
(array[begin]>=array[right])
break
;
}
for
(;left<right;left++){
if
(array[begin]<array[left])
break
;
}
if
(left!=right){
int
tmp=array[left];
array[left]=array[right];
array[right]=tmp;
}
else
if
(right!=begin){
int
tmp=array[begin];
array[begin]=array[left];
array[left]=tmp;
}
}
if
(left-
1
>begin)
sort(array,begin,left-
1
);
if
(right+
1
<end)
sort(array,right+
1
,end);
}
}
|
執行結果：
最後一段程序是使用數據結構棧來實現的非遞歸快速排序算法：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
|
package
sort;
import
java.util.Date;
import
java.util.Stack;
/**
* 使用棧而不是遞歸來實現快排
* @author newflydd@189.cn
* Time : 2016年1月8日 下午9:51:49
*/
public
class
QuickSort2 {
public
static
void
main(String[] args) {
Date begin =
new
Date();
Date end=
null
;
int
K=
1000
;
int
N=
100000
;
for
(
int
num=
0
;num<K;num++){
int
[] array=
new
int
[N];
for
(
int
i=
0
;i<N;i++)
array[i]=(
int
) (Math.random()*
9999
);
Stack<Node> stack=
new
Stack<Node>();
stack.add(
new
Node(
0
,N-
1
));
while
(!stack.isEmpty()){
Node node=stack.pop();
int
right=node.end , left=node.begin;
while
(right!=left){
for
(;right>left;right--)
if
(array[node.begin]>=array[right])
break
;
for
(;left<right;left++)
if
(array[node.begin]<array[left])
break
;
if
(left!=right){
int
tmp=array[left];
array[left]=array[right];
array[right]=tmp;
}
else
if
(right!=node.begin){
int
tmp=array[node.begin];
array[node.begin]=array[right];
array[right]=tmp;
}
}
if
(left-
1
>node.begin)
stack.push(
new
Node(node.begin,left-
1
));
if
(node.end>right+
1
)
stack.push(
new
Node(right+
1
,node.end));
}
}
end=
new
Date();
long
time=end.getTime()-begin.getTime();
System.out.println(
"使用數據結構棧進行快速排序，對 "
+N+
"個整數進行排序 "
+K+
"次，用時："
+String.valueOf(time)+
"毫秒\n平均用時："
+time/K+
"毫秒"
);
}
}
class
Node{
public
int
begin;
public
int
end;
public
Node(
int
begin,
int
end){
this
.begin=begin;
this
.end=end;
}
}
|
執行結果：
綜上所述，能夠直觀的看出來
-
複雜度爲O(N^2)的冒泡排序速度至關慢，一次排序就要18秒，而複雜度爲O(NlogN)的快速排序基本上20毫秒內就搞定，這就是算法的力量啊。
-
遞歸函數在這裏並不會影響性能，直觀，簡潔的遞歸算法是至關實用的，除非動態規劃算法必定要將遞歸轉變成循環，不然大多數狀況下並不須要改變遞歸方法，而非遞歸算法由於會引入其餘數據結構，有可能致使程序還會稍稍有些額外開支。
相關文章
- 1. 快速排序與冒泡排序
- 2. 快速排序，冒泡排序
- 3. 冒泡排序和快速排序
- 4. 冒泡排序+快速排序
- 5. js 冒泡排序和快速排序
- 6. 快速排序，冒泡排序算法
- 7. Java-冒泡排序、快速排序、插入排序、快速排序
- 8. JS實現快速排序，冒泡排序 JS-排序詳解-冒泡排序
- 9. 排序算法（Java筆記）—冒泡排序&快速排序
- 10. Java排序（冒泡排序、快速排序）
- 更多相關文章...
- • ADO 排序 - ADO 教程
- • PHP 數組排序 - PHP教程
- • 算法總結-歸併排序
- • Composer 安裝與使用
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. 快速排序與冒泡排序
- 2. 快速排序，冒泡排序
- 3. 冒泡排序和快速排序
- 4. 冒泡排序+快速排序
- 5. js 冒泡排序和快速排序
- 6. 快速排序，冒泡排序算法
- 7. Java-冒泡排序、快速排序、插入排序、快速排序
- 8. JS實現快速排序，冒泡排序 JS-排序詳解-冒泡排序
- 9. 排序算法（Java筆記）—冒泡排序&快速排序
- 10. Java排序（冒泡排序、快速排序）