Java各种排序算法

最新推荐文章于 2024-04-27 17:58:54 发布
最新推荐文章于 2024-04-27 17:58:54 发布
阅读量260 收藏
点赞数
分类专栏： Java 排序 文章标签： Java 排序

转自：http://www.oschina.net/code/snippet_120166_6102?p=2

//插入排序:
 
package org.rut.util.algorithm.support;
 
import org.rut.util.algorithm.SortUtil;
/**
  * @author treeroot
  * @since 2006-2-2
  * @version 1.0
  */
public class InsertSort implements SortUtil.Sort{
 
     /** (non-Javadoc)
      * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
      */
     public void sort( int [] data) {
         int temp;
         for ( int i= 1 ;i<data.length;i++){
             for ( int j=i;(j> 0 )&&(data[j]<data[j- 1 ]);j--){
                 SortUtil.swap(data,j,j- 1 );
             }
         }       
     }
 
}
//冒泡排序:
 
 
for (var i= 0 ; i<arr.length; i++) {   
     for (var j=i+ 1 ; j<=arr.length- 1 ; j++) {
         if (eval(arr[i]) < eval(arr[j])) {       
             temp = arr[i];                     
             arr[i] = arr[j];                       
             arr[j] = temp;                                             
         }
     }
}
 
 
 
package org.rut.util.algorithm.support;
 
import org.rut.util.algorithm.SortUtil;
 
/**
  * @author treeroot
  * @since 2006-2-2
  * @version 1.0
  */
public class BubbleSort implements SortUtil.Sort{
 
     /** (non-Javadoc)
      * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
      */
     public void sort( int [] data) {
         int temp;
         for ( int i= 0 ;i<data.length;i++){
             for ( int j=data.length- 1 ;j>i;j--){
                 if (data[j]<data[j- 1 ]){
                     SortUtil.swap(data,j,j- 1 );
                 }
             }
         }
     }
 
}
 
//选择排序:
 
package org.rut.util.algorithm.support;
 
import org.rut.util.algorithm.SortUtil;
 
/**
  * @author treeroot
  * @since 2006-2-2
  * @version 1.0
  */
public class SelectionSort implements SortUtil.Sort {
 
     /**
      * (non-Javadoc)
      *
      * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
      */
     public void sort( int [] data) {
         int temp;
         for ( int i = 0 ; i < data.length; i++) {
             int lowIndex = i;
             for ( int j = data.length - 1 ; j > i; j--) {
                 if (data[j] < data[lowIndex]) {
                     lowIndex = j;
                 }
             }
             SortUtil.swap(data,i,lowIndex);
         }
     }
 
}
 
//Shell排序:
 
package org.rut.util.algorithm.support;
 
import org.rut.util.algorithm.SortUtil;
 
/**
  * @author treeroot
  * @since 2006-2-2
  * @version 1.0
  */
public class ShellSort implements SortUtil.Sort{
 
     /** (non-Javadoc)
      * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
      */
     public void sort( int [] data) {
         for ( int i=data.length/ 2 ;i> 2 ;i/= 2 ){
             for ( int j= 0 ;j<i;j++){
                 insertSort(data,j,i);
             }
         }
         insertSort(data, 0 , 1 );
     }
 
     /**
      * @param data
      * @param j
      * @param i
      */
     private void insertSort( int [] data, int start, int inc) {
         int temp;
         for ( int i=start+inc;i<data.length;i+=inc){
             for ( int j=i;(j>=inc)&&(data[j]<data[j-inc]);j-=inc){
                 SortUtil.swap(data,j,j-inc);
             }
         }
     }
 
}
 
//快速排序:
 
package org.rut.util.algorithm.support;
 
import org.rut.util.algorithm.SortUtil;
 
/**
  * @author treeroot
  * @since 2006-2-2
  * @version 1.0
  */
public class QuickSort implements SortUtil.Sort{
 
