java排序(java排序sort方法)

Java排序算法代码有哪些呢？

  当人们渴望先知道排在前面的是谁时，

* 我们用选择排序；当我们不断拿到新的数并想保持已有的数始终有序时，我们用插入排序；当给出的数

* 列已经比较有序，只需要小幅度的调整一下时，我们用冒泡排序。

public class SortUtil extends Sort {

* 插入排序法

* @param data

* @Des 插入排序(Insertion Sort)是，每次从数列中取一个还没有取出过的数，并按照大小关系插入到已经取出的数中使得已经取出的数仍然有序。

Java中的快速排序源代码有哪些呢？

public class QuickSort {　　public static void main(String[] args) {　　Random random=new Random();　　int[] pData=new int[10];　　for(int i=0;i

　　Integer a =random.nextInt(100);　　pData[i]= a;　　System.out.print(pData[i]+" ");　　}　　System.out.println();　　int left=0;　　int right=pData.length-1;　　Sort(pData,left,right);　　for(int i=0;i

　　System.out.print(pData[i]+" ");　　}　　System.out.println();　　}

java几种基本排序

* 冒泡排序

* 比较相邻的元素。如果第一个比第二个大，就交换他们两个。  

* 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。  

* 针对所有的元素重复以上的步骤，除了最后一个。

* 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 

* @param numbers 需要排序的整型数组
*/
public static void bubbleSort(int[] numbers)
{
int temp = 0;
int size = numbers.length;
for(int i = 0 ; i  
{
for(int j = 0 ;j  
{
if(numbers[j] > 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  
{
while(low  temp)
{
high--;
}
numbers[low] = numbers[high];//比中轴小的记录移到低端
while(low  
{
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  
{
int middle = getMiddle(numbers,low,high); //将numbers数组进行一分为二
quickSort(numbers, low, middle-1);//对低字段表进行递归排序
quickSort(numbers, middle+1, high); //对高字段表进行递归排序
}      

java 排序

第一种用冒泡排序

for (int i = 0; i  
for (int j = i; j  
// 两个数交换
if (arr[i]  
int tmp = Integer.MIN_VALUE;
tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
}
}第二种，使用Arrays.sort()，给你个例子      

import java.util.Arrays;
import java.util.Comparator;
public class $ {
public static void main(String[] args) {
Integer[] a = { 1, 3, 2, 4 };// 不能是基础数据类型,本例中不能是int,必须是Integer
Arrays.sort(a, new Comparator
    
     () {
    
public int compare(Integer o1, Integer o2) {
return o2 - o1;// 降序
// return o1 - o2;//升序
}
});
System.out.println(Arrays.toString(a));
}}你的代码sort里面如果就一个参数，那默认的是按升序Arrays没有提供降序的方法，只有自己写一个排序方法。      

import java.util.Scanner;
import java.util.Arrays;
public class Text {
 public static void main(String[] args) {
 System.out.print("请输入4个数字：");
 Scanner input = new Scanner(System.in);
 int[] a = new int[4];
 for (int i = 0; i  
a[i] = input.nextInt();
 Arrays.sort(a);
 for (int i = a.length; i <= a.length; i++) {
System.out.println(Arrays.toString(a));
 Text.sort(a);
 System.out.println(Arrays.toString(a));
 private static void sort(int[] a) {
 for (int i = 0; i  
for (int j = i + 1; j  
if (a[j] > a[i]) {
int t = a[j];
a[j] = a[i];
a[i] = t;}输出数组的时候从最后一个开始输出就可以了。
}
      

public static void main(String[] args) {
 // TODO Auto-generated method stub
 System.out.print("请输入4个数字：");
 Scanner input =new Scanner(System.in);
// int[] a=new int[4];
 Integer[] a = new Integer[4]; //换成基本类型的类对象
 for(int i=0;i
     
    
 a[i]=input.nextInt();
 Arrays.sort(a,new Comparator
    
     (){ //使用指定比较器方式排序
    
@Override
public int compare(Integer o1, Integer o2) {  //重定义比较器算法
// TODO Auto-generated method stub
return -o1.compareTo(o2);  //调用Ineger的比较算法，返回倒序结果
 });
// for(int i=a.length;i<=a.length;i++)//输出不用再循环了，直接输出
// {  
System.out.println(Arrays.toString(a));
// }
 }...你反过来输出就行了
Arrays.sort(a);
for(int i=a.length;i>0;i--)
System.out.println(a[i-1]);
}排序完再 用一个等长的数组从a的最后一位取起，把最后一位放到其0位……。一直这样就从大到小排了