(选择，冒泡，插入，归并，希尔，快速)排序算法java预览

最新推荐文章于 2024-11-10 21:43:58 发布
最新推荐文章于 2024-11-10 21:43:58 发布
阅读量77 收藏
点赞数
文章标签： 算法 Java J# 数据结构 Blog

刚捣鼓了一下数据结构和算法 把总结写下，本内容和 my csdn一样http://blog.csdn.net/maomaolingyu

package source.datastruct_algorithm;

import java.util.Random;

public class SortUtil {
    static int size =10000;
    static VirtualObj[] persion ;
    static long[] arr ;
    @SuppressWarnings("unchecked")
    static synchronized void init(){
        persion = new VirtualObj[size];
        arr = new long[size];
        int[] ran_arr = randomInt();
        for(int i=0;i<size;i++){
            persion[i] = new VirtualObj("tom"+ran_arr[i],ran_arr[i],ran_arr[i]);
        }
        for(int i =0;i<size;i++){
            arr[i] = ran_arr[i];
        }
        Proxy.serviceProxy().initLongArr(arr);
        Proxy.serviceProxy().initObjArr(persion);
    }
    private static int[] randomInt(){
        Random ran = new Random();
         boolean[] bool = new boolean[size];
         int rs[] = new int[size];
        int temp,j=0;
        for(int i=0;i<size;i++){
            do{
                temp = ran.nextInt(size);
            }while(bool[temp]);
            bool[temp] =true;
            rs[j++]=temp;
        }
        return rs;
    }
    public void setBaseArray(long[] array){
        arr= array;
        size= array.length;
    }
   
    public void setObjArray(Object[] arr){
        persion = (VirtualObj[])arr;
        size= persion.length;
    }
    public static void bubbleSort(){
        Proxy.serviceProxy().baseBubbleSort();
        Proxy.serviceProxy().objBubbleSort();
    }
    public static void selectSort(){
        Proxy.serviceProxy().baseSelectSort();
        Proxy.serviceProxy().objSelectSort();
    }   
    public static void insertSort(){
        Proxy.serviceProxy().baseInsertSort();
        Proxy.serviceProxy().objInsertSort();
    }
    public static void mergeSort(){
        Proxy.serviceProxy().baseUnionSort();
        Proxy.serviceProxy().objUnionSort();   
    }   
    public static void shellSort(){
        Proxy.serviceProxy().baseShellSort();
        Proxy.serviceProxy().objShellSort();
    }   
    public static void quickSort(){
        Proxy.serviceProxy().baseQuickSort();
        Proxy.serviceProxy().objQuickSort();
    }
    public static void main(String[] args) {
        init();
        System.out.println(System.currentTimeMillis());
        bubbleSort();
        System.out.println(System.currentTimeMillis());
        System.out.println("bubble sort ..............................");
        init();
        System.out.println(System.currentTimeMillis());
        selectSort();
        System.out.println(System.currentTimeMillis());
        System.out.println("select sort ..............................");
        System.out.println(System.currentTimeMillis());
        init();
        insertSort();
        System.out.println(System.currentTimeMillis());
        System.out.println("insert sort ..............................");
        init();
        System.out.println(System.currentTimeMillis());
        mergeSort();
        System.out.println(System.currentTimeMillis());
        System.out.println("merge sort ..............................");
        init();
        System.out.println(System.currentTimeMillis());
        shellSort();
        System.out.println(System.currentTimeMillis());
        System.out.println("shell sort ..............................");
        init();
        System.out.println(System.currentTimeMillis());
        quickSort();
        System.out.println(System.currentTimeMillis());
        System.out.println("quick sort ..............................");
    }

}

class Proxy{
    @SuppressWarnings("rawtypes")
    private static SortService service = new SortService();
    @SuppressWarnings("rawtypes")
    public static SortService serviceProxy(){
        return service;
    }
}


class SortService<T extends VirtualObj>{
    private long[] longArr;
    private T[] objArr;
    private int size;
    public void initLongArr(long[] arr){
        longArr = arr;
        size = arr.length;
    }
    public void initObjArr(T[] arr){
        objArr = arr;
        size = arr.length;
    }
   
