合并两个无序数组java_Java实现十大排序算法（上）

最新推荐文章于 2023-02-08 18:14:06 发布

weixin_39929961

最新推荐文章于 2023-02-08 18:14:06 发布

阅读量563

点赞数

文章标签：合并两个无序数组java

本文链接：https://blog.youkuaiyun.com/weixin_39929961/article/details/112333784

版权

本文介绍了Java实现的十大排序算法，包括冒泡排序、选择排序、插入排序、希尔排序和归并排序。重点讲解了归并排序，它是稳定的排序方法，具有O(n log2 n)的时间复杂度，需要额外的内存空间。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

概念

概念解释稳定如果a原本在b前面，而a=b，排序之后a仍然在b的前面。不稳定如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。时间复杂度对排序数据的总的操作次数，反映当n变化时，操作次数所呈现规律。空间复杂度算法在计算机内执行时所需存储空间，反映当n变化时，存储空间所呈现规律。

1、冒泡排序/简单比较排序

冒泡排序是简单比较排序。冒泡排序对数组的无序部分进行循环比较，每次比较两个元素，如果顺序错误就进行位置交换，循环结束后会在无序部分的尾部得到最值，成为有序部分；然后继续对剩余的无序部分进行循环比较，直到整个数组都成为有序部分为止。

助记码：

 i∈[0,N-1)               //循环N-1遍
   j∈[0,N-1-i)           //每遍循环要处理的无序部分
     swap(j,j+1)         //相邻元素排序并交换位置

复杂度和稳定性：

复杂度解释时间复杂度外循环和内循环以及判断和交换元素的时间开销 (n-1) + (n-2) + (n-3) + … + 1 = n*(n-1)/2空间复杂度在交换元素时那个临时变量所占的内存空间平均时间复杂度最差时间复杂度无顺序标志位最优时间复杂度有顺序标志位最优时间复杂度杂序 O( n^2 )逆序 O( n^2 )顺序无标志位 O( n^2 )顺序有标志位 O(n)平均空间复杂度最差空间复杂度最优空间复杂度杂序 O(1)逆序 O(1)顺序且不使用临时空间来交换两个元素O(0)稳定性稳定不使用临时空间来交换两个元素a = a + b; b = a - b; a = a - b;a = a * b; b = a / b; a = a / b;a = a ^ b; b = a ^ b; a = a ^ b;

Java代码实现：

public class BubbleSort {

    public static void main(String[] args) {
        //TODO 冒泡排序
        int[] arr = new int[]{10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
        int[] result = sort(arr);
        System.out.println("结果");
        for (int value : result) {
            System.out.print(value + " ");
        }
    }

    /**
     * @param arr 待排序的数组
     * @return
     */
    private static int[] sort(int[] arr) {
        //数组大小
        int n = arr.length;
        //临时值放在循环外，提高效率
        int temp;
        for (int i = 0; i < n - 1; i++) {
            //外层循环，n个数比较，只需要循环比较n-1次。
            for (int j = 0; j < arr.length - 1 - i; j++) {
                //内层无序部分循环，循环结束后，将取出最值置于数组后端有序部分。
                if (arr[j] > arr[j + 1]) {
                    //相邻元素比较替换，前者大于后者替换为升序，前者小于后者替换为降序。
                    temp = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = temp;
                }
            }
            System.out.println("第" + (i + 1) + "次");
            for (int value : arr) {
                System.out.print(value + " ");
            }
            System.out.println(" ");
        }
        return arr;
    }
}

运行结果：

第1次
9 8 7 6 5 4 3 2 1 10  
第2次
8 7 6 5 4 3 2 1 9 10  
第3次
7 6 5 4 3 2 1 8 9 10  
第4次
6 5 4 3 2 1 7 8 9 10  
第5次
5 4 3 2 1 6 7 8 9 10  
第6次
4 3 2 1 5 6 7 8 9 10  
第7次
3 2 1 4 5 6 7 8 9 10  
第8次
2 1 3 4 5 6 7 8 9 10  
第9次
1 2 3 4 5 6 7 8 9 10  
结果
1 2 3 4 5 6 7 8 9 10

有判断是否顺序的标志位的冒泡排序，Java代码实现：

public class BubbleSort {

    public static void main(String[] args) {
        //TODO 冒泡排序
        int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        int[] result = sort(arr);
        System.out.println("结果");
        for (int value : result) {
            System.out.print(value + " ");
        }
    }

