Java算法总结（4）_插值排序

1、常用的比较排序

  本章作为排序算法的初篇，首先给大家介绍插入类排序，它包括：直接插入排序、二分插入排序、希尔排序。由于个人觉得二分插入排序的选址作用性不大，所以就不对它进行阐述。

2、直接插入排序

2.1 原理

  从左往右依次不明显地交换元素，在每次移动元素时都保证元素前已处于排序过的状态；

2.2 算法分析

1、 时间复杂度：

• 最坏：O(N2)；
• 最好：O(N);
• 平均：O(N2)

2、 空间复杂度：O(1);
3、 稳定排序；

2.3 动态图解

2.4 直接插入Java代码

/**
	 * 插值排序法
	 * @param <T>
	 * @param a
	 */
	public static <T extends Comparable<? super T>> void insertionSort(T[] a) {
		int j;
		//从第二个开始遍历排序
		for (int i = 1; i < a.length; i++) {
			T temp = a[i];//哨兵
			//不明显的交换
			for ( j = i; j>0&&temp.compareTo(a[j-1])<0; j--) {
				a[j] = a[j-1];
				
			}
			a[j]=temp;
		}
	}

3 希尔排序

3.1 原理

  根据直接插入排序的特点：数组越短，数据越有序，排序时间就越短，Donald Shell采用增量序列对原始数组进行分组，通过比较一定间隔的元素来工作，使得各趟比较所用的距离随着算法的进行而减小，直到只比较相邻元素的最后一趟元素为止；

3.2 算法分析

1. 增量数列h1、h2、h3、h4……其中h1必须为1，Shell建议的序列:
   

2. 时间复杂度：最坏：O(N2);最好：O(N);平均：O(N1.3)

3. 空间复杂度：O(1);

4. 不稳定排序；

3.3 动态图解

3.4 希尔排序Java代码

/**
	 * 希尔排序
	 * @param <T>
	 * @param a
	 */
	public static <T extends Comparable<? super T>> void shellSort(T[] a) {
		//最外层为间隔gap的增量序列
		for (int gap = a.length/2; gap>0; gap/=2) {
			int j;
			//插值法
			for (int i = gap; i < a.length; i++) {
				T temp=a[i];
				for ( j = i; j>=gap&&temp.compareTo(a[j-1])<0; j-=gap) {
					a[j] = a[j-gap];
					
				}
				a[j]=temp;
			}
			
		}
	}

4 算法测试

package xw.zx.algorithm.sort;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class SortTest {
	private static final int ARRAY_LEN=100;
	private static Integer[] arr=new Integer[ARRAY_LEN];
	public static void main(String[] args) {
		List<Integer> l=new ArrayList<>();
		for (int i = 0; i < ARRAY_LEN; i++) {
			l.add(i+1);			
		}
		Collections.shuffle(l);
		arr=l.toArray(new Integer[0]);
		System.out.println("输出原数组");
		printVal(arr);
		AllSorts.shellSort(arr);
		System.out.println("输出排序后的数组");
		printVal(arr);
	}
	/**
	 * 打印数组
	 * @param arr
	 */
	private static void printVal(Integer[] arr) {
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i]+" ");
			
		}
		System.out.println("");
	}
}