Java排序一共有几种？ java几种基本排序
日常操作中，常见的排序方法有：冒泡排序、快速排序、选择排序、插入排序、希尔排序，甚至还有基数排序、鸡尾酒排序、桶排序、鸽巢排序、归并排序等。
各类排序方法代码如图：
java的排序大的分类可以分为两种：内排序和外排序。在排序过程中，全部记录存放在内存，则称为内排序，如果排序过程中需要使用外存，则称为外排序。下面讲的排序都是属于内排序。
1.插入排序：直接插入排序、二分法插入排序、希尔排序。
2.选择排序：简单选择排序、堆排序。
3.交换排序：冒泡排序、快速排序。
4.归并排序
5.基数排序
插入排序,冒泡排序,选择排序,归并排序,希尔排序,快速排序,都行啊，排序是一个算法而一般不分什么语言的，就是说有了这个思想，用什么语言都能编出来排序的！
http://baike.baidu.com/view/297739.htm
去这儿看，很全的。
其实正常知道 插入排序,冒泡排序,选择排序,快速排序
就基本够了！
数据结构中有几中,JAVA就有几中!
http://topic.csdn.net/u/20080218/15/4302f41c-8c62-4104-b0d0-3d473f121bed.html
Java中排序有多少种？具体代码是什么？~
这里有几个不全的：
import java.io.*;
interface Item
{
public boolean less(Item v);
}
class Recod
{
int id;
String name;
double balance;
static int flag=2;
}
class Sort
{
static boolean less(Item v,Item w)
{
return v.less(w);
}
static void compExch(Item a[],int i,int j)
{
if(less(a[i],a[j]))
exch(a,i,j);
}
static void exch(Item a[],int i,int j)
{
Item t=a[i]; a[i]=a[j]; a[j]=t;
}
//选择排序
static void selSort(Item a[],int l,int r)
{
for(int i=l;i<=r;i++)
{
int max=i;
for(int j=i+1;j<=r;j++)
{
if(less(a[max],a[j])) max=j;
}
if(max!=i)
exch(a,i,max);
}
}
//冒泡
static void maoSort(Item a[],int l,int r)
{
for(int i=l;i<=r;i++)
{
int flag=1;
for(int j=r;j>i;j--)
{
if(less(a[j-1],a[j]))
{
exch(a,j-1,j);
flag=0;
}
}
if(flag==1) break;
}
}
//插入
static void insertSort(Item a[],int l,int r)
{
Item item;
int j=0;
for(int i=1+l;i<=r;i++)
{
item=a[i];
j=i-1;
while(j>=l && less(a[j],item))
{
a[j+1]=a[j];
j--;
}
a[j+1]=item;
}
}
//快排(三路取中加小文件截断)
static void quickSort(Item a[],int l,int r)
{
if((r-l)<=10) insertSort(a,l,r);
else
{
if(l<r)
{
int i=l,j=r,k=(l+r)/2;
compExch(a,r,k);
compExch(a,r,l);
compExch(a,k,l);
exch(a,k,l);
Item item=a[i];
while(i!=j)
{
while(i<j && less(a[j],item))
j--;
if(i<j)
{
a[i]=a[j];
i++;
}
while(i<j && less(item,a[i]))
i++;
if(i<j)
{
a[j]=a[i];
j--;
}
}
a[i]=item;
quickSort(a,l,i-1);
quickSort(a,i+1,r);
}
}
}
//希尔排序
static void shellSort(Item a[],int l,int r)
{
int d=r/2;
Item item;
while(d>0)
{
for(int i=d;i<=r;i++)
{
int j=i-d;
while(j>=l && less(a[j],a[j+d]))
{
item=a[j];
a[j]=a[j+d];
a[j+d]=item;
j=j-d;
}
}
d=d/2;
}
}
}
public class Quick extends Recod implements Item
{
public boolean less(Item v)
{
Quick qu=(Quick)v;
switch(flag)
{
case 2: return id<qu.id;
case 1: return name.compareTo(qu.name)<0;
default:return balance<qu.balance;
}
}
public static void main(String[]args)
{
Quick a[]=new Quick[2000];
for(int i=0;i<2000;i++)
{
a[i]=new Quick();
a[i].id=(int)(1+Math.round(Math.random()*100));
a[i].name="ren"+String.valueOf(i);
a[i].balance=10+Math.random()*100;
System.out.println(a[i].id+" "+a[i].balance);
}
Sort.quickSort(a,0,1999);
System.out.println("**************");
if(flag==2)
for(int j=0;j<2000;j++)
{
System.out.println(a[j].id+" "+a[j].name);
}
else
{
for(int j=0;j<2000;j++)
System.out.println(a[j].balance+" "+a[j].name);
}
}
}
/** * 冒泡排序 * 比较相邻的元素。如果第一个比第二个大，就交换他们两个。 * 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。 * 针对所有的元素重复以上的步骤，除了最后一个。 * 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 * @param numbers 需要排序的整型数组 */ public static void bubbleSort(int[] numbers) { int temp = 0; int size = numbers.length; for(int i = 0 ; i numbers[j+1]) //交换两数位置 { temp = numbers[j]; numbers[j] = numbers[j+1]; numbers[j+1] = temp; } } } }快速排序的基本思想： 通过一趟排序将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另一部分关键字小，则分别对这两部分继续进行排序，直到整个序列有序。/** * 查找出中轴（默认是最低位low）的在numbers数组排序后所在位置 * * @param numbers 带查找数组 * @param low 开始位置 * @param high 结束位置 * @return 中轴所在位置 */ public static int getMiddle(int[] numbers, int low,int high) { int temp = numbers[low]; //数组的第一个作为中轴 while(low temp) { high--; } numbers[low] = numbers[high];//比中轴小的记录移到低端 while(low < high && numbers[low] < temp) { low++; } numbers[high] = numbers[low] ; //比中轴大的记录移到高端 } numbers[low] = temp ; //中轴记录到尾 return low ; // 返回中轴的位置 } 递归形式的分治排序算法： /** * * @param numbers 带排序数组 * @param low 开始位置 * @param high 结束位置 */ public static void quickSort(int[] numbers,int low,int high) { if(low < high) { int middle = getMiddle(numbers,low,high); //将numbers数组进行一分为二 quickSort(numbers, low, middle-1); //对低字段表进行递归排序 quickSort(numbers, middle+1, high); //对高字段表进行递归排序 } }
Java 常见的几种排序算法
答：5、快速排序 6、希尔排序
排序都有哪几种方法?请列举。用JAVA实现一个快速排序。
答：【答案】：排序的方法有：插入排序（直接插入排序、希尔排序），交换排序（冒泡排序、快速排序），选择排序（直接选择排序、堆排序），归并排序，分配排序（箱排序、基数排序）快速排序的伪代码。/ /使用快速排序方法对a[ 0 :n- 1 ]排序 从a[ 0 :n- 1 ]中选择一个元素作为m i d d l e，该...
java中排序方法有哪些
答：1、直接插入排序：最基本的插入排序，将第i个插入到前i-1个中的适当位置。2、折半插入排序：因为是已经确定了前部分是有序序列，所以在查找插入位置的时候可以用折半查找的方法进行查找，提高效率。3、 希尔排序： 又称缩小增量排序法。把待排序序列分成若干较小的子序列，然后逐个使用直接插入排序法...
Java排序一共有几种?
答：日常操作中，常见的排序方法有：冒泡排序、快速排序、选择排序、插入排序、希尔排序，甚至还有基数排序、鸡尾酒排序、桶排序、鸽巢排序、归并排序等。各类排序方法代码如图：
JAVA中有哪几种常用的排序方法?
答：共n-1轮排序处理，第j轮进行n-j次比较和至多n-j次交换。从以上排序过程可以看出，较大的数像气泡一样向上冒，而较小的数往下沉，故称冒泡法。public void bubbleSort(int a[]){ int n = a.length;for(int i=0;i<n-1;i++){ for(int j=0;j<n-i-1;j++){ if(a[j] > a[j+...
java怎么实现排序
答：Java实现几种常见排序方法 日常操作中常见的排序方法有：冒泡排序、快速排序、选择排序、插入排序、希尔排序，甚至还有基数排序、鸡尾酒排序、桶排序、鸽巢排序、归并排序等。以下常见算法的定义 1. 插入排序：插入排序基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的...
java里,几种排序方法各有什么优缺点?
答：六、归并排序 归并排序是多次将两个或两个以上的有序表合并成一个新的有序表。最简单的归并是直接将两个有序的子表合并成一个有序的表。归并排序是稳定的排序.即相等的元素的顺序不会改变.如输入记录 1(1) 3(2) 2(3) 2(4) 5(5) (括号中是记录的关键字)时输出的 1(1) 2(3) 2(4...
Java的排序算法有哪些
答：java的排序大的分类可以分为两种：内排序和外排序。在排序过程中，全部记录存放在内存，则称为内排序，如果排序过程中需要使用外存，则称为外排序。下面讲的排序都是属于内排序。1.插入排序：直接插入排序、二分法插入排序、希尔排序。2.选择排序：简单选择排序、堆排序。3.交换排序：冒泡排序、快速排序。
Java排序算法有哪些
答：直接插入排序，希尔排序，堆排序，冒泡排序，快速排序，归并排序，基数排序，选择排序
java实现几种常见排序算法
答：下面给你介绍四种常用排序算法：1、冒泡排序 特点：效率低，实现简单 思想（从小到大排）：每一趟将待排序序列中最大元素移到最后，剩下的为新的待排序序列，重复上述步骤直到排完所有元素。这只是冒泡排序的一种，当然也可以从后往前排。2、选择排序 特点：效率低，容易实现。思想：每一趟从待排序序列...
