希尔排序算法（Shell Sort） Java实现

希尔排序（Shell Sort）

是对直接插入排序改进后的版本，可以增加效率

所谓基本有序，就是小的关键字基本在前面，大的基本在后面，不大不小的基本在中间。

将相距某个“增量”的记录组成一个子序列，这样才能保证在子序列内分别进行直接插入排序后得到的结果是基本有序而不是局部有序

import java.util.Arrays;
import java.util.Random;

/**
 * 希尔排序算法
 *
 *是直接插入排序的变种，只不过直接插入排序增量一开始就是1
 */
public class ShellSort {
    
    public void shellSort(int[] arrNative) {
        
        int[] arr = new int[arrNative.length + 1];
        System.arraycopy(arrNative, 0, arr, 1, arrNative.length);
        
        // 增量
        int increment = arrNative.length;
        
        do {
            // 增量序列
            increment = increment/3 + 1;
            
            for (int i = increment + 1; i < arr.length; i++) {
                
                if (arr[i] < arr[i - increment]) {
                    arr[0] = arr[i];
                    
                    int j;
                    for (j = i - increment; j > 0 && arr[0] < arr[j]; j-=increment)
                        arr[j + increment] = arr[j];
                    
                    arr[j + increment] = arr[0];
                    
                }
            }
        } while (increment > 1);
        
        System.arraycopy(arr, 1, arrNative, 0, arrNative.length);
        
        System.out.println(Arrays.toString(arrNative));
    }
    
    public static void main(String[] args) {
//        int[] arr = new int[]{9, 1, 5, 8, 3, 7, 4, 6, 2};
        int[] arr = new int[10];
        
        Random ran = new Random();
        for (int i = 0; i < arr.length; i++) {
            arr[i] = ran.nextInt(50);
        }
        
        System.out.println(Arrays.toString(arr));
        new ShellSort().shellSort(arr);
    }

}