数据结构中
8
大排序（java方式实现）
*
* 冒泡排序
* 插入排序
* 选择排序
* shell排序
* 堆排序
* 归并排序
* 二叉树排序
* 快速排序
* 冒泡排序
private
void
bubblesort() {
int
data [] = create();
print (data );
long
start = start ();
for
(
int
i =
0
; i< data .length -
1
; i ++){
for
(
int
j =i +
1
; j <data . length; j ++){
if
( data [i ]> data[ j ])
swap (i , j, data );
}
}
end (start ,
"冒泡"
);
print (data );
}
private
void
swap(
int
i ,
int
j ,
int
[] data ) {
int
temp =
0
;
temp = data[ i ];
data [ i] = data [ j];
data [ j] = temp ;
}
public
static
long
start (){
return
System.currentTimeMillis ();
}
public
static
void
end (
long
start , String str ){
long
end = System.currentTimeMillis();
System . out. println (str +
"排序花费的时间 = "
+( end- start ));
}
static
int
[] create () {
int
array [] =
new
int
[
1000
];
for
(
int
i =
0
; i<
1000
; i ++){
try
{
Thread . sleep(
1
);
}
catch
(InterruptedException e ) {
// TODO Auto-generated catch block
e . printStackTrace();
}
array [ i] =
new
Random (). nextInt(
100000
);
}
return
array;
}
* 插入排序
private
void
insertsort() {
int
data [] = create();
print (data );
long
start = start ();
int
temp =
0
, j =
0
;
for
(
int
i =
0
; i< data .length ; i++){
temp = data[ i ];
j = i-
1
;
while
( j >=
0
&& data[ j ]>temp ){
data [ j+
1
] = data[ j ];
j --;
}
data [ j+
1
] = temp;
}
end (start ,
"插入"
);
print (data );
}
* 选择排序
private
void
selectsort() {
int
data [] = create();
print (data );
int
k =
0
;
long
start = start ();
for
(
int
i =
0
; i< data .length -
1
; i ++){
k = i;
for
(
int
j =i +
1
; j <data . length; j ++){
if
( data [k ]> data[ j ]){
k = j;
}
}
swap (i , k, data );
}
end (start ,
"选择"
);
print (data );
}
* shell 排序
private
void
shellsort() {
int
data [] = create();
print (data );
long
start = start ();
int
j =
0
;
int
temp =
0
;
int
gap =
0
;
int
n = data . length;
while
( gap <data . length){
gap = gap*
3
+
1
;
}
while
( gap >
0
){
for
(
int
i =gap ; i< n ; i ++){
j = i- gap ;
temp = data[ i ];
while
( j >=
0
&& data[ j ]>temp ){
data [ j+ gap ] = data[ j ];
j = j- gap ;
}
data [ j+ gap ] = temp;
}
gap = ( gap -
1
)/
3
;
}
print (data );
end (start ,
"shell"
);
}
* 堆排序
public
void
heapsort() {
int
data [] = create();
print (data );
long
start = start ();
crateheap (data );
for
(
int
i =data . length-
1
; i >=
1
; i --){
swap (i ,
0
, data );
heapfiy (data ,
0
, i );
}
end (start ,
"堆"
);
print (data );
}
private
void
crateheap(
int
[] data ) {
int
n = data . length;
for
(
int
i =n /
2
-
1
; i >
0
; i --){
heapfiy (data , i, n );
}
}
private
void
heapfiy(
int
[] data ,
int
i,
int
n ) {
int
left = i *
2
+
1
;
int
right = i *
2
+
2
;
int
large =
0
;
if
( left <n && data[ left ]>data [ i])
large = left;
else
large = i;
if
( right <n && data[ right ]>data [ large])
large = right;
if
( large !=i ){
swap (large , i, data );
heapfiy (data , large, n );
}
}
* 归并排序
public
void
mergesort() {
int
data [] = create();
print (data );
long
start = start ();
merge (data ,
0
, data .length -
1
);
end (start ,
"归并"
);
print (data );
}
public
void
merge(
int
data [],
int
low ,
int
high){
int
mid = ( low+ high )/
2
;
if
( low <high ){
merge (data , low, mid );
merge (data , mid+
1
, high );
merge1 (data , low, mid , high );
}
}
private
void
merge1(
int
[] data ,
int
low,
int
mid ,
int
high ) {
int
temp [] =
new
int
[ high -low +
1
];
int
i = low ;
int
j = mid +
1
;
int
k =
0
;
while
( i <=mid && j<= high ){
if
( data [i ]< data[ j ]){
temp [ k++] = data [ i++];
}
else
{
temp [ k++] = data [ j++];
}
}
while
( i <=mid ){
temp [ k++] = data [ i++];
}
while
( j <=high ){
temp [ k++] = data [ j++];
}
for
(
int
k2 =
0
; k2< temp .length ; k2++){
data [ k2+ low ] = temp[ k2 ];
}
}
* 二叉树排序
public
class
BinaryTree {
int
data ;
//根节点数据
BinaryTree left ;
//左子树
BinaryTree right ;
//右子树
public
BinaryTree(
int
data)
//实例化二叉树类
{
this
. data = data ;
left =
null
;
right =
null
;
}
public
void
insert( BinaryTree root,
int
data ){
//向二叉树中插入子节点
if
( data >root . data)
//二叉树的左节点都比根节点小
{
if
( root .right ==
null
){
root . right =
new
BinaryTree( data );
}
else
{
this
. insert (root . right, data );
}
}
else
{
//二叉树的右节点都比根节点大
if
( root .left ==
null
){
root . left =
new
BinaryTree( data );
}
else
{
this
. insert (root . left, data );
}
}
}
}
public
static
void
inOrder( BinaryTree root ){
if
( root !=
null
){
inOrder (root . left);
System . out. print (root . data+
"--"
);
inOrder (root . right);
}
}
* 快速排序
public
void
quicksort() {
int
data [] = create();
print (data );
long
start = start ();
quick1 (data ,
0
, data .length -
1
);
end (start ,
"快速"
);
print (data );
}
public
int
[] quick1 (
int
data [],
int
left,
int
right ){
int
mid ;
if
( left <right ){
mid = quick ( data, left , right );
quick1 (data , left, mid -
1
);
quick1 (data , mid+
1
, right );
}
return
data;
}
private
int
quick(
int
[] data ,
int
left,
int
right ) {
int
mid = data [ left];
while
( left <right ){
while
( left <right && data[ right ]>=mid )
right --;
data [ left] = data [ right];
while
( left <right && data[ left ]<=mid )
left ++;
data [ right] = data [ left];
}
data [ left] = mid ;
return
left;
}
803
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