    public void baseQuickSort(){
        baseRecQuicSort(0, size-1);
        displayLongArr();
    }
    //基本类型的快速排序
    private void baseRecQuicSort(int left,int right){
        if(right - left +1 <=10){
            baseInsertSort(left,right);
        }else{
            long povit = baseGetPivot(left, right);
            //long povit = longArr[right];
            int compareIndex = basePartition(left,right,povit);
            baseRecQuicSort(left,compareIndex);
            baseRecQuicSort(compareIndex+1, right);
        }
    }
    //快速排序时的插入排序
    private void baseInsertSort(int left,int right){
        int j=0;
        for(int i=left+1;i<=right;i++){
            long temp = longArr[i];
            for(j =i;j>left&&longArr[j-1]>temp;j--){
                longArr[j]=longArr[j-1];
            }
            longArr[j] = temp;
        }
       
    }
    //3项取中，防止数据不随机
    private long baseGetPivot(int left,int right){
        int center = (left + right)/2;
        if(longArr[left] <= longArr[center]){
            swap(left, center);
        }
        if(longArr[left]<= longArr[right]){
            swap(left, right);
        }
         if(longArr[center] > longArr[right]){
             swap(center, right);
         }
       
        return longArr[right];
    }
    //快速排序
    private int basePartition(int left,int right,long povit){
        int leftindex = left;
        int rightindex = right-1;
        while(true){
            while(longArr[++leftindex] < povit);
            while((--rightindex)>0&&longArr[rightindex] > povit);
            if(leftindex >= rightindex)break;
            else{
                swap(leftindex, rightindex);
            }
        }swap(leftindex, right -1);
        return leftindex;
    }
    //交换
    private void swap(int indexFrom,int indexTo){
        long temp = longArr[indexFrom];
        longArr[indexFrom] = longArr[indexTo];
        longArr[indexTo] = temp;
    }
    //对象类型快速排序
    public void objQuickSort(){
        objRecQuickSort(0,size-1);
        displayObjArr();
    }
    //对象类型快速排序
    private void objRecQuickSort(int left,int right){
        if(right - left <10){
            objInsertSort(left,right);
        }
        else{
            T compareObj = objGetPovit(left,right);
            //T compareObj = objArr[right];
            int compareIndex = objPartion(left,right,compareObj);
            objRecQuickSort(left, compareIndex);
            objRecQuickSort(compareIndex+1, right);
        }
    }
    //对象快速排序
    private int objPartion(int left,int right,T povit){
        int leftindex = left;
        int rightindex = right-1;
        while(true){
            while(objArr[++leftindex].getStr().compareTo(povit.getStr())<0);
            while(objArr[--rightindex].getStr().compareTo(povit.getStr())>0);
            if(leftindex >= rightindex)break;
            else{
                swapObj(leftindex, rightindex);
            }
        }swapObj(leftindex, right-1);
        return leftindex;
    }
    //对象插入排序
    private void objInsertSort(int left,int right){
        int i=0;
        for(int j =left+1;j<size;j++){
            T temp = objArr[j];
            for(i=j;i>left&&objArr[i-1].getStr().compareTo(temp.getStr())>0;i--){
                objArr[i] = objArr[i-1];
            }
            objArr[i] = temp;
        }
    }
    //3项取中 针对数组不大小不随机
    private T objGetPovit(int left,int right){
        int center = (right + left)/2;
        T t_left = objArr[left];
        T t_center = objArr[center];
        T t_right = objArr[right];
        if(t_left.getStr().compareTo(t_center.getStr()) >0){
            swapObj(left,center);
        }
        if(t_center.getStr().compareTo(t_right.getStr()) <0){
            swapObj(center, right);
        }
        if(t_left.getStr().compareTo(t_right.getStr()) >0){
            swapObj(left, right);
        }   
        return objArr[right];
    }
    //对象交换
    private void swapObj(int from,int to){
        T temp = objArr[from];
        objArr[from] = objArr[to];
        objArr[to] = temp;
    }
   