    /**
     * @param arr 待排序的数组
     * @return
     */
    private static int[] sort(int[] arr) {
        //数组大小
        int n = arr.length;
        //临时值放在循环外，提高效率
        int temp;
        //是否顺序的标志位
        int flag = 1;
        for (int i = 0; i < n - 1; i++) {
            //外层循环，n个数比较，只需要循环比较n-1次。
            for (int j = 0; j < arr.length - 1 - i; j++) {
                //内层无序部分循环，循环结束后，将取出最值置于数组后端有序部分。
                if (arr[j] > arr[j + 1]) {
                    //相邻元素比较替换，前者大于后者替换为升序，前者小于后者替换为降序。
                    temp = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = temp;
                    flag = 0;

                }
            }
            System.out.println("第" + (i + 1) + "次");
            for (int value : arr) {
                System.out.print(value + " ");
            }
            System.out.println(" ");
            //是顺序
            if (flag==1) break;
        }
        return arr;
    }
}

运行结果：

第1次
1 2 3 4 5 6 7 8 9 10  
结果
1 2 3 4 5 6 7 8 9 10

2、简单选择排序

简单选择排序，将数组的无序部分中的元素进行比较，得到最值，并与无序部分的首部交换位置，成为数组的有序部分；然后继续对剩余的无序部分执行相同操作，直到整个数组都成为有序部分为止。

助记码：

 i∈[0,N-1)              //循环N-1遍
   j∈[i+1,N)            //每遍循环要处理的无序部分
     select(min)        //选择最值
   swap(i, min)   //交换最值和无序部分的首部位置

复杂度和稳定性：

平均时间复杂度最差时间复杂度最优时间复杂度空间复杂度稳定性O( n^2 )O( n^2 )O( n^2 )O(1)不稳定

Java代码实现：

public class SelectionSort {
    public static void main(String[] args) {
        //TODO 选择排序
        int[] arr = new int[]{10, 2, 8, 3, 6, 8, 4, 7, 9, 1};
        int[] result = sort(arr);
        System.out.println("结果");
        for (int value : result) {
            System.out.print(value + " ");
        }
    }

    /**
     * @param arr 待排序的数组
     * @return
     */
    private static int[] sort(int[] arr) {
        //临时值放在循环外，提高效率
        int miniIndex, miniValue;
        for (int i = 0; i < arr.length - 1; i++) {
            //外层循环，n个数比较，只需要循环比较n-1次。
            miniIndex = i;
            for (int j = i + 1; j < arr.length; j++) {
                //内层循环，对无序部分进行比较，得到最值
                if (arr[miniIndex] > arr[j]) {
                    miniIndex = j;
                }
            }
            //得到最值后，将最值与无序部分的首部进行位置互换，成为数组的有序部分
            miniValue = arr[miniIndex];
            arr[miniIndex] = arr[i];
            arr[i] = miniValue;

            System.out.println("第" + (i + 1) + "次");
            for (int value : arr) {
                System.out.print(value + " ");
            }
            System.out.println(" ");
        }
        return arr;
    }
}

运行结果：

第1次
1 2 8 3 6 8 4 7 9 10  
第2次
1 2 8 3 6 8 4 7 9 10  
第3次
1 2 3 8 6 8 4 7 9 10  
第4次
1 2 3 4 6 8 8 7 9 10  
第5次
1 2 3 4 6 8 8 7 9 10  
第6次
1 2 3 4 6 7 8 8 9 10  
第7次
1 2 3 4 6 7 8 8 9 10  
第8次
1 2 3 4 6 7 8 8 9 10  
第9次
1 2 3 4 6 7 8 8 9 10  
结果
1 2 3 4 6 7 8 8 9 10

3、简单插入排序

取出未排序无序序列中的首部元素，在数组首部已排序有序序列中从后向前扫描，找到相应位置并插入，也就是未找到相应位置时进行位置交换，找到相应位置时停止位置交换，成为有序序列；然后继续从剩余无序序列中取出首部元素，进行插入，直到整个数组成为有序序列。例如扑克牌排序。

简单插入排序在小规模数据数据或者基本有序或者时十分高效。数据有序程度越高，越高效，移动少。

复杂度和稳定性：

平均时间复杂度最差时间复杂度最优时间复杂度空间复杂度稳定性O( n^2 )O( n^2 )O( n )O(1)稳定

Java实现代码：

public class InsertionSort {

