JIAVA之选择排序和快速排序

努力的张同学

已于 2022-04-23 18:39:13 修改

阅读量153

点赞数 1

文章标签： java

于 2022-04-21 22:26:52 首次发布

本文链接：https://blog.csdn.net/m0_66435981/article/details/124332821

版权

本文详细介绍了Java中三种常见的排序算法：直接选择排序和优化后的选择排序，以及快速排序的基本思想和实现。通过代码示例展示了每种排序算法的运作过程，并提供了性能分析。此外，还给出了合并两个有序数组的实现方法，有助于理解排序和数据整合的策略。

摘要由CSDN通过智能技术生成

一 JIAVA之选择排序

1 直接选择排序-原理

每一次从无序区间选出最大（或最小）的一个元素，存放在无序区间的最后（或最前），直到全部待排序的数据元素排完。

选择排序的主要优点与数据移动有关。如果某个元素位于正确的最终位置上，则它不会被移动。选择排序每次交换一对元素，它们当中至少有一个将被移到其最终位置上，因此对n个元素的表进行排序总共进行至多n-1次交换。在所有的完全依靠交换去移动元素的排序方法中，选择排序属于非常好的一种

2 选择排序分析

3 代码实现

import java.util.Arrays;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: ZBY
 * Date: 2022-04-21
 * Time: 21:57
 */
public class TestDome {
    public static void swap(int[] array,int i,int j){//大小进行交换
        int tmp=array[i];
        array[i]=array[j];
        array[j]=tmp;
    }
    public static void selectSort(int[] array){
        for (int i = 0; i < array.length; i++) {
            for (int j = i+1; j < array.length ; j++) {
                if (array[j] < array[i]){//j 下标的值小于i下标的值就调用swap()函数进行交换
                    swap(array,j,i);
                }
            }

        }
    }

    public static void main(String[] args) {
int[] array={12,5,9,34,6,8,33,56,88,0,54,34};
     selectSort(array);
        System.out.println(Arrays.toString(array));
    }

}

4 优化之后的代码

import java.util.Arrays;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: ZBY
 * Date: 2022-04-21
 * Time: 21:57
 */
public class TestDome {
    public static void swap(int[] array,int i,int j){      //大小进行交换
        int tmp=array[i];
        array[i]=array[j];
        array[j]=tmp;
    }
    public static void selectSort(int[] array){
        for (int i = 0; i < array.length; i++) {
            int minIndex=i;  // 用来记录当前找到的最小值
            for (int j = i+1; j < array.length ; j++) {

                if (array[j] <array[minIndex]){      //     j 下标的值小于i下标的值就调用swap()函数进行交换
                    minIndex=j;             //存储当前最小值的下标
                }
            }
            swap(array,i,minIndex);

        }
    }

    public static void main(String[] args) {
int[] array={12,5,9,34,6,8,33,56,88,0,54,34};
     selectSort(array);
        System.out.println(Arrays.toString(array));
    }

}

补充，测试，随机生成一堆数据，测算排序时间，代码如下

import java.util.Arrays;
import java.util.Random;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: ZBY
 * Date: 2022-04-21
 * Time: 21:57
 */
public class TestDome {
    public static void swap(int[] array,int i,int j){      //大小进行交换
        int tmp=array[i];
        array[i]=array[j];
        array[j]=tmp;
    }
    public static void selectSort(int[] array){
        for (int i = 0; i < array.length; i++) {
            int minIndex=i;  // 用来记录当前找到的最小值
            for (int j = i+1; j < array.length ; j++) {

                if (array[j] <array[minIndex]){      //     j 下标的值小于i下标的值就调用swap()函数进行交换
                    minIndex=j;             //存储当前最小值的下标
                }
            }
            swap(array,i,minIndex);

        }
    }
    //测算时间复杂度
public static  void  test1(int capacity){
        int [] array=new int[capacity];
    Random random=new Random();//生成随机数字
    for (int i = 0; i < array.length; i++) {
        array[i]=random.nextInt(capacity);
    }
     long start=System.currentTimeMillis();//计算时间，开始时候的时间
    selectSort(array);
    long end=System.currentTimeMillis();
    System.out.println(end-start);
}

    public static void main(String[] args) {
        test1(10_0000 );
    }

    public static void main1(String[] args) {
int[] array={12,5,9,34,6,8,33,56,88,0,54,34};
     selectSort(array);
        System.out.println(Arrays.toString(array));
    }

}

二 java之快速排序

1、基本思想：

1. 从待排序区间选择一个数，作为基准值(pivot)；
2. Partition: 遍历整个待排序区间，将比基准值小的（可以包含相等的）放到基准值的左边，将比基准值大的（可以包含相等的）放到基准值的右边；
3. 采用分治思想，对左右两个小区间按照同样的方式处理，直到小区间的长度 == 1，代表已经有序，或者小区间
的长度 == 0，代表没有数据。