    //基本类型希尔排序  增量-3
    public void baseShellSort(){
        int h=1;
        int in,out;
        while(h<size/3){
            h=h*3+1;
        }
       
        while(h>0){
            for(out = h;out<size;out++){
                long temp = longArr[out];
                for(in=out;in > h-1&&longArr[in-h] >= temp;in-=h){
                    longArr[in] = longArr[in-h];
                }
                longArr[in] = temp;
            }
            h=(h-1)/3;
        }
        displayLongArr();
    }
    //对象类型希尔排序  增量-3
    public void objShellSort(){
        int h=1;
        int in,out;
        while(h<size/3){
            h=h*3+1;
        }
       
        while(h>0){
            for(out = h;out<size;out++){
                T temp = objArr[out];
                for(in=out;in > h-1&&objArr[in-h].getStr().compareTo(temp.getStr())>0;in-=h){
                    objArr[in] = objArr[in-h];
                }
                objArr[in] = temp;
            }
            h=(h-1)/3;
        }
        displayObjArr();
    }
   
    //基本类型归并排序
    public void baseUnionSort(){
        long[] workspace = new long[size];
        baseMergeSort(workspace,0, workspace.length-1);
        displayLongArr();
    }

    //归并算法
    private void baseMergeSort(long[] arr,int lower,int upper){
        if(lower == upper)return;
        int mid = (upper+lower)/2;
        baseMergeSort(arr,lower,mid);
        baseMergeSort(arr,mid+1,upper);
        baseMerge(arr,lower,mid+1,upper);
    }
    //归并排序算法
    private void baseMerge(long[] arr,int lower,int mid,int upper){
        int i=0,middle = mid-1;
        int low = lower;
        int size = (upper - lower)+1;
        while(lower <=middle&&mid<=upper){
            if(longArr[lower] < longArr[mid]){
                arr[i++] = longArr[lower++];
            }
            else{
                arr[i++] = longArr[mid++];
            }
        }
        while(lower<=middle){
            arr[i++] = longArr[lower++];
        }
        while(mid<=upper){
            arr[i++] = longArr[mid++];
        }
        for(int j=0;j<size;j++){
            longArr[low+j] = arr[j];
        }
       
    }
   
    //对象类型归并排序 ： 当有大量重复时，结果不准确
    public void objUnionSort(){
        VirtualObj[] t = new VirtualObj[size];
        objMergeSort((T[])t,0,size-1);
        displayObjArr();
    }
    //归并算法
    private void objMergeSort(T[] arr,int lower,int upper){
        if(lower == upper)return;
        int mid = (upper+lower)/2;
        objMergeSort(arr,lower,mid);
        objMergeSort(arr,mid+1,upper);
        objMerge(arr,lower,mid+1,upper);
    }
    //归并排序算法
    public void objMerge(T[] arr,int lower,int mid,int upper){
        int low = lower;
        int i=0;
        int size = (upper - lower)/2;
        int middle = mid-1;
        while(lower <=middle&&mid<=upper){
            if(objArr[lower].getStr().compareTo(objArr[mid].getStr())<0){
                arr[i++] = objArr[lower++];
            }else{
                arr[i++] = objArr[mid++];
            }
        }
        while(lower <= middle){
            arr[i++] = objArr[lower++];
        }
        while(mid<=upper){
            arr[i++] = objArr[mid++];
        }
        for(int j=0;j<size;j++){
            objArr[low+j] = arr[j];
        }
    }
   
    //基本类型冒泡排序
    public void baseBubbleSort(){
        for(int i =size-1; i>1;i--){
            for(int j = 0 ; j < i ; j ++){
                if(longArr[j] > longArr[j+1]){
                    long temp;
                    temp = longArr[j];
                    longArr[j] = longArr[j+1];
                    longArr[j+1] = temp;
                }
            }
        }
        displayLongArr();
    }
    //对象类型冒泡排序
    public void objBubbleSort(){
        T temp;
        for(int i =size-1; i>1;i--){
            for(int j = 0 ; j < i ; j ++){
                if(objArr[j].getStr().compareTo(objArr[j+1].getStr())>0){
                    temp = objArr[j];
                    objArr[j] = objArr[j+1];
                    objArr[j+1] = temp;
                }
            }
        }
        displayObjArr();
    }
   
