java-一些排序算法代码实现

最新推荐文章于 2023-02-10 10:17:43 发布

头秃自闭型儿童

最新推荐文章于 2023-02-10 10:17:43 发布

阅读量302

点赞数

文章标签：排序算法 java

本文链接：https://blog.csdn.net/weixin_44270056/article/details/124077157

版权

本文详细介绍了六种经典的排序算法实现，包括选择排序、冒泡排序、插入排序、归并排序、快速排序1.0、快速排序2.0和堆排序。每种排序算法都通过随机生成的数组进行了测试，确保了排序的正确性。这些排序算法各有特点，适用于不同的数据和场景，对于理解算法和提升编程能力具有重要意义。

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

1.选择排序

package class01;
import java.util.Arrays;
public class SelectionSort {
    public static void main(String[] args){
        int maxSize=100;
        int maxValue=1000;
        int times=50;
        for(int i=0;i<times;i++){
            System.out.println("第"+(i+1)+"次测试：");
            int[] arr1=getRandomArray(maxSize,maxValue);
//            printArray(arr1);
            int[] arr2=copyArray(arr1);
//            printArray(arr2);
            selectionSort(arr1);
            Arrays.sort(arr2);
            if(isEqual(arr1,arr2)){
                System.out.println("Successful!");
            }else{
                System.out.println("Unsuccessful!");
                printArray(arr1);
                System.out.println("???????????????");
                printArray(arr2);
                break;
            }
        }
    }
    //输出数组
    public static void printArray(int[] arr){
        for(int i=0; i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }
    //判断两个数组中的数是否相等
    public static boolean isEqual(int[] arr1,int[] arr2){
        if((arr1==null &&arr2!=null)||(arr2==null &&arr1!=null)){
            return false;
        }
        if(arr1.length!=arr2.length){
            return false;
        }
        for(int i=0; i<arr1.length;i++){
            if(arr1[i]!=arr2[i]){
                return false;
            }
        }
        return true;
    }
    //交换数组中的两个数
    public static void swap(int i, int minIndex, int[] arr){
        int a=arr[i];
        arr[i]=arr[minIndex];
        arr[minIndex]=a;
    }
    //选择排序
    public static void selectionSort(int[] arr){
        if(arr==null || arr.length<2){
            return;
        }
        for(int i=0; i<arr.length ;i++){
            int minIndex=i;
            for(int j=i;j<arr.length;j++){
                if(arr[minIndex]>arr[j]){
                    minIndex=j;
                }
            }
            swap(i,minIndex,arr);
        }
    }
    //随机生成数组
    public static int[] getRandomArray(int maxSize, int maxValue){
        int[] arr= new int[(int)((maxSize+1)*Math.random())] ;
        for(int i=0; i<arr.length;i++){
            arr[i]=(int)((maxValue+1)*Math.random())-(int)(maxValue*Math.random());
        }
        return arr;
    }
    //复制数组
    public static int[] copyArray(int[] arr){
        if(arr==null){
            return null;
        }
        int[] arr2=new int[arr.length];
        for(int i=0;i<arr.length;i++){
            arr2[i]=arr[i];
        }
        return arr2;
    }
}

2.冒泡排序

package class01;

import java.util.Arrays;

public class BubbleSort {
    public static void main(String[] args) {
        int maxSize=100;
        int maxValue=1000;
        int times=50;
        for(int i=0; i<times;i++){
            System.out.println(i+1);
            double[] arr1=getRandomArray(maxSize,maxValue);
            double[] arr2=copyArray(arr1);
            BubbleSort(arr1);
            Arrays.sort(arr2);
            if(isEqual(arr1,arr2)){
                System.out.println("Successful!");
            }else{
                System.out.println("Unsuccessful!");
                break;
            }
        }

    }
    //判断两个数组是否相等
    public static boolean isEqual(double[] arr1,double[] arr2){
        if((arr1==null && arr2!=null)||(arr2==null && arr2!=null)){
            return false;
        }
        if(arr1.length!=arr2.length){
            return false;
        }
        for(int i=0;i<arr1.length;i++){
            if(arr1[i]!=arr2[i]){
                return false;
            }
        }
        return true;
    }
    //随机生成数组
    public static double[] getRandomArray(int maxSize, int maxValue){
        double[] arr=new double[(int)((maxSize+1)*Math.random())];
        for(int i=0;i<arr.length;i++){
            arr[i]=(maxValue)*Math.random()-maxValue*Math.random();
        }
        return arr;
    }
    //复制数组
    public static double[] copyArray(double[] arr){
        if(arr==null){
            return null;
        }
        double[] arr2=new double[arr.length];
        for(int i=0;i<arr.length;i++){
            arr2[i]=arr[i];
        }
        return arr2;
    }
    //交换数组中的两个数
    public static void swap(int i,int j,double[] arr){
        double a=arr[i];
        arr[i]=arr[j];
        arr[j]=a;
    }
    public static void BubbleSort(double[] arr){
        if((arr==null)||(arr.length<2)){
            return;
        }
        for(int i=0;i< arr.length-1;i++){
            for(int j=0;j<arr.length-1-i;j++){
                if(arr[j]>arr[j+1]){
                    swap(j,j+1,arr);
                }
            }
        }
    }
}

3.插入排序

0_{0范围有序；0}1范围有序……；0~N范围有序。数据状况不同会导致时间复杂度不同。

package class01;

import java.util.Arrays;

public class InsertionSort {
    public static void main(String[] args) {
        int maxSize=100;
        int maxValue=1000;
        int times=100;
        for(int i=0; i<times;i++){
            System.out.println(i+1);
            double[] arr1=getRandomArray(maxSize,maxValue);
            double[] arr2=copyArray(arr1);
            insertionSort(arr1);
            Arrays.sort(arr2);
            if(isEqual(arr1,arr2)){
                System.out.println("Successful!");
            }else{
                System.out.println("Unsuccessful!");
                break;
            }
        }
    }
    //判断两个数组是否相等
    public static boolean isEqual(double[] arr1,double[] arr2){
        if((arr1==null && arr2!=null)||(arr2==null && arr2!=null)){
            return false;
        }
        if(arr1.length!=arr2.length){
            return false;
        }
        for(int i=0;i<arr1.length;i++){
            if(arr1[i]!=arr2[i]){
                return false;
            }
        }
        return true;
    }
    //随机生成数组
    public static double[] getRandomArray(int maxSize, int maxValue){
        double[] arr=new double[(int)((maxSize+1)*Math.random())];
        for(int i=0;i<arr.length;i++){
            arr[i]=(maxValue)*Math.random()-maxValue*Math.random();
        }
        return arr;
    }
    //复制数组
    public static double[] copyArray(double[] arr){
        if(arr==null){
            return null;
        }
        double[] arr2=new double[arr.length];
        for(int i=0;i<arr.length;i++){
            arr2[i]=arr[i];
        }
        return arr2;
    }
    //交换数组中的两个数
    public static void swap(int i,int j,double[] arr){
        double a=arr[i];
        arr[i]=arr[j];
        arr[j]=a;
    }
    //插入排序
    public static void insertionSort(double[] arr){
        if (arr == null || arr.length < 2) {
            return;
        }
        for(int i=1;i<arr.length;i++){
            for(int j=i;j>0;j--){
                if(arr[j]<arr[j-1]){
                    swap(j,j-1,arr);
                }
            }
        }
    }
}

4.归并排序

找到中点，左侧排好序，右侧排好序；开辟一个新的空间，合并在一起，比较左右两侧，谁小先拷贝谁，并且指针移动；然后拷贝回原数组。使用递归实现

package class01;

import java.util.Arrays;

//归并排序
public class MergeSort {
    public static void main(String[] args) {
        int maxSize=100;
        int maxValue=1000;
        int times=100;
        for(int i=0; i<times;i++){
            System.out.println(i+1);
            double[] arr1=getRandomArray(maxSize,maxValue);
            double[] arr2=copyArray(arr1);
            //注意一定要是arr1.length-1
            mergeSort(0,arr1.length-1,arr1,new double[arr1.length]);
            Arrays.sort(arr2);
            if(isEqual(arr1,arr2)){
                System.out.println("Successful!");
            }else{
                System.out.println("Unsuccessful!");
                break;
            }
        }
    }
    //判断两个数组是否相等
    public static boolean isEqual(double[] arr1,double[] arr2){
        if((arr1==null && arr2!=null)||(arr2==null && arr2!=null)){
            return false;
        }
        if(arr1.length!=arr2.length){
            return false;
        }
        for(int i=0;i<arr1.length;i++){
            if(arr1[i]!=arr2[i]){
                return false;
            }
        }
        return true;
    }
    //随机生成数组
    public static double[] getRandomArray(int maxSize, int maxValue){
        double[] arr=new double[(int)((maxSize+1)*Math.random())];
        for(int i=0;i<arr.length;i++){
            arr[i]=(maxValue)*Math.random()-maxValue*Math.random();
        }
        return arr;
    }
    //复制数组
    public static double[] copyArray(double[] arr){
        if(arr==null){
            return null;
        }
        double[] arr2=new double[arr.length];
        for(int i=0;i<arr.length;i++){
            arr2[i]=arr[i];
        }
        return arr2;
    }
    public static void mergeSort(int L,int R,double[] arr,double[] tempArr){
        //注意一定要有L<R这个判定条件
        if(L<R){
            int mid=(L+R)/2;
            mergeSort(L,mid,arr,tempArr);
            mergeSort(mid+1,R,arr,tempArr);
            sort(L,mid,R,arr,tempArr);
        }
    }
    public static void sort(int L,int mid,int R,double[] arr,double[] tempArr){
        int index=0;
        int i=L;
        int j=mid+1;
        while(i<=mid&&j<=R){
            if(arr[i]<arr[j]){
                tempArr[index]=arr[i];
                index++;
                i++;
            }else{
                tempArr[index]=arr[j];
                index++;
                j++;
            }
        }
        if(j>R){
            for(;i<=mid;i++){
                tempArr[index]=arr[i];
                index++;
            }
        }else{
            for(;j<=R;j++){
                tempArr[index]=arr[j];
                index++;
            }
        }
        for(int k=L,g=0;k<=R;k++,g++){
            arr[k]=tempArr[g];
        }
    }
}

5.快速排序1.0

使用最后一个值做为划分值，做到小于的在左边，大于等于的在右边；最后一个数跟大于区的第一个数做交换；左侧和右侧分别递归。

package class01;

import java.util.Arrays;

//使用最后一个值做为划分值，做到小于的在左边，大于等于的在右边；
// 最后一个数跟大于区的第一个数做交换；左侧和右侧分别递归。
public class QuickSort1 {
    public static void main(String[] args) {
        int maxSize=100;
        int maxValue=1000;
        int times=100;
        for(int i=0; i<times;i++){
            System.out.println(i+1);
            double[] arr1=getRandomArray(maxSize,maxValue);
            double[] arr2=copyArray(arr1);
            //注意一定要是arr1.length-1
            quickSort1(arr1,0, arr1.length-1);

            Arrays.sort(arr2);
            if(isEqual(arr1,arr2)){
                System.out.println("Successful!");
            }else{
                System.out.println("Unsuccessful!");
                break;
            }
        }
    }
    //判断两个数组是否相等
    public static boolean isEqual(double[] arr1,double[] arr2){
        if((arr1==null && arr2!=null)||(arr2==null && arr2!=null)){
            return false;
        }
        if(arr1.length!=arr2.length){
            return false;
        }
        for(int i=0;i<arr1.length;i++){
            if(arr1[i]!=arr2[i]){
                return false;
            }
        }
        return true;
    }
    //随机生成数组
    public static double[] getRandomArray(int maxSize, int maxValue){
        double[] arr=new double[(int)((maxSize+1)*Math.random())];
        for(int i=0;i<arr.length;i++){
            arr[i]=(maxValue)*Math.random()-maxValue*Math.random();
        }
        return arr;
    }
    //复制数组
    public static double[] copyArray(double[] arr){
        if(arr==null){
            return null;
        }
        double[] arr2=new double[arr.length];
        for(int i=0;i<arr.length;i++){
            arr2[i]=arr[i];
        }
        return arr2;
    }
    public static void swap(int i,int j,double[] arr){
        double a=arr[i];
        arr[i]=arr[j];
        arr[j]=a;
    }
    public static void quickSort1(double[] arr,int L,int R){
        if(L<R){
            int position=partition(arr,L,R);
            quickSort1(arr,L,position-1);
            quickSort1(arr,position+1,R);
        }
    }
    public static int partition(double[] arr, int L, int R){
        double pivot=arr[R];
        int point=L;
        for(int i=L;i<=R;i++){
            if(arr[i]<pivot){
                swap(i,point,arr);
                point++;
            }
        }
        swap(point,R,arr);
        return point;
    }
}

6.快速排序2.0

使用最后一个值作为划分，做到小于、等于和大于区；分别在小于和大于区做划分。

package class01;

import java.util.Arrays;
//快速排序2.0：使用最后一个值作为划分，做到小于、等于和大于区；分别在小于和大于区做划分。
public class QuickSort2 {
    public static void main(String[] args) {
        int maxSize = 10;
        int maxValue = 1000;
        int times = 100;
        for (int i = 0; i < times; i++) {
            System.out.println(i + 1);
            double[] arr1 = getRandomArray(maxSize, maxValue);
            double[] arr2 = copyArray(arr1);
            //注意一定要是arr1.length-1
            quickSort2(arr1, 0, arr1.length - 1);
            Arrays.sort(arr2);
            if (isEqual(arr1, arr2)) {
                System.out.println("Successful!");
            } else {
                printArray(arr1);
                System.out.println("???????");
                printArray(arr2);
                System.out.println("Unsuccessful!");
                break;
            }
        }
    }
    //判断两个数组是否相等
    public static boolean isEqual(double[] arr1,double[] arr2){
        if((arr1==null && arr2!=null)||(arr2==null && arr2!=null)){
            return false;
        }
        if(arr1.length!=arr2.length){
            return false;
        }
        for(int i=0;i<arr1.length;i++){
            if(arr1[i]!=arr2[i]){
                return false;
            }
        }
        return true;
    }
    //打印数组
    public static void printArray(double[] arr){
        for(int i=0; i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }
    //随机生成数组
    public static double[] getRandomArray(int maxSize, int maxValue){
        double[] arr=new double[(int)((maxSize+1)*Math.random())];
        for(int i=0;i<arr.length;i++){
            arr[i]=(maxValue)*Math.random()-maxValue*Math.random();
        }
        return arr;
    }
    //复制数组
    public static double[] copyArray(double[] arr){
        if(arr==null){
            return null;
        }
        double[] arr2=new double[arr.length];
        for(int i=0;i<arr.length;i++){
            arr2[i]=arr[i];
        }
        return arr2;
    }
    public static void swap(int i,int j,double[] arr){
        double a=arr[i];
        arr[i]=arr[j];
        arr[j]=a;
    }
    public static int[] partition(double[] arr,int L,int R){
        double pivot=arr[R];
        int[] point=new int[2];
        int point_L=L;
        int point_R=R;
        int i=L;
        while(i<=point_R){
            if(arr[i]<pivot){
                swap(i,point_L,arr);
                point_L++;
                i++;
            }else if(arr[i]>pivot){
                swap(i,point_R,arr);
                point_R--;
            }else{
                i++;
                //只有i++，没有其他操作
            }
        }

        point[0]=point_L-1;
        point[1]=point_R+1;
        return point;
    }
    public static void quickSort2(double[] arr,int L,int R){
        if(L<R){
            int[] position= partition(arr,L,R);
            int position_L=position[0];
            int position_R=position[1];
            quickSort2(arr,L,position_L);
            quickSort2(arr,position_R,R);
        }
    }
}

7.快速排序3.0

随机选一个数作为划分值。

package class01;

import java.util.Arrays;

//快速排序3.0：随机选一个数作为划分值。还是分三段。
public class QuickSort3 {
    public static void main(String[] args) {
        int maxSize=100;
        int maxVaule=100;
        int times=100;
        for(int i=0;i<times;i++){
            System.out.println(i+1);
            int[] arr1=getRandomArray(maxSize,maxVaule);
            int[] arr2=copyArray(arr1);
            quickSort3(0, arr1.length-1,arr1);
            Arrays.sort(arr2);
            if(isEqual(arr1,arr2)){
                System.out.println("Successful!");
            }else{
                System.out.println("Unsuccessful!");
                break;
            }
        }
    }
    public static int[] getRandomArray(int maxSize, int maxValue){
        int[] arr=new int[(int)((maxSize+1)*Math.random())];
        for(int i=0;i<arr.length;i++){
            arr[i]=(int)((maxValue+1)*Math.random())-(int)(maxValue*Math.random());
        }
        return arr;
    }
    public static int[] copyArray(int[] arr){
        if(arr==null){
            return null;
        }
        int[] arr1=new int[arr.length];
        for(int i=0;i<arr.length;i++){
            arr1[i]=arr[i];
        }
        return arr1;
    }
    public static boolean isEqual(int[] arr1,int[] arr2){
        if((arr1==null && arr2!=null)|| (arr2==null && arr1!=null)){
            return false;
        }
        if(arr1.length!=arr2.length){
            return false;
        }
        for(int i=0; i< arr1.length;i++){
            if(arr1[i]!=arr2[i]){
                return false;
            }
        }
        return true;
    }
    public static void swap(int i,int j,int[] arr){
        int a=arr[i];
        arr[i]=arr[j];
        arr[j]=a;
    }
    public static void quickSort3(int L,int R,int[] arr){
        if(L<R){
            int[] position=partition(L,R,arr);
            int position_L=position[0];
            int position_R=position[1];
            quickSort3(L,position_L,arr);
            quickSort3(position_R,R,arr);
        }
    }
    public static int[] partition(int L,int R, int[] arr){
        int[] point=new int[2];
        int pivot_index=L+(int)((R-L)*Math.random());
        int pivot=arr[pivot_index];
        int point_L=L;
        int point_R=R;
        int i=L;
        while(i<=point_R){
            if(arr[i]>pivot){
                swap(i,point_R,arr);
                point_R--;
            }else if(arr[i]<pivot){
                swap(i,point_L,arr);
                point_L++;
                i++;
            }else{
                i++;
            }
        }
        point[0]=point_L-1;
        point[1]=point_R+1;
        return point;
    }
}

8.堆排序

先把一个数组整体变成大根堆；把位置0和最后一个位置的数进行交换，然后heapsize–，也就是找到了最大值；重复进行heapify。

package class01;

import java.util.Arrays;

public class HeapSort {
    public static void main(String[] args) {
        int maxSize=10;
        int maxVaule=100;
        int times=100;
        for(int i=0;i<times;i++){
            System.out.println(i+1);
            int[] arr1=getRandomArray(maxSize,maxVaule);
            int[] arr2=copyArray(arr1);
            heapSort(arr1);
            Arrays.sort(arr2);
            if(isEqual(arr1,arr2)){
                System.out.println("Successful!");
            }else{
                printArray(arr1);
                System.out.println("???????");
                printArray(arr2);
                System.out.println("Unsuccessful!");
                break;
            }
        }
    }
    //打印数组
    public static void printArray(int[] arr){
        for(int i=0; i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }
    public static int[] getRandomArray(int maxSize, int maxValue){
        int[] arr=new int[(int)((maxSize+1)*Math.random())];
        for(int i=0;i<arr.length;i++){
            arr[i]=(int)((maxValue+1)*Math.random())-(int)(maxValue*Math.random());
        }
        return arr;
    }
    public static int[] copyArray(int[] arr){
        if(arr==null){
            return null;
        }
        int[] arr1=new int[arr.length];
        for(int i=0;i<arr.length;i++){
            arr1[i]=arr[i];
        }
        return arr1;
    }
    public static boolean isEqual(int[] arr1,int[] arr2){
        if((arr1==null && arr2!=null)|| (arr2==null && arr1!=null)){
            return false;
        }
        if(arr1.length!=arr2.length){
            return false;
        }
        for(int i=0; i< arr1.length;i++){
            if(arr1[i]!=arr2[i]){
                return false;
            }
        }
        return true;
    }
    public static void swap(int i,int j,int[] arr){
        int a=arr[i];
        arr[i]=arr[j];
        arr[j]=a;
    }
    public static void heapSort(int[] arr){
        for(int i=1;i<arr.length;i++){
            heapInsert(arr,i);//先排成一个大根堆
        }
        for(int i=0;i< arr.length-1;i++){

            swap(0,arr.length-1-i,arr);
            heapify(arr,0,arr.length-2-i);
        }
    }
    //在堆中插入一个新的元素，需要判断该元素与父节点之间的大小关系进行适当的调整，保证当前数据结构是一个最大堆
    public static void heapInsert(int[] arr,int index){
        int parent=(index-1)/2;
        while(arr[index]>arr[parent]){
            swap(index,parent,arr);
            index=parent;
            parent=(index-1)/2;
        }
    }
    //删除一个节点的过程是将队尾元素与要删除的节点进行交换，同时减少堆的大小，遮盖被交换出去数据的存在
    //原来的队尾元素插入到新的位置后，需要进行一次自上而下的调整，重新构建最大堆
    public static void heapify(int[] arr,int index,int heapSize){
        int left=2*index+1;
        while(left<=heapSize){
            //比较左右子节点之间的最大值
            int largest;
            //注意是<=
            if(left+1<=heapSize){
                largest=arr[left]>arr[left+1]?left:(left+1);
            }else{
                largest=left;
            }
            largest=arr[largest]>arr[index]?largest:index;
            if(largest==index){
                break;
            }else{
                swap(largest,index,arr);
                index=largest;
                left=2*index+1;
            }
        }
    }
}

头秃自闭型儿童

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java-一些排序算法代码实现

1.选择排序package class01;import java.util.Arrays;public class SelectionSort { public static void main(String[] args){ int maxSize=100; int maxValue=1000; int times=50; for(int i=0;i<times;i++){ System.out.
复制链接

扫一扫