码迷,mamicode.com
首页 > 编程语言 > 详细

常见排序算法——希尔排序

时间:2019-12-17 13:02:22      阅读:108      评论:0      收藏:0      [点我收藏+]

标签:sys   xtend   插入排序   复杂度   ||   ble   shell   pack   归并   

希尔排序:

希尔排序是对插入排序的优化,将插入排序的交换步长由1增加到h。
希尔排序的思想是使数组中任意间隔为h的元素有序。步长调幅为h = 3*h + 1, 也就是1,4,13,40,121,364, 1003....这种步长算法是经过论文证明为比较高效的步长。
最开始由最大步长开始排序,最大步长为
while(h < n/3) h = 3*h +1
步长最大时,比较的元素非常少,速度很快
后来步长逐渐缩短,比较的元素越来越多,但是此时元素的有序性也变好了,排序速度还是会很快。
while(h>=1){
  for: i from h~n{
    for: j from i~h,j = j-h;
      比较a[j]和a[j-h],并根据比较结果交换元素位置,
  }
}
 

实现代码:()
import java.util.Arrays;

import java.util.Random;

 

public class ShellSort {

1.这是定义了一个公共的(public)静态的(static )泛型方法
其中<AnyType extends Comparable<? super AnyType>>是泛型的类型,定义类型只能是Comparable或Comparable的子类,并且Comparable也是一个泛型类他的 类型只能是AnyType或是AayType的超类也就是AayType父类
int 是方法的返回类型
(AnyType[] a,AnyType x)参数列表,第一个是传递进来的数组第二个是一个值,也就是查找该值在数组中的下标,他们的类型都是该泛型方发传进来的类型
public static <AnyType extends Comparable<? super AnyType>>

void shellSortOnce(AnyType a[]){

AnyType temp;

if((a==null)||(a.length==0)){

return ;

}

for(int gap = a.length /2 ; gap > 0 ;gap = gap /2){

for(int i = gap ; i<a.length; i++){

AnyType tmp = a[i];

int j = i;

for( ; j >= gap && tmp.compareTo(a[j - gap]) < 0 ; j -= gap){

a[j] = a[j-gap];

}

a[j] = tmp ;

}

}

}

public static void main(String[] args){

Random rand = new Random();

Integer[] arr = new Integer[10];

for(int i = 0 ;i <10 ;i++){

arr[i] = rand.nextInt(1000);

}

println(Arrays.toString(arr));

shellSortOnce(arr);

println(Arrays.toString(arr));

}

public static void println(String str){

System.out.println(str);

}
}
}

import java.util.Arrays;

 

import com.edu.hpu.sort.Sort;

 

public class ShellSort extends Sort {

 

@Override

public int[] doSort(int[] arr) {

int len = arr.length;

// 所有的步长可能性(首次为数组长的一半,接下来每次为上一次的一半)
for (int gap = len / 2; gap > 0; gap /= 2) {

// 将步长中的所有元素进行插入排序
for(int w = 0; w < gap; w++){

// 步长为gap的插入排序

// 对照插入排序
/*
* for(int i = p + 1; i < r; i++){

* int key = arr[i];

* int j = i - 1;

* while(j >= 0 && arr[j] > key) {

* arr[j + 1] = arr[j];

* j--;

* }

* arr[j + 1] = key;

* }

*/
for (int i = gap + w; i < len; i += gap) {

// 插入排序
int key = arr[i];

int j = i - gap;

while (j >= 0 && arr[j] > key) {

arr[j + gap] = arr[j];

j -= gap;

}

arr[j + gap] = key;

}

}

System.out.println(Arrays.toString(arr));

}

return arr;

}

 

public static void main(String[] args) {

Sort sort = new ShellSort();

sort.printOrder(new int[] {100, 201, 999, 4, 1, 3, 2, 16, 9, 100, 194, 8, 7, 0, 90 });

}
}
}

 

 

package www.jk.shell;

import java.util.Arrays;

public class Test {

/**
* @author jk,这个代码写的是shell排序,其实我个人认为这个排序的思想是把归并和快排的思想结合起来,快排是通过
* 第一个元素来进行左右划分,归并是无论什么样,先将数组分成两组,然后继续分最后结合起来,这个shell排序,首先是将数组
* 分为两组,然后进行插入,其实就类似将大的或者小的先放在前面或者后面,所以,我认为这个算法的复杂度应该和归并和快排是差不多的
*
*/
public static void main(String[] args) {
int[] a = { 1, 4, 2, 0, 8, 6, 4, 6 };
shellSort(a);
// 输出排序后的数组
System.out.println(Arrays.toString(a));

}

private static void shellSort(int[] a) {
// 将数组分组
for (int r = a.length / 2; r >= 1; r /= 2) {
// 这里的思路和插入排序的思路相同,通过找到前一个的数大于或者小于来进行插入
for (int i = r; i < a.length; i += r) {
int temp = a[i];
int j = i - r;
while (j >= 0 && temp < a[j]) {
a[j + r] = a[j];
j -= r;
}
a[j + r] = temp;
}
}

}

}

常见排序算法——希尔排序

标签:sys   xtend   插入排序   复杂度   ||   ble   shell   pack   归并   

原文地址:https://www.cnblogs.com/sdx-BK/p/12053772.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!