    //基本类型插入排序
    public void baseInsertSort(){
        int j;
        for(int i=1;i<size;i++){
            long temp = longArr[i];
            for(j=i;j>i-1&& longArr[j-1]>temp;j--){               
                longArr[j]=longArr[j-1];
            }
            longArr[j]=temp;
        }
        displayLongArr();
    }
    //对象类型插入排序
    public void objInsertSort(){
        int j;
        for(int i=1;i<size;i++){
            T temp = objArr[i];
            for(j=i;j>i-1&& objArr[j-1].getStr().compareTo(temp.getStr())>0;j--){               
                objArr[j]=objArr[j-1];
            }
            objArr[j]=temp;
        }
        displayObjArr();
    }
    //基本类型选择排序
    public void baseSelectSort(){
        for(int i=0;i<size;i++){
            for(int j=i;j<size;j++){
                if(longArr[i]>longArr[j]){
                    long temp;
                    temp = longArr[i];
                    longArr[i] = longArr[j];
                    longArr[j] = temp;
                }
            }
        }
        displayLongArr();
    }
    //对象类型选择排序
    public void objSelectSort(){
        T temp;
        for(int i=0;i<size;i++){
            for(int j=i;j<size;j++){
                if(objArr[i].getStr().compareTo(objArr[j].getStr()) > 0){
                    temp = objArr[i];
                    objArr[i] = objArr[j];
                    objArr[j] = temp;
                }
            }
        }
        displayObjArr();
    }
    public void displayLongArr(){
       
        for(int i =0 ;i<size;i++){
            System.out.print(longArr[i]+" ");
        }System.out.println();
    }
    public void displayObjArr(){
        for(int i =0 ;i<size;i++){
            System.out.print(objArr[i].getStr()+" ");
        }System.out.println();
    }

}