     /** (non-Javadoc)
      * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
      */
     public void sort( int [] data) {
         quickSort(data, 0 ,data.length- 1 );       
     }
     private void quickSort( int [] data, int i, int j){
         int pivotIndex=(i+j)/ 2 ;
         //swap
         SortUtil.swap(data,pivotIndex,j);
         
         int k=partition(data,i- 1 ,j,data[j]);
         SortUtil.swap(data,k,j);
         if ((k-i)> 1 ) quickSort(data,i,k- 1 );
         if ((j-k)> 1 ) quickSort(data,k+ 1 ,j);
         
     }
     /**
      * @param data
      * @param i
      * @param j
      * @return
      */
     private int partition( int [] data, int l, int r, int pivot) {
         do {
            while (data[++l]<pivot);
            while ((r!= 0 )&&data[--r]>pivot);
            SortUtil.swap(data,l,r);
         }
         while (l<r);
         SortUtil.swap(data,l,r);       
         return l;
     }
 
}
//改进后的快速排序:
 
package org.rut.util.algorithm.support;
 
import org.rut.util.algorithm.SortUtil;
 
/**
  * @author treeroot
  * @since 2006-2-2
  * @version 1.0
  */
public class ImprovedQuickSort implements SortUtil.Sort {
 
     private static int MAX_STACK_SIZE= 4096 ;
     private static int THRESHOLD= 10 ;
     /** (non-Javadoc)
      * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
      */
     public void sort( int [] data) {
         int [] stack= new int [MAX_STACK_SIZE];
         
         int top=- 1 ;
         int pivot;
         int pivotIndex,l,r;
         
         stack[++top]= 0 ;
         stack[++top]=data.length- 1 ;
         
         while (top> 0 ){
             int j=stack[top--];
             int i=stack[top--];
             
             pivotIndex=(i+j)/ 2 ;
             pivot=data[pivotIndex];
             
             SortUtil.swap(data,pivotIndex,j);
             
             //partition
             l=i- 1 ;
             r=j;
             do {
                 while (data[++l]<pivot);
                 while ((r!= 0 )&&(data[--r]>pivot));
                 SortUtil.swap(data,l,r);
             }
             while (l<r);
             SortUtil.swap(data,l,r);
             SortUtil.swap(data,l,j);
             
             if ((l-i)>THRESHOLD){
                 stack[++top]=i;
                 stack[++top]=l- 1 ;
             }
             if ((j-l)>THRESHOLD){
                 stack[++top]=l+ 1 ;
                 stack[++top]=j;
             }
             
         }
         //new InsertSort().sort(data);
         insertSort(data);
     }
     /**
      * @param data
      */
     private void insertSort( int [] data) {
         int temp;
         for ( int i= 1 ;i<data.length;i++){
             for ( int j=i;(j> 0 )&&(data[j]<data[j- 1 ]);j--){
                 SortUtil.swap(data,j,j- 1 );
             }
         }      
     }
 
}
 
//归并排序:
 
package org.rut.util.algorithm.support;
 
import org.rut.util.algorithm.SortUtil;
 
/**
  * @author treeroot
  * @since 2006-2-2
  * @version 1.0
  */
public class MergeSort implements SortUtil.Sort{
 
     /** (non-Javadoc)
      * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
      */
     public void sort( int [] data) {
         int [] temp= new int [data.length];
         mergeSort(data,temp, 0 ,data.length- 1 );
     }
     
     private void mergeSort( int [] data, int [] temp, int l, int r){
         int mid=(l+r)/ 2 ;
         if (l==r) return ;
         mergeSort(data,temp,l,mid);
         mergeSort(data,temp,mid+ 1 ,r);
         for ( int i=l;i<=r;i++){
             temp[i]=data[i];
         }
         int i1=l;
         int i2=mid+ 1 ;
         for ( int cur=l;cur<=r;cur++){
             if (i1==mid+ 1 )
                 data[cur]=temp[i2++];
             else if (i2>r)
                 data[cur]=temp[i1++];
             else if (temp[i1]<temp[i2])
                 data[cur]=temp[i1++];
             else
                 data[cur]=temp[i2++];           
         }
     }
 
}
 
//改进后的归并排序:
 
package org.rut.util.algorithm.support;
 
import org.rut.util.algorithm.SortUtil;
 
/**
  * @author treeroot
  * @since 2006-2-2
  * @version 1.0
  */
public class ImprovedMergeSort implements SortUtil.Sort {
 
     private static final int THRESHOLD = 10 ;
 
