插入排序(直接插入排序-折半插入-希尔排序)(java)全家桶

插入排序详解

最新推荐文章于 2024-04-22 22:14:32 发布

原创最新推荐文章于 2024-04-22 22:14:32 发布 · 102 阅读

0 ·

CC 4.0 BY-SA版权

java基础同时被 2 个专栏收录

11 篇文章

订阅专栏

算法

5 篇文章

订阅专栏

本文详细介绍了插入排序的不同变种，包括直接插入排序、折半插入排序和希尔排序等，并提供了具体的实现代码示例。

插入排序

1直接插入排序----具有稳定性–O(n)-O(n2)

假设第一个元素已经排好序,用需要插入的元素和前面已经排好序的元素比较,找的第一个(强调第一个是为了保证稳定性)小于它的元素,插入到这个元素的前面.
建立在元素基本有序,数据量不大的情况下,

2希尔排序----不具有稳定性-----O(n)-O(n1.3)

最大的时间复杂度是数学上的一个难题,没解决出来,在n为一个稳定的范围时,接近n的1.3次方.

又称缩小增量排序

为了解决数据量比较大,元素无序问题,引入希尔排序,把一个表依据增量序列d划分成若干个子表,先使得这些个子表有序,然后再对全体记录进行一次直接插入排序

直接插入排序


            //插入排序
    public static void InsertSort(int[] A, int n) {
        int j;
        int temp;
        for (int i = 1; i < n; i++) {
            if (A[i] < A[i-1]) {
                temp = A[i];

				//while(A[j]>temp &&j>=0){
                
               		 	//A[j+1] = A[j];
                		//j--
           		 //}
                for (j = i - 1; j >= 0 && A[j] > temp; j--) {
                    A[j+1] = A[j];
                }
                A[j + 1] = temp;
            }
        }

折半直接插入排序O(n)-O(n2)

//折半

        public static void binInsertSort2(int[] A){
        int j =0;

            for (int i = 1; i < A.length; i++) {
                if(A[i]<A[i-1]){
                     int temp = A[i];
                    int low =0;
                    int high = i-1;
                    while (low <= high) {
                        int mid = (low +high) / 2;
                        if(A[mid]>=temp){
                            high = mid -1;
                        }else{
                            low = mid + 1;
                        }
                    }
                    for (j = i-1; j>=low; --j) {
                        A[j+1] = A[j];
                    }

                    A[low] = temp;
               }
            }

        }

希尔排序

希尔排序----不具有稳定性-----O(n)-O(n1.3)**

又称缩小增量排序

为了解决数据量比较大,元素无序问题,引入希尔排序,把一个表依据增量序列d划分成若干个子表,先使得这些个子表有序,然后再对全体记录进行一次直接插入排序

  //希尔1
    public static void shellSort(int[] A,int n){
        int d ,j,temp = 0;
        for(d=n/2;d>=1;d = d/2){
            //这个 i= d,不等于d+1,和王道不一样,
            for (int i = d; i <n ; i++) {
                if(A[i]<A[i-d]) {
                    temp = A[i];

                    for (j = i - d; j >=0 && A[j] > temp; j = j - d) {
                        A[j + d] = A[j];

                    }
                    A[j + d] = temp;
                }//if

            }

        }






//希尔2
        public static void shell2(int[]A,int n){
        int j;
            for(int d= n/2;d>=1;d= d/2){
                for(int i = d;i<n;i++){
                    if(A[i] <A[i-d]) {
                        int temp = A[i];

                        for (j = i - d; j >= 0 && A[j] > temp;j = j- d){
                            A[j +d] = A[j];
                        }
                        A[j+d] = temp;
                    }
                }

             }
        }

总的插入排序(3个—例子)

package Demo01;

public class demo02 {
    public static void main(String[] args) {
        int[] A = new int[]{21, 3, 54, 4,7, 64,9, 3};
        shellSort(A,A.length);
        for (int a : A
        ) {
            System.out.print(a +",");
        }
    }
            //折半插入排序
    public static void binaryinsertSort(int[] A, int n) {
        int low, high, mid,j;
        for (int i = 1; i < n; i++) {
            if(A[i] <A[i-1]){
                int temp = A[i];
                low = 0;
                high = i-1;

                while (low <= high) {
                    mid = (low + high) / 2;
                    if (temp < A[mid]) {
                        high = mid - 1;
                    } else {
                        low = mid + 1;
                    }
                }
                for (  j = i - 1; j >=high +1; j--) {
                    A[j + 1] = A[j];
                }
                A[j+1] = temp;
            }//if

        }

    }
            //插入排序
    public static void InsertSort(int[] A, int n) {
        int j;
        int temp;
        for (int i = 1; i < n; i++) {
            if (A[i] < A[i-1]) {
                temp = A[i];

                //for (j=i-1;A[j]>temp&&j>=0;j-- ) {


                for (j = i - 1; j >= 0 && A[j] > temp; j--) {
                    A[j+1] = A[j];
                }
                A[j + 1] = temp;
            }
        }
    }
    //希尔
    public static void shellSort(int[] A,int n){
        int d ,j,temp = 0;
        for(d=n/2;d>=1;d = d/2){
            //这个 i= d,不等于d+1,和王道不一样,
            for (int i = d; i <n ; i++) {
                if(A[i]<A[i-d]) {
                    temp = A[i];

                    for (j = i - d; j >=0 && A[j] > temp; j = j - d) {
                        A[j + d] = A[j];

                    }
                    A[j + d] = temp;
                }//if

            }

        }








    }

//插入排序,折半
        public static  void sort(int[] array) {
            int temp;
            int j;

            for (int i = 1; i <array.length; i++) {
                int low = 0;
                int hight = i - 1;
                //这一步的if 是灵魂,我觉得这一步可以省下一些步骤.自创
                if(array[i]<array[i-1]) {
                    temp = array[i];


                    while (hight >= low) {
                        int mid = (low + hight) / 2;
                        if (array[mid] > temp) {
                            hight = mid - 1;
                        } else {
                            low = mid + 1;
                        }
                    }

                    for (j = i - 1; j >= low; --j) {
                        array[j + 1] = array[j];
                    }

                    array[low] = temp;
                }

            }

        }
//折半

        public static void binInsertSort2(int[] A){
        int j =0;

            for (int i = 1; i < A.length; i++) {
                if(A[i]<A[i-1]){
                     int temp = A[i];
                    int low =0;
                    int high = i-1;
                    while (low <= high) {
                        int mid = (low +high) / 2;
                        if(A[mid]>=temp){
                            high = mid -1;
                        }else{
                            low = mid + 1;
                        }
                    }
                    for (j = i-1; j>=low; --j) {
                        A[j+1] = A[j];
                    }

                    A[low] = temp;
               }
            }

        }


//希尔2
        public static void shell2(int[]A,int n){
        int j;
            for(int d= n/2;d>=1;d= d/2){
                for(int i = d;i<n;i++){
                    if(A[i] <A[i-d]) {
                        int temp = A[i];

                        for (j = i - d; j >= 0 && A[j] > temp;j = j- d){
                            A[j +d] = A[j];
                        }
                        A[j+d] = temp;
                    }
                }

             }
        }

}