    public static void main(String[] args) {
        //TODO 插入排序
        int[] arr = new int[]{10, 2, 8, 3, 6, 5, 4, 7, 9, 1};
        int[] result = sort(arr);
        System.out.println("结果");
        for (int value : result) {
            System.out.print(value + " ");
        }
    }
    /**
     * @param arr 待排序的数组
     * @return
     */
    private static int[] sort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return arr;
        }
        int len = arr.length;
        int preIndex, current;
        //可以把数组首部元素，当做已排序的有序序列
        for (int i = 1; i < len; i++) {
            //已排序序列的最后一个元素
            preIndex = i - 1;
            //未排序序列的第一个元素
            current = arr[i];
            //寻找当前元素在有序序列中的相应位置，未结束循环且有序序列前一个元素比当前元素大，则继续寻找
            while (preIndex >= 0 && arr[preIndex] > current) {
                //交换位置
                arr[preIndex + 1] = arr[preIndex];
                //继续寻找
                preIndex--;
            }
            //如果已排序序列已经循环完毕，或者，已经找到对应位置
            arr[preIndex + 1] = current;

            System.out.println("第" + i + "次");
            for (int value : arr) {
                System.out.print(value + " ");
            }
            System.out.println(" ");
        }

        return arr;

    }
}

运行结果：

第1次
2 10 8 3 6 5 4 7 9 1  
第2次
2 8 10 3 6 5 4 7 9 1  
第3次
2 3 8 10 6 5 4 7 9 1  
第4次
2 3 6 8 10 5 4 7 9 1  
第5次
2 3 5 6 8 10 4 7 9 1  
第6次
2 3 4 5 6 8 10 7 9 1  
第7次
2 3 4 5 6 7 8 10 9 1  
第8次
2 3 4 5 6 7 8 9 10 1  
第9次
1 2 3 4 5 6 7 8 9 10  
结果
1 2 3 4 5 6 7 8 9 10

4、希尔排序/改进版简单插入排序/缩小增量排序/递减增量排序

希尔排序改进插入排序，使得对较大规模并且无序的数据也非常有效率

与简单插入排序的不同之处在于，希尔排序会优先比较距离较远的元素。

首先它在逻辑上把较大的数据集合分割成若干个小组，然后对每一个小组分别进行插入排序，此时，插入排序所作用的每一个小组的数据量比较小，插入的效率比较高。

当增量为1时，整个数组已经接近有序了，插入排序效率高。

希尔排序的核心在于间隔序列的设定。既可以提前设定好间隔序列，也可以动态的定义间隔序列。

希尔排序的时间度分析极其复杂，有的增量序列的复杂度至今还没人能够证明出来。

Hibbard提出了另一个增量序列{1,3,7，...,2^k-1 }，这种序列的时间复杂度(最坏情形)为O(n^1.5 )

Sedgewick提出了几种增量序列，其最坏情形运行时间为O（n^1.3 ）,其中最好的一个序列是{1,5,19,41,109,...}

虽然插入排序是稳定的，但是希尔排序在插入的时候是跳跃性插入的，有可能破坏稳定性。

复杂度和稳定性：

空间复杂度稳定性O(1)不稳定

Java代码实现：

public class ShellSort {
    public static void main(String[] args) {
        //TODO 希尔排序
        int[] arr = new int[]{10, 2, 8, 3, 6, 8, 4, 7, 9, 1};
        int[] result = sort(arr);
        System.out.println("结果");
        for (int value : result) {
            System.out.print(value + " ");
        }
    }

    private static int[] sort(int[] arr) {
        int length = arr.length;
        int current;
        int incrementTime=0;
        for (int increment = length / 2; increment >= 1; increment /= 2) {
            incrementTime++;
            System.out.println("第" + incrementTime + "组" + increment +"增量");
            int insertTime = 0;
            for (int i = increment; i < length; i++) {
                insertTime++;
                System.out.println("第" + insertTime + "次插入排序");
                //此处是简单插入排序
                //分组已排序序列的最后一个元素
                current = arr[i];
                //局部未排序序列的第一个元素
                int preIndex = i - incrementTime;
                //寻找当前元素在分组有序序列中的相应位置，未结束循环且分组有序序列前一个元素比当前元素大，则继续向前寻找
                while (preIndex >= 0 && arr[preIndex] > current) {
                    //交换位置
                    arr[preIndex + incrementTime] = arr[preIndex];
                    //继续寻找
                    preIndex -= incrementTime;
                }
                //如果分组已排序序列已经循环完毕，或者已经找到对应位置，则结束寻找
                arr[preIndex + incrementTime] = current;
                for (int value : arr) {
                    System.out.print(value + " ");
                }
                System.out.println(" ");
            }
        }
        return arr;
    }
}

运行结果：

