JAVA数据结构--插入排序

插入排序（英语：Insertion Sort）是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

算法描述

一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：

1. 从第一个元素开始，该元素可以认为已经被排序
2. 取出下一个元素，在已经排序的元素序列中从后向前扫描
3. 如果该元素（已排序）大于新元素，将该元素移到下一位置
4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
5. 将新元素插入到该位置后
6. 重复步骤2~5

如果比较操作的代价比交换操作大的话，可以采用二分查找法来减少比较操作的数目。该算法可以认为是插入排序的一个变种，称为二分查找插入排序。

    　　　　　　　　

　　时间复杂度：O（n^2）

　　最优时间复杂度：O（n）

---

Weiss书算法实现

 package DataStructures;

 import java.util.Arrays;

 public class InsertionSort {
     public static void main(String[] args) {
         Integer nums[]=new Integer[]{45,1,22,15,6,3,7,5,14};
         insertionsort(nums);
         System.out.println("Last is: "+Arrays.toString(nums));
     }
     public static <AnyType extends Comparable<? super AnyType>>
     void insertionsort(AnyType[] a){
         int j;
         for(int p=1;p<a.length;p++){
             AnyType tmp=a[p];
             for(j=p;j>0&&tmp.compareTo(a[j-1])<0;j--)    //逐一递减对比
                 a[j]=a[j-1];    //后移一项
             a[j]=tmp;    //插入替换
             System.out.println(p+"th  is: "+Arrays.toString(a));
         }
     }
 }

output:

1th  is: [1, 45, 22, 15, 6, 3, 7, 5, 14]
2th  is: [1, 22, 45, 15, 6, 3, 7, 5, 14]
3th  is: [1, 15, 22, 45, 6, 3, 7, 5, 14]
4th  is: [1, 6, 15, 22, 45, 3, 7, 5, 14]
5th  is: [1, 3, 6, 15, 22, 45, 7, 5, 14]
6th  is: [1, 3, 6, 7, 15, 22, 45, 5, 14]
7th  is: [1, 3, 5, 6, 7, 15, 22, 45, 14]
8th  is: [1, 3, 5, 6, 7, 14, 15, 22, 45]
Last is: [1, 3, 5, 6, 7, 14, 15, 22, 45]

算法实现（JAVA）

 public class InsertionSort {
     public static void main(String[] args){
         int []elem={3,4,12,6,87,1,22,45,5};
         InsertionSort insertionSort=new InsertionSort();
         insertionSort.sort(elem);
         for(int i=0;i<elem.length;i++)
             System.out.print(elem[i]+" ");
     }
     public int[] sort(int[] elem){
         for(int i=1;i<elem.length;i++){
             for(int j=i-1;j>=0;j--){
                 if(elem[j]>elem[i]){
                     int temp=elem[j];
                     elem[j]=elem[i];
                     elem[i]=temp;
                     i--;
                 }
             }
         }
         return elem;
     }
 }