数据结构之直接插入排序算法

1.最近没得事，准备重新在学习一遍数据结构，今天就先学习下直接插入排序算法和希尔排序，说实在的这些长时间没有的确忘记了不少，书我也是看了半天才看懂的，在此记录下。

2.直接插入排序算法：

这个算法很简单，不过大部分博客讲的很繁琐。在这里以整数数组A来说。A的数据如下。

{12,15,9,20,6,31,24},要给这组数据排序，假如用直接排序算法思路是这样的。

从这组数据的第二个元素开始遍历：也就说  i=1; 当前元素的大小是A[i], 用这个元素的前一个元素也就是A[i-1]和 A[i]作比较。当A[i-1]<A[i]，那么进行下一个遍历，也就是continue； 当A[i-1]>A[i]的时候， 将A[i]与之前所有的元素相比，大于A[i]的话，就将这个元素后移一位，把A[i]前移动一位。这样经过一个完整的遍历，就会得到顺序值。

因为涉及到俩个元素相互换位置，所以要因为第三方变量t，考虑到空间问题，A数据的值要空出来也就是A[0]的值，空出来，我们可以设置成-1，那么后面当A[i-1]>A[i]的时候，把A[i]的值，保存到A[0]中这样。也后只需要因为A[0]。不用额外设置第三方变量int  t。

完整代码如下：

public class Test1 {

	int []a={-1,12,15,9,20,6,31,24};//a[0]故意设置成-1的
	public void InsertSort() 
	{
		int i,j;
		for(i=2;i<a.length;i++)
		{
			if(a[i]<a[i-1])
			{
				a[0]=a[i];
				for(j=i-1;a[j]>a[0];j--)
				{
					a[j+1]=a[j];
					a[j]=a[0];
				}
			}
		}
		for(int n=1;n<a.length;n++)
		{
			System.out.println(a[n]);
		}
	}
	public static void main(String arsg[])
	{
		Test1 t=new Test1();
		t.InsertSort();
	}

}

直接插入排序算法：

空间复杂度：O（1）因为占用了一个A[0]空间。

时间复杂度: 最好的情况O(n)

      最坏的情况O(n^2)

      平均复杂度:O(n^2)
     算法稳定。

3,希尔排序算法：

我来解释下这个图的意思：

待排序的序列有;10个数，d=10/2=5，

分组为：(9,4)，9和4之间的数，都要去5个间隔分为一组，也就是说：(1,8),(2,6),(5,3),(7,5)都是分的组，将每个组排序于是就可与 第二趟起始的排列顺序

第二趟的d=d/2=2. 因此分组（4,2，5,8,7）,4和2中间的数 1.也要划分为一组，也就是(1,3,9,6,7).总共就是这俩组，将这俩组排序。就会得到突然第三趟的排序。

第三趟的d=d/2=1  ，则将(2,1,4,3,5,6,5,7,8,9)作为一组，然后排序。最后得到的结果就是顺序的。

每组之间采用的排序方法为：直接插入法排序。

这是希尔排序的定义：

希尔排序（shell sort）是对直接插入排序的改进。

基本思想：先将整个记录分割成若干个子序列，在子序列内分别进行直接插入排序，待整个序列基本有序时，再对全部记录进行一次直接插入排序。

下面是我写的希尔排序代码,有点复杂，有些博客在得到分组的时候，用list集合将分组的数据保存起来，然后直接调用直接插入算法。这样做起来，思维清楚但是，占用的内存比较多。我这里做的没有引用一个list集合，直接在原始的数据中操作。

代码如下：

public class Test3 {

	int []l={-1,1,2,3,4};
	public static void main(String arsg[])
	{
		Test3 t=new Test3();
		t.InsertSort(t.l.length-1);
	}

	private void InsertSort(int d) {
		int d1=d/2;
		//d为数据的长度，也就是说d=
		while(d1>0)
		{
			for(int i=1;i<l.length;i++)
			{
				int n=(l.length-1-i)/d1;
				int y=n*d1+i;
				for(i=i+d1;i<=y;i=i+d1)
				{
					if(l[i]>=l[i-d1])
					{
						continue;
					}
					else{
						l[0]=l[i];
						int x=i;
						while(x-d1>0)
						{
							if(l[x-d1]>l[0])
							{
								l[x]=l[x-d1];
								l[x-d1]=l[0];
							}
							x=x-d1;
						}
					}
				}
			}
			d1=d1/2;
		}
		
		for(int n=1;n<l.length;n++)
		{
			System.out.println(l[n]);
		}
	}
}

正如前面直接插入排序算法中说到的一样。希尔排序中，数组第一个元素值为-1,充当哨兵的作用。

时间复杂度：   研究表明，希尔排序的时间性能在O(n2)和O(nlog2n)之间。当n在某个特定范围内，希尔排序所需的比较次数和记录的移动次数约为O(n1.3 ) 。

空间复杂度：   希尔排序只需要一个辅助空间：O(1 ) 。

算法的稳定性：希尔排序为不稳定排序方法，因为比较记录是跳跃 。

掌握直接插入算法，才能进一步掌握希尔算法。