第1组5增量
第1次插入排序
10 2 8 3 6 8 4 7 9 1  
第2次插入排序
10 2 8 3 4 6 8 7 9 1  
第3次插入排序
10 2 8 3 4 6 7 8 9 1  
第4次插入排序
10 2 8 3 4 6 7 8 9 1  
第5次插入排序
1 10 2 8 3 4 6 7 8 9  
第2组2增量
第1次插入排序
1 10 2 8 3 4 6 7 8 9  
第2次插入排序
1 8 2 10 3 4 6 7 8 9  
第3次插入排序
1 8 2 10 3 4 6 7 8 9  
第4次插入排序
1 4 2 8 3 10 6 7 8 9  
第5次插入排序
1 4 2 8 3 10 6 7 8 9  
第6次插入排序
1 4 2 7 3 8 6 10 8 9  
第7次插入排序
1 4 2 7 3 8 6 10 8 9  
第8次插入排序
1 4 2 7 3 8 6 9 8 10  
第3组1增量
第1次插入排序
1 4 2 7 3 8 6 9 8 10  
第2次插入排序
1 4 2 7 3 8 6 9 8 10  
第3次插入排序
1 4 2 7 3 8 6 9 8 10  
第4次插入排序
1 3 2 7 4 8 6 9 8 10  
第5次插入排序
1 3 2 7 4 8 6 9 8 10  
第6次插入排序
1 3 2 6 4 8 7 9 8 10  
第7次插入排序
1 3 2 6 4 8 7 9 8 10  
第8次插入排序
1 3 2 6 4 8 7 9 8 10  
第9次插入排序
1 3 2 6 4 8 7 9 8 10  
结果
1 3 2 6 4 8 7 9 8 10

5、归并排序

和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是O(n log n）的时间复杂度。代价是需要额外的内存空间。

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。归并排序是一种稳定的排序方法。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。

•把长度为n的输入序列分成两个长度为n/2的子序列；
•对这两个子序列分别采用归并排序；
•将两个排序好的子序列合并成一个最终的排序序列。

复杂度和稳定性：

平均时间复杂度最差时间复杂度最优时间复杂度空间复杂度稳定性O(n log2 n)O(n log2 n)O(n log2 n)O(n)稳定

归并排序迭代版，Java代码实现：

public class MergeSortIteration {
    public static void main(String[] args) {
        //TODO 归并排序迭代版
        int[] arr = new int[]{10, 2, 8, 3, 6, 5, 4, 7, 9, 1};
        sort(arr);
    }

    public static void sort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        int[] orderedArr = new int[arr.length];
        for (int i = 2; i < arr.length * 2; i *= 2) {
            for (int j = 0; j < (arr.length + i - 1) / i; j++) {
                int left = i * j;
                int mid = left + i / 2 >= arr.length ? (arr.length - 1) : (left + i / 2);
                int right = i * (j + 1) - 1 >= arr.length ? (arr.length - 1) : (i * (j + 1) - 1);
                int start = left, l = left, m = mid;
                while (l < mid && m <= right) {
                    if (arr[l] < arr[m]) {
                        orderedArr[start++] = arr[l++];
                    } else {
                        orderedArr[start++] = arr[m++];
                    }
                }
                while (l < mid)
                    orderedArr[start++] = arr[l++];
                while (m <= right)
                    orderedArr[start++] = arr[m++];
                System.arraycopy(orderedArr, left, arr, left, right - left + 1);
            }
        }
    }
}

归并排序递归版，Java代码实现：

public class MergeSortRecursive {
    public static void main(String[] args) {
        //TODO 归并排序递归版
        int[] arr = new int[]{10, 2, 8, 3, 6, 5, 4, 7, 9, 1};
        sort(arr);

    }

    private static void sort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        int[] result = new int[arr.length];
        merge_sort_recursive(arr, result, 0, arr.length - 1);
    }

    private static void merge_sort_recursive(int[] arr, int[] result, int start, int end) {
        if (start >= end)
            return;
        int len = end - start, mid = (len >> 1) + start;
        int start1 = start, end1 = mid;
        int start2 = mid + 1, end2 = end;
        merge_sort_recursive(arr, result, start1, end1);
        merge_sort_recursive(arr, result, start2, end2);
        int k = start;
        while (start1 <= end1 && start2 <= end2)
            result[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];
        while (start1 <= end1)
            result[k++] = arr[start1++];
        while (start2 <= end2)
            result[k++] = arr[start2++];
        for (k = start; k <= end; k++)
            arr[k] = result[k];
    }
}

欢迎关注Android技术堆栈，专注于Android技术学习的公众号，致力于提高Android开发者们的专业技能！