     /**
      * (non-Javadoc)
      *
      * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
      */
     public void sort( int [] data) {
         int [] temp= new int [data.length];
         mergeSort(data,temp, 0 ,data.length- 1 );
     }
 
     private void mergeSort( int [] data, int [] temp, int l, int r) {
         int i, j, k;
         int mid = (l + r) / 2 ;
         if (l == r)
             return ;
         if ((mid - l) >= THRESHOLD)
             mergeSort(data, temp, l, mid);
         else
             insertSort(data, l, mid - l + 1 );
         if ((r - mid) > THRESHOLD)
             mergeSort(data, temp, mid + 1 , r);
         else
             insertSort(data, mid + 1 , r - mid);
 
         for (i = l; i <= mid; i++) {
             temp[i] = data[i];
         }
         for (j = 1 ; j <= r - mid; j++) {
             temp[r - j + 1 ] = data[j + mid];
         }
         int a = temp[l];
         int b = temp[r];
         for (i = l, j = r, k = l; k <= r; k++) {
             if (a < b) {
                 data[k] = temp[i++];
                 a = temp[i];
             } else {
                 data[k] = temp[j--];
                 b = temp[j];
             }
         }
     }
 
     /**
      * @param data
      * @param l
      * @param i
      */
     private void insertSort( int [] data, int start, int len) {
         for ( int i=start+ 1 ;i<start+len;i++){
             for ( int j=i;(j>start) && data[j]<data[j- 1 ];j--){
                 SortUtil.swap(data,j,j- 1 );
             }
         }
     }
 
}
//堆排序:
 
package org.rut.util.algorithm.support;
 
import org.rut.util.algorithm.SortUtil;
 
/**
  * @author treeroot
  * @since 2006-2-2
  * @version 1.0
  */
public class HeapSort implements SortUtil.Sort{
 
     /** (non-Javadoc)
      * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
      */
     public void sort( int [] data) {
         MaxHeap h= new MaxHeap();
         h.init(data);
         for ( int i= 0 ;i<data.length;i++)
             h.remove();
         System.arraycopy(h.queue, 1 ,data, 0 ,data.length);
     }
 
 
      private static class MaxHeap{
          
         
         void init( int [] data){
             this .queue= new int [data.length+ 1 ];
             for ( int i= 0 ;i<data.length;i++){
                 queue[++size]=data[i];
                 fixUp(size);
             }
         }
          
         private int size= 0 ;
 
         private int [] queue;
                 
         public int get() {
             return queue[ 1 ];
         }
 
         public void remove() {
             SortUtil.swap(queue, 1 ,size--);
             fixDown( 1 );
         }
         //fixdown
         private void fixDown( int k) {
             int j;
             while ((j = k << 1 ) <= size) {
                 if (j < size && queue[j]<queue[j+ 1 ])
                     j++;
                 if (queue[k]>queue[j]) //不用交换
                     break ;
                 SortUtil.swap(queue,j,k);
                 k = j;
             }
         }
         private void fixUp( int k) {
             while (k > 1 ) {
                 int j = k >> 1 ;
                 if (queue[j]>queue[k])
                     break ;
                 SortUtil.swap(queue,j,k);
                 k = j;
             }
         }
 
     }
 
}
 
  
 
//SortUtil:
 
package org.rut.util.algorithm;
 
import org.rut.util.algorithm.support.BubbleSort;
import org.rut.util.algorithm.support.HeapSort;
import org.rut.util.algorithm.support.ImprovedMergeSort;
import org.rut.util.algorithm.support.ImprovedQuickSort;
import org.rut.util.algorithm.support.InsertSort;
import org.rut.util.algorithm.support.MergeSort;
import org.rut.util.algorithm.support.QuickSort;
import org.rut.util.algorithm.support.SelectionSort;
import org.rut.util.algorithm.support.ShellSort;
 
/**
  * @author treeroot
  * @since 2006-2-2
  * @version 1.0
  */
public class SortUtil {
     public final static int INSERT = 1 ;
 
     public final static int BUBBLE = 2 ;
 
     public final static int SELECTION = 3 ;
 
     public final static int SHELL = 4 ;
 
     public final static int QUICK = 5 ;
 
     public final static int IMPROVED_QUICK = 6 ;
 
