Java学习——排序篇

最新推荐文章于 2024-10-11 22:21:14 发布

可爱的古月安

最新推荐文章于 2024-10-11 22:21:14 发布

阅读量119

点赞数

分类专栏： 2019JAVA学习文章标签： JAVA 排序算法

本文链接：https://blog.csdn.net/qq_35553192/article/details/89340034

版权

2019JAVA学习专栏收录该内容

3 篇文章 0 订阅

订阅专栏

这篇博客详细介绍了Java中几种常见的排序算法，包括冒泡排序、选择排序、插入排序以及快速排序。每种排序算法都阐述了其基本原理，并提供了相应的JAVA源码实现，帮助读者深入理解并掌握这些排序方法。

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

冒泡排序

原理：
从小到大：两两比较，小的在前，大的在后
从大到小：两两比较，大的在前，小的在后

JAVA源码：

public class SORT_FUNCTION {
    public static void main(String args[]){
        int a[]={3,2,1,4,7,6,8,10,5,9,0};
        bubble(a);
    }

    private static int[] bubble(int[] array_num) {
        int i,j,k;
        System.out.println("-------------------Origin--------------");
        for(i=0;i<array_num.length;i++){
            System.out.print(array_num[i]+" ");
        }
        for(i=0;i<array_num.length-1;i++){
            for(j=0;j<array_num.length-1-i;j++){
                if(array_num[j]>array_num[j+1]){
                    k=array_num[j];
                    array_num[j]=array_num[j+1];
                    array_num[j+1]=k;
                }
            }
        }
        System.out.println("\n-------------------Bubble--------------");
        for(i=0;i<array_num.length;i++){
            System.out.print(array_num[i]+" ");
        }
        return array_num;
    }

}

输出结果：
冒泡排序结果

选择排序

原理：
选择第n小（大）的放在第n个位置

JAVA源码：

 public static int[] select(int[] array_num){
        int i,j,k,l;
        System.out.println("-------------------Origin--------------");
        for(i=0;i<array_num.length;i++){
            System.out.print(array_num[i]+" ");
        }
        for(i=0;i<array_num.length;i++){
            k=i;
            for(j=i+1;j<array_num.length;j++){
                if(array_num[j]<array_num[k]){
                    k=j;
                }
            }
            if(k!=i){
                l=array_num[i];
                array_num[i]=array_num[k];
                array_num[k]=l;
            }
        }
        System.out.println("\n---------------After Sorting-----------");
        for(i=0;i<array_num.length;i++){
            System.out.print(array_num[i]+" ");
        }
        return array_num;
    }

输出结果：
选择排序结果

插入排序

原理：
每次把1个元素按照关键字的大小插入到前面已排好序的子序列中。

① 直接插入排序
在子序列中倒序查找第一个不比该元素大的位置 j ，在子序列中 j 后的元素全部后移，并将该元素插入至位置 j+1 。

JAVA源码：

public static int[] insert(int[] array_num){
        int i,j,k;
        System.out.println("-------------------Origin----------------------------");
        for(i=0;i<array_num.length;i++){
            System.out.print(array_num[i]+" ");
        }
        for(i=1;i<array_num.length;i++){
            k=array_num[i];
            for(j=i-1;j>=0&&array_num[j]>k;j--){
                array_num[j+1]=array_num[j];
            }
            array_num[j+1]=k;
        }
        System.out.println("\n-------------------After Inserting Sort--------------");
        for(i=0;i<array_num.length;i++){
            System.out.print(array_num[i]+" ");
        }
        return array_num;
    }

输出结果：

② 二分插入排序
原理：
在直接插入排序基础上，二分查找要插入的位置。

JAVA源码：

 public static int[] mid_insert(int[] array_num){
        int i,j,k,l,r,mid;
        System.out.println("------------------Origin----------------------");
        for(i=0;i<array_num.length;i++){
            System.out.print(array_num[i]+" ");
        }
        for(i=1;i<array_num.length;i++){
           k=array_num[i];
           l=0;
           r=i-1;
           while(l<=r){
               mid=(l+r)/2;
               if(array_num[mid]>k){
                   r=mid-1;
               }
               else{
                   l=mid+1;
               }
           }
           for(j=i-1;j>r;j--){
               array_num[j+1]=array_num[j];
           }
           array_num[j+1]=k;
        }
        System.out.println("\n------------------Mid-Insert ASC--------------");
        for(i=0;i<array_num.length;i++){
            System.out.print(array_num[i]+" ");
        }
        return array_num;
    }

输出结果：
二分插入排序
③ 希尔排序
原理：
按照增量，将数组分为多个序列，分别进行直接插入排序。增量从数组大小的一半一直除2直至减为1。
即对于增量d，原数组可分为（0,d,2d,…,nd）,(1,d+1,2d+1,…,nd+1)等序多个序列。
JAVA源码：

public static int[] shell_sort(int[] array_num) {
        int i,j,k,increment;
        System.out.println("\n--------------Origin----------------------");
        for(i=0;i<array_num.length;i++){
            System.out.print(array_num[i]+" ");
        }
        for(increment=array_num.length/2;increment>0;increment/=2){
            for(i=increment;i<array_num.length;i++){
                k=array_num[i];
                for(j=i-increment;j>=0&&array_num[j]>k;j-=increment){
                    array_num[j+increment]=array_num[j];
                }
                array_num[j+increment]=k;
            }
        }
        System.out.println("\n--------------Shell-Sort ASC--------------");
        for(i=0;i<array_num.length;i++){
            System.out.print(array_num[i]+" ");
        }
        return array_num;
    }

输出结果：
希尔排序结果
希尔排序方法二：原始子序列加上待排序数一起判断，小的在前，大的在后。

JAVA源码：

    public static int[] shell_swap(int[] array_num) {
        int i,j,k,increment;
        System.out.println("\n--------------Origin----------------------");
        for(i=0;i<array_num.length;i++){
            System.out.print(array_num[i]+" ");
        }
        for(increment=array_num.length/2;increment>0;increment/=2){
            for(i=increment;i<array_num.length;i++){
                for(j=i-increment;j>=0&&array_num[j+increment]<array_num[j];j-=increment){
                    k=array_num[j];
                    array_num[j]=array_num[j+increment];
                    array_num[j+increment]=k;
                }
            }
        }
        System.out.println("\n--------------Shell-Sort ASC--------------");
        for(i=0;i<array_num.length;i++){
            System.out.print(array_num[i]+" ");
        }
        return array_num;
    }

快速排序

原理：
数组中找一个base，比它小的数在左，大的在右。左右再各自做快速排序，直到没有元素。

JAVA源码：

/*递归快排，通过中间值位置分割数组，对左右两个数组再次快排*/
    public static void quicksort(int[] array_num,int low,int high){
        if(low<high){
            int dp=partion(array_num,low,high),k;
            quicksort(array_num,low,dp-1);
            quicksort(array_num,dp+1,high);
        }
    }
    /*设定最后一位为base，扫一遍[low,high),n小的放在nth位置，base与第一个比base大的数交换位置并返回该位置*/
    public static int partion(int[] array_num,int low,int high){
        int i,j,k,base;
        base=array_num[high];
        i=low-1;
        for(j=low;j<high;j++){
            if(array_num[j]<base){
                i++;
                k=array_num[j];
                array_num[j]=array_num[i];
                array_num[i]=k;
            }
        }
        k=array_num[i+1];
        array_num[i+1]=base;
        array_num[high]=k;
        return i+1;
   }

输出结果：
快速排序结果