换句话说

快速排序是我们之前学习的冒泡排序的升级，他们都属于交换类排序，都是采用不断的比较和移动来实现排序的。快速排序是一种非常高效的排序算法，它的实现，增大了记录的比较和移动的距离，将关键字较大的记录从前面直接移动到后面，关键字较小的记录从后面直接移动到前面，从而减少了总的比较次数和移动次数。同时采用“分而治之”的思想，把大的拆分为小的，小的拆分为更小的，其原理如下：对于给定的一组记录，选择一个基准元素,通常选择第一个元素或者最后一个元素,通过一趟扫描，将待排序列分成两部分,一部分比基准元素小,一部分大于等于基准元素,此时基准元素在其排好序后的正确位置,然后再用同样的方法递归地排序划分的两部分，直到序列中的所有记录均有序为止。

2、复杂度分析：

（1）最坏时间复杂度
最坏情况是指每次区间划分的结果都是基准关键字的左边（或右边）序列为空，而另一边区间中的记录仅比排序前少了一项，即选择的关键字是待排序记录的最小值或最大值。最坏情况下快速排序的时间复杂度为这里写图片描述。
（2）最好时间复杂度
最好情况是指每次区间划分的结果都是基准关键字的左右两边长度相等或者相差为1，即选择的基准关键字为待排序的记录的中间值。此时进行比较次数总共为 nlogn，所以最好情况下快速排序的时间复杂度为这里写图片描述。
（3）平均时间复杂度
快速排序的平均时间复杂度为。在所有平均时间复杂度为O(nlogn)的算法中，快速排序的平均性能是最好的。
（4）空间复杂度
快速排序的过程中需要一个栈空间来实现递归。最好情况，递归树的深度为这里写图片描述，其空间复杂度也就是O(nlogn)；最坏情况下，需要进行 n-1次递归，其空间复杂度为O(n)；平均情况，空间复杂度为O(nlogn).
（5）基准关键字的选取，基准关键字的选取是决定快速排序算法的关键，常用的基准关键字的选取方式如下：
第一种：三者取中。将序列首、尾和中间位置上的记录进行比较，选择三者中值作为基准关键字。
第二种：取left和right之间的一个随机数这里写图片描述，用(pivot)作为基准关键字。采用这种方法得到的快速排序一般称为随机的快速ji

3 代码实现

import java.util.Arrays;
import java.util.Random;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: ZBY
 * Date: 2022-04-23
 * Time: 16:15
 */
public class TestDome {

    public  static  void quickSort(int[] array){
        quick(array,0,array.length-1);

    }
    public static void quick(int[] array,int left,int right){
        if (left>=right){
            return;
        }
        int pivot= partition (array,left,right);//
        quick(array,left,pivot-1);
        quick(array,pivot+1,right);

    }

    private static  int partition(int[] array,int start,int end){
        int tmp=array[start];
        while (start<end){
            while (start<end && array[end]>=tmp){
                end--;
            }
            array [start]=array[end];
            while (start<end && array[start]<=tmp){
                start++;
            }
            array[end]=array[start];
        }
        array[start]=tmp;
        return start;
    }

    public static void main(String[] args) {
        int[] array={12,5,9,34,6,0,33,56,89,0,7,4,0,55,77};
        quickSort(array);
        System.out.println(Arrays.toString(array));
    }
}

三合并有序数组

import java.util.Arrays;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: ZBY
 * Date: 2022-04-23
 * Time: 17:51
 */
public class TESTdome1 {
    public static int[] mergeArray(int[] array1, int[] array2) {
        int[] tmp = new int[array1.length + array2.length];
        int k = 0;
        int s1 = 0;
        int e1 = array1.length - 1;
        int s2 = 0;
        int e2 = array2.length - 1;
        while (s1 <= e1 && s2 <= e2) {
            if (array1[s1] <= array2[s2]) {

               // tmp[k] = array1[s1];
                tmp[k++] = array1[s1++];
            } else {
               // tmp[k] = array2[s1];
               tmp[k++] = array2[s2++];
            }
        }
        while (s1 <= e1) {
            tmp[k++] = array1[s1++];
        }
        while (s2 <= e2) {
            tmp[k++] = array2[s2++];
        }
        return tmp;
    }

    public static void main(String[] args) {
        int[] array1 = {1, 3, 5, 7, 9};
        int[] array2 = {2, 4, 6, 8, 10};
        int[] ret = mergeArray(array1, array2);
        System.out.println(Arrays.toString(ret));
    }

}