class VirtualObj{
    public VirtualObj() {
        super();
    }
    public VirtualObj(String str, int age, float idCard) {
        super();
        this.str = str;
        this.age = age;
        this.idCard = idCard;
    }
    public String getStr() {
        return str;
    }
    public void setName(String str) {
        this.str = str;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public float getIdCard() {
        return idCard;
    }
    public void setIdCard(float idCard) {
        this.idCard = idCard;
    }

    private String str;
    private int age;
    private float idCard;
   
}

总结 ： 在次测试了数组在1000 和10000的情况 看出 冒泡，选择，插入这三个0(N平方)算法 冒泡最慢，插入稍微由于选择.不过大致相当

而归并和希尔表现出色 . 但是快速排序本以为很好的 表现不如前两者，但是有序前面简单派算法。 经过重复和不重复数据的测试，（只是在该环境下的效率大概如此）.推荐在数据较多重复情况下优先选择 希尔和归并排序.

希尔和归并 随数据增大效率提高可在10倍N

 

iteye_9538
关注
Java实现八个常用的排序算法：插入排序、冒泡排序、选择排序、希尔排序等
09-03
在本文中，我们将深入探讨Java实现的八个经典排序算法，包括它们的工作原理、时间复杂度以及如何用Java代码实现。 1. **插入排序(Insertion Sort)** 插入排序是一种简单直观的排序算法，它的工作原理是通过构建...
八种排序算法原理及Java实现( 冒泡排序+快速排序直接插入排序+希尔排序+选择排序+归并排序+基数排序)
06-21
八种排序算法原理及Java实现是排序算法中的一种，包括冒泡排序、快速排序、直接插入排序、希尔排序、选择排序、归并排序和基数排序等。 冒泡排序是八种排序算法中的一种，属于交换排序。冒泡排序的基本思想是重复...
《冒泡，选择，插入，归并，希尔，快速》排序算法java实现一览
jingtao.gao的专栏
11-04 674
<br />package source.datastruct_algorithm;<br /><br /> import java.util.Random;<br /><br /> public class SortUtil {<br />     static int size =10000;<br />     static VirtualObj[] persion ;<br />     static long[] arr ;<br />    //初始化测试数据<br />     @
Java 排序算法总结(冒泡,选择,插入,希尔)
YuZongTao
03-25 515
亲手写了四个数组排序的算法实现代码，记录下，后面再补充其他排序算法^_^ Java数组排序总结(冒泡,选择,插入,希尔)  实现代码： public class SortAll { public static void main(String args[]) { int[] m = {11,23,435,232,44,3421,454,45,4543,66,4654
Java-十种内部排序实现（选择，冒泡，插入，希尔，堆，归并，快速，基数，计数，桶）及代码下载
nyyin@qq.com
10-07 6553
选择排序 冒泡排序 插入排序 希尔排序 堆排序 归并排序 快速排序 基数排序 计数排序 桶排序 1. 选择排序这个排序方法最简单，废话不多说，直接上代码：public class SelectSort { /** * 选择排序 * 思路:每次循环得到最小值的下标，然后交换数据。 * 如果交换的位置不等于原来的位置，则不交换。 */ public
[算法专题] 二分搜索&排序数组
diaolun4894的博客
08-04 208
基础知识 二分非递归写法： int binary_search(const int a[], const int size, const int val) { int lower = 0; int upper = size-1; /* invariant: if a[i]==val for any i, then lower <= i <= ...
java数组的数据结构_java 数据结构学习之（一）数组
weixin_36475451的博客
02-12 137
数组是应用最广泛的数据结构，也是最简单的数据结构，它有着结构简单，算法通俗易懂的优点。数组又分为有序数组和无序数组，我们通常用的都是无序数组。下面是这两种数组之间的区别无序数组的优点：插入快，根据索引查找快。缺点：在未知数组位置的情况下查找慢，删除慢。有序数组的优点：使用二分法查找快。缺点：插入数据和删除数据慢。因为插入数据要做排序操作。综合以上，可以看出他们各自的使用场景，无序数组适合经常做插入...
六大排序算法：插入排序、希尔排序、选择排序、冒泡排序、堆排序、快速排序
热门推荐
HanMeng的博客
07-24 61万+
文章目录：1. 插入排序2.希尔排序 1. 插入排序 步骤： 1.从第一个元素开始，该元素可以认为已经被排序 2.取下一个元素tem，从已排序的元素序列从后往前扫描 3.如果该元素大于tem，则将该元素移到下一位 4.重复步骤3，直到找到已排序元素中小于等于tem的元素 5.tem插入到该元素的后面，如果已排序所有元素都大于tem，则将tem插入到下标为0的位置 6.重复步骤2~5 动图演示如下： 思路：   在待排序的元素中，假设前n-1个元素已有序，现将第n个元素插入到前面已经排好的序列中，使得前n个
十大排序算法详解（一）冒泡排序、选择排序、插入排序、快速排序、希尔排序
HK的博客
06-27 18万+
冒泡排序、选择排序、插入排序、快速排序、希尔排序
七大排序算法，冒泡排序 选择排序 插入排序 希尔排序 堆排序 快速排序 归并排序的深度讲解
m0_62747332的博客
11-04 2126
排序方法最好平均最坏空间复杂度稳定性冒泡排序O(n)O(n^2)O(n^2)O(1)稳定插入排序O(n)O(n^2)O(n^2)O(1)稳定选择排序O(n^2)O(n^2)O(n^2)O(1)不稳定希尔排序O(n)O(n^1.3)O(n^2)O(1)不稳定堆排序O(1)不稳定快速排序O(n^2)不稳定归并排序O(n)稳定。
【算法】排序算法(插入排序、希尔排序、选择排序、冒泡排序、快速排序、归并排序、基数排序、堆排序)
酷酷的馫博客
12-18 1万+
八大排序算法(插入排序、希尔排序、选择排序、冒泡排序、快速排序、归并排序、基数排序、堆排序)
基于比较的排序算法汇总 选择排序法 插入排序法 归并排序法 快速排序法 堆排序法 冒泡排序法 希尔排序法
01-15
本文将深入探讨标题中提到的几种基于比较的排序算法：选择排序、插入排序、归并排序、快速排序、堆排序、冒泡排序以及希尔排序。 1. **选择排序（Selection Sort）**： - 基本思想：在未排序的序列中找到最小（或...
C++实现八个常用的排序算法：插入排序、冒泡排序、选择排序、希尔排序等
09-03
在本文中，我们将深入探讨C++实现的八种常见的排序算法，它们分别是插入排序、冒泡排序、选择排序、希尔排序、快速排序、归并排序、堆排序和LST基数排序。这些排序算法在计算机科学中有着广泛的应用，是理解和掌握...
7大排序算法实现程序（快速排序，冒泡排序，选择排序，归并排序，插入排序，希尔排序，堆排序）
06-21
本资源提供了七大经典排序算法的实现程序，包括快速排序、冒泡排序、选择排序、归并排序、插入排序、希尔排序和堆排序。下面将逐一详细介绍这些排序算法及其原理。 1. 快速排序：由C.A.R. Hoare提出，是一种采用...
点云配准之点到点，点到面，点到线ICP，NDT算法介绍
最新发布
qq_54375651的博客
11-10 1248
点云配准在人工智能，自动驾驶，SLAM等任务中具有十分关键的作用，本文将介绍点云配准的点到点，点到线，点到面ICP和NDT算法
二分查找习题篇(上)
zoelinkailuo的博客
11-07 989
给定⼀个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。这里，我们把数组的元素分为两部分——小于等于target的部分[left,Bright] and 大于target的部分[Bright+1,right]。这里，我们把数组的元素分为两部分——平方后小于等于x的部分[1,mid] and 平方后大于x的部分[mid-1, x]和一个目标值，在数组中找到目标值，并返回其索引;
数组类算法【leetcode】
随便写写
11-07 365
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。二分查找 用于有序数组中，没有重复的数组。首先需要定义一个头（left）和尾(right)，最后通过mid和target对比不断修改头和尾指向的位置。【需要注意区间问题，根据区间的开和闭决定边界条件】推荐练习 leetcode35.
GJ Round (2024.10) Round 8~21
lunjiahao的博客
11-06 892
前言： 点此 返回 GJ Round 目录 Round 8 (10.5) A 给定 nnn 个区间，每个区间 [li,ri][l_i,r_i][li​,ri​]，最大化选取区间对数，使得每对区间 [li,ri],[lj,rj][l_i,r_i],[l_j,r_j][li​,ri​],[lj​,rj​] 满足 [li,ri]∩[lj,rj]=∅[l_i,r_i] \cap [l_j,r_j] =\varnothing[li​,ri​]∩[lj​,rj​]=∅ 先按 lil_ili​ 从小到大排序，再按
【刷题】优选算法
林宇恒的博客
11-06 517
如图，我们先算出最左边(1)和最右边(7)围起来的容量，然后，7不动，1继续和7的左边3，8，4...遍历算出容量，你会发现底是不断缩短的，同时高一直都是1，因为高只有两种情况，比它小或和它相等，所以1和7左边的值算出来的容量都是比1和7的容量小的，因为底在不断变小同时高可能不变也可能变小。根据两个实例和鸽巢原理可以发现不断的平方和最终都会形成环，所以我们可以联想到用快慢指针，慢指针走一步，快指针走两步，最终会在环相遇，判断相遇时是否为1。第一个实例是快乐数，因为会变为1且不断是1的循环。
C语言实现各种排序算法：冒泡、插入、选择、快速、堆、归并及希尔排序
"本资源提供了C语言实现的多种排序算法，包括冒泡排序、希尔排序、插入排序、选择排序、快速排序、堆排序和归并排序。这些排序算法的时间复杂度从O(n^2)到O(n log n)不等，适用于不同的数据规模和场景。其中，插入...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值