     public final static int MERGE = 7 ;
 
     public final static int IMPROVED_MERGE = 8 ;
 
     public final static int HEAP = 9 ;
 
     public static void sort( int [] data) {
         sort(data, IMPROVED_QUICK);
     }
     private static String[] name={
             "insert" , "bubble" , "selection" , "shell" , "quick" , "improved_quick" , "merge" , "improved_merge" , "heap"
     };
     
     private static Sort[] impl= new Sort[]{
             new InsertSort(),
             new BubbleSort(),
             new SelectionSort(),
             new ShellSort(),
             new QuickSort(),
             new ImprovedQuickSort(),
             new MergeSort(),
             new ImprovedMergeSort(),
             new HeapSort()
     };
 
     public static String toString( int algorithm){
         return name[algorithm- 1 ];
     }
     
     public static void sort( int [] data, int algorithm) {
         impl[algorithm- 1 ].sort(data);
     }
 
     public static interface Sort {
         public void sort( int [] data);
     }
 
     public static void swap( int [] data, int i, int j) {
         int temp = data[i];
         data[i] = data[j];
         data[j] = temp;
     }
}
刘浮夸
关注
专栏目录
Java各种排序算法代码.zip
05-31
这个名为"Java各种排序算法代码.zip"的压缩包包含了一系列实现不同排序算法的Java源代码。排序算法是计算机科学中的基本概念，用于对一组数据进行排列。下面将详细讨论这些算法及其在Java中的实现。 1. 冒泡排序...
java各种排序算法总结
11-18
排序算法，就是如何使得记录按照要求排列的方法。排序算法在很多领域得到相当地重视，尤其是在大量数据的处理方面。一个优秀的算法可以节省大量的资源。在各个领域中考虑到数据的各种限制和规范，要得到一个符合实际...
详解Java常用排序算法（10种，含演示动画）
不积跬步无以至千里，不积小流无以成江海。一个喜欢学习分享的程序员
06-30 2万+
Java常用的排序算法有以下几种： 1. 冒泡排序；2. 选择排序；3. 插入排序；4. 希尔排序；5. 归并排序；6. 快速排序；7. 堆排序；8. 计数排序；9. 桶排序；10. 基数排序。 这些排序算法都有各自的优缺点，应根据具体情况选择适合的算法。
java实现10种排序算法
热门推荐
weixin_622464的博客
05-06 7万+
1.冒泡排序(Bubble Sort) import java.util.Arrays; //冒泡排序 public class BubbleSort_01 { public static void main(String[] args) { int a[]={3,44,38,5,47,15,36,26,27,2,46,4,19,50,48}; //记录比较次数 int count=0; //i=0,第一轮比较 for (int i = 0; i < a.length-1; i
深入探索Java中的多种排序算法及其应用场景
聚焦于深度解析最新的编程语言特性、框架升级、架构设计、开发工具和最佳实践，涵盖Web前端（如Vue3, React, Angular等）、后端开发（如Node.js, Java, Python等）、移动端开发（iOS, Android原生及跨平台开发）
03-29 2万+
在实际开发中，Java的Arrays.sort()方法底层实现了高度优化的TimSort算法，结合了归并排序和插入排序的优点，适用于大多数通用排序场景。尽管如此，理解和掌握各类排序算法仍然是提高算法思维和优化程序性能的重要手段。开发者应根据实际需求，结合数据特性和规模，灵活选择并应用相应的排序算法。
Java常见排序算法
Meng
07-10 2436
目录1、归并排序2、堆排序3、基数排序4、冒泡排序5、希尔排序6、快速排序7、插入排序8、选择排序1、基本思想归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。2、代码实现1、基本思想堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好，平均时间复杂度均为O(
十大经典排序算法（Java实现）
qq_43794633的博客
12-04 2万+
为了加深对这十种算法的理解，固写此文。首先可用如下表来简单概括这十种算法： 目录1、冒泡排序2、选择排序3、插入排序4、希尔排序5、归并排序6、快速排序7、堆排序8、计数排序9、桶排序10、基数排序 十大经典排序算法 平均时间复杂度 最好时间复杂度 最坏时间复杂度 空间复杂度 排序方式 稳定性 冒泡排序 O\OmicronO(n2) O\OmicronO(n) O\OmicronO(n2) O\OmicronO(1) In-place 稳定 选择排序 O\OmicronO(n2) O\O
十大排序算法（Java实现）
ji_meng的博客
06-27 3817
1.冒泡排序 2.快速排序
java插入排序算法及示例
mr_lili_1986的博客
04-27 4064
java插入排序算法及示例
Java实现排序算法
上庸者-不服周
06-14 1948
排序算法
Java语言实现常用的十种排序算法
Young_深情不及里子的博客
02-23 2276
排序问题一直都是程序工作或面试中的重点，特别是对于排序算法而言，在一些公司的笔试中，手写个冒泡啥的也不足为奇，因此今天抽空整理一下Java语言实现的各类排序算法，互勉学习一下。
十大经典排序算法——java语言
weixin_56781779的博客
11-11 6304
一、冒泡排序 二、选择排序 三、插入排序 四、希尔排序 五、归并排序 六、快速排序 七、堆排序 八、计数排序 九、桶排序 十、基数排序
Java各种排序算法代码.7z
07-12
这里，我们将深入探讨一些常见的Java排序算法，包括它们的工作原理、优缺点以及适用场景。 1. 冒泡排序（Bubble Sort）： 冒泡排序是一种简单的交换排序，通过重复遍历数组，比较相邻元素并根据需要交换它们，直到...
Java各种排序算法.pdf
07-14
Java 排序算法 Java 排序算法是计算机科学中的一种基本算法，用于将一组无序的数据转换为有序的数据。排序算法可以分为内部排序和外部排序两种，内部排序是指在计算机内存中进行排序，而外部排序是指在外存储器中...
经济补偿金、赔偿金的核定及劳动合同解除后双方的义务.ppt
09-14
经济补偿金、赔偿金的核定及劳动合同解除后双方的义务.ppt
配电网分布式电源和储能选址定容 以配电网总成本最低为目标函数，其中包括年运行成本，设备维护折损成本、环境成本；以系统潮流运行为约
09-14
配电网分布式电源和储能选址定容 以配电网总成本最低为目标函数，其中包括年运行成本，设备维护折损成本、环境成本；以系统潮流运行为约束条件，采用粒子群算法求解，实现光伏、风电、储能设备的规划。 这是一个使用粒子群算法进行优化的程序。下面我将对程序进行详细的分析和解释。 首先，程序开始时加载了一些数据文件，包括光伏、风电和负荷的数据。然后，定义了一些参数，如蓄电池参数、迭代次数、种群大小、速度更新参数等。 接下来，程序进行了种群的初始化。使用随机数生成种群的初始位置，并初始化速度。然后，对种群中的每个个体进行潮流计算，并计算适应度。适应度的计算包括对电压、网损等进行评估，并考虑了一些约束条件，如储能容量、光伏容量等的限制。 接下来，程序进行了迭代优化过程。在每次迭代中，根据当前的速度和位置，更新粒子的速度和位置。然后，对更新后的粒子进行潮流计算，并计算适应度。如果个体的适应度优于个体历史最佳适应度，则更新个体历史最佳适应度和位置。如果个体的适应度优于全局最佳适应度，则更新全局最佳适应度和位置。 程序通过迭代优化过程不断更新粒子的速度和位置，直到达到指定的迭代次数。最后，程序输出优化结
Cpp-halcono-pencv互相转换
最新发布
09-14
Cpp_halcon_opencv互相转换 python halcon_opencv图像变量互相转换 C++ halcon 和opencv 图像变量互相转换 VS2022工程 无需配置环境即可 使用绝对路径 无需配置 无需配置 无需配置 下载即可编译生成 仅限交流学习使用;仅限交流学习使用;仅限交流学习使用;
××部20xx年人员裁员分流方案表.xlsx
09-14
××部20xx年人员裁员分流方案表.xlsx
Java排序算法详解与实现
【资源摘要信息】: "Java排序算法汇总，包括插入排序、交换排序、选择排序、归并排序和基数排序。适用于不同规模和顺序的数组，选择合适的排序算法能提高效率。" 在计算机科学中，排序算法是用于对一组数据进行排序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值