排序算法-----插入排序和希尔排序

1 插入排序

插入排序（Insertion Sorting）的基本思想是：把 n 个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只包含一个元素，无序表中包含有 n-1 个元素，排序过程中每次从无序表中取出第一个元素，把它的排序码依次与有序表元素的排序码进行比较，将它插入到有序表中的适当位置，使之成为新的有序表。

代码：

package SortingAlgorithm;

public class InsertSortDemo {

    public static void main(String[] args) {
        int a[] =new int[] {1,5,3,4,62,356,7,34,35455,89,12};
        InsertSort(a);
        for(int i=0;i<=a.length-1;i++)
            System.out.print(a[i]+" ");
    }
    public  static  void InsertSort(int a[]) //插入排序方法
    {

        for(int i=1;i<a.length;i++)
        {
            int number=a[i]; //记录当前元素的值，因为后面这个位子会被覆盖
            int state=i-1; //要测试是否可以放的位置的下标
            for(int j=i-1;j>=0;j--) //到前面去找位置
            {
                if(a[j]>number) //前一个元素比现元素大，前者后移
                {
                    a[j+1]=a[j];
                    state--;

                }
                else //找到位置了
                {
                    break;//退出循环
                }

            }

            a[state+1]=number;//找到位子后赋值

        }




    }
}

2 希尔排序

对于普通的插入排序存在的问题;

当需要插入的数是较小的数时，后移的次数明显增多，对效率有影响

希尔排序是希尔（Donald Shell）于 1959 年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序。

 

 

package SortingAlgorithm;

import java.util.Arrays;

public class ShellSortDemo {
    public static void main(String[] args) {
        int[] arr = {8, 9, 1, 7, 2, 3, 5, 4, 6, 0};

        //逐步推到
        //希尔排序第一轮
        shellSort2(arr);
        System.out.println(Arrays.toString(arr));
      /*
      int temp;
      for(int i=5;i<arr.length;i++)
        {

            for(int j=i-5;j>=0;j-=5)
            {
                //如果当前元素大于加上步长的那个元素，说明交换
                if(arr[j]>arr[j+5])
                {
                    temp=arr[j];
                    arr[j]=arr[j+5];
                    arr[j+5]=temp;

                }
            }
        }


        System.out.println("希尔排序1轮后="+ Arrays.toString(arr));

//第二次希尔排序

        for(int i=2;i<arr.length;i++)
        {

            for(int j=i-2;j>=0;j-=2)
            {
                //如果当前元素大于加上步长的那个元素，说明交换
                if(arr[j]>arr[j+2])
                {
                    temp=arr[j];
                    arr[j]=arr[j+2];
                    arr[j+2]=temp;

                }
            }
        }


        System.out.println("希尔排序2轮后="+ Arrays.toString(arr));

        for(int i=1;i<arr.length;i++)
        {

            for(int j=i-1;j>=0;j-=1)
            {
                //如果当前元素大于加上步长的那个元素，说明交换
                if(arr[j]>arr[j+1])
                {
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;

                }
            }
        }


        System.out.println("希尔排序3轮后="+ Arrays.toString(arr));

*/

      
    }

    
    public  static  void sellSort(int arr[]) //交换法
    {
        int temp;
          for (int gap = arr.length / 2; gap > 0; gap /= 2) {

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

                for (int j = i - gap; j >= 0; j -= gap) {
                    //如果当前元素大于加上步长的那个元素，说明交换
                    if (arr[j] > arr[j + gap]) {
                        temp = arr[j];
                        arr[j] = arr[j + gap];
                        arr[j + gap] = temp;

                    }
                }
            }


        }

        System.out.println("希尔排序后="+ Arrays.toString(arr));
        
        
        
        
    }
    public static  void shellSort2(int arr[]) //移位法
    {

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

           //从第gap个元素，逐个对所在组进行插入排序
            for(int i=gap;i<arr.length;i++)
            {
                int j=i;
                int temp=arr[j];
                if(arr[j]<arr[j-gap])
                {
                    while(j-gap>=0&&temp<arr[j-gap])
                    {
                        //移动
                        arr[j]=arr[j-gap];
                        j-=gap;
                    }
                    //当推出循环，找到了插入的位置
                    arr[j]=temp;
                }
            }


        }




    }
}