① java array.sort 對數字的排序方法是什麼,效率怎麼樣api里好像沒有說
效率槐碰肯定高啊，人家編寫jdk源碼的工程師會好意思弄個冒泡排序讓你調用鉛檔談？
具體方法不知道，你可以看看源碼，估計是某種快蠢沒速排序演算法吧。
② Java數組排序 幾種排序方法詳細一點
JAVA中在運用數組進行排序功能時，一般有四種方法：快速排序法、冒泡法、選擇排序法、插入排序法。
快速排序法主要是運用了Arrays中的一個方法Arrays.sort（）實現。
冒泡法是運用遍歷數組進行比較，通過不斷的比較將最小值或者最大值一個一個的遍歷出來。
選擇排序法是將數組的第一個數據作為最大或者最小的值，然後通過比較循環，輸出有序的數組。
插入排序是選擇一個數組中的數據，通過不斷的插入比較最後進行排序。下面我就將他們的實現方法一一詳解供大家參考。
<1>利用Arrays帶有的排序方法快速排序
publicclassTest2{
publicstaticvoidmain(String[]args){
int[]a={5,4,2,4,9,1};
Arrays.sort(a);//進行排序
for(inti:a){
System.out.print(i);
}
}
}<2>冒泡排序演算法
publicstaticint[]bubbleSort(int[]args){//冒泡排序演算法
for(inti=0;i<args.length-1;i++){
for(intj=i+1;j<args.length;j++){
if(args[i]>args[j]){
inttemp=args[i];
args[i]=args[j];
args[j]=temp;
}
}
}
returnargs;
}<3>選擇排序演算法
publicstaticint[]selectSort(int[]args){//選擇排序演算法
for(inti=0;i<args.length-1;i++){
intmin=i;
for(intj=i+1;j<args.length;j++){
if(args[min]>args[j]){
min=j;
}
}
if(min!=i){
inttemp=args[i];
args[i]=args[min];
args[min]=temp;
}
}
returnargs;
}<4>插入排序演算法
publicstaticint[]insertSort(int[]args){//插入排序演算法
for(inti=1;i<args.length;i++){
for(intj=i;j>0;j--){
if(args[j]<args[j-1]){
inttemp=args[j-1];
args[j-1]=args[j];
args[j]=temp;
}elsebreak;
}
}
returnargs;
}
③ JAVA中如何使用SORT從大到小排.
在排序中,最重要的是歲檔自己實現自己的比較的行數,即是閉槐implements Comparator
實現方法 public int compare(Object o1, Object o2) 最為重要..
舉個例子:
package book.arrayset;
import java.util.Comparator;
/**
* 整數比較器，將整數按降序排列
*/
class MyIntComparator implements Comparator{
/**
* o1比o2大，返回-1；o1比o2小，返回1。
*/
public int compare(Object o1, Object o2) {
int i1 = ((Integer)o1).intValue();
int i2 = ((Integer)o2).intValue();
if (i1 < i2){
return 1;
}
if (i1 > i2){
return -1;
}
return 0;
}
}
//上面的為比較的函數實現,下面真正的添加數據,
//通過調用上面的比較函數實現自定義排序的功能
package book.arrayset;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
* 對List中的元素排序
*/
public class SortList {
public static void output(List list){
if (list == null){
return;
}
for (int i=0; i<list.size(); i++){
System.out.print(list.get(i).toString() + " ");
}
System.out.println();
}
public static void main(String[] args) {
List list = new ArrayList();
list.add(new Integer(5));
list.add(new Integer(8));
list.add(new Integer(1));
list.add(new Integer(3));
list.add(new Integer(2));
list.add(new Double(3.1));
System.out.println("list開始狀態");
SortList.output(list);
//Collections.sort方法將用默認轎雀友比較器排列list的元素
Collections.sort(list);
System.out.println("list被默認比較器排序後的狀態");
SortList.output(list);
//下面將list的元素按降序排列
Collections.sort(list, new MyIntComparator());
System.out.println("list被自定義比較器排序後的狀態");
SortList.output(list);
//因此，對於任意自定義類的對象，當保存在集合類容器中後，如果需要對它們進行排序，
//需要自己提供適應於自定義類的比較器，自定義比較器必須實現Comparator介面。
//然後採用Collections.sort(list, comparator);方法對容器進行排序。
}
}
④ java Arrays.sort() 排序規則
首先，你要學會查文檔，文檔當中都寫得清清楚楚。還有需要注意的是sort的排序是採用bubble的。只能在一般的處理，如果要求演算法比較高的就不行了～但是他 能做的事情就很多了，比如說能給對象從小到大排序。等等。但是也有局限性的。具體的用法樓上也說了：
static void sort(byte[] a)
對指定的 byte 型數組按數字升序進行排序。
static void sort(byte[] a, int fromIndex, int toIndex)
對指定 byte 型數組的指定范圍按數字升序進行排序。
static void sort(char[] a)
對指定的 char 型數組按數字升序進行排序。
static void sort(char[] a, int fromIndex, int toIndex)
對指定 char 型數組的指定范圍按數字升序進行排序。
static void sort(double[] a)
對指定的 double 型數組按數字升序進行排序。隱信
static void sort(double[] a, int fromIndex, int toIndex)
對指定 double 型數灶虧輪組的指定范圍按數字升序進行排序。
static void sort(float[] a)
對指定的 float 型數組按數字升序進行排序。
static void sort(float[] a, int fromIndex, int toIndex)
對指定 float 型數組的指定范圍按數字升序進行排序。
static void sort(int[] a)
對指定的 int 型數組按數字升序進行排序。
static void sort(int[] a, int fromIndex, int toIndex)
對指定 int 型數組的指定范圍按數字升序進行排序。
static void sort(long[] a)
對指定的 long 型數組按數字升序進行排序。
static void sort(long[] a, int fromIndex, int toIndex)
對指定 long 型數組的指定范圍按數字升序進行排序。
static void sort(Object[] a)
根據元素的自然順序對指定對象數組按升序進行排序。
static void sort(Object[] a, int fromIndex, int toIndex)
根據元素的自然順序對指定對象數組的指定范圍按升序進行排序。
static void sort(short[] a)
對指定的 short 型數組按數字升序進行排序。
static void sort(short[] a, int fromIndex, int toIndex)
對指定 short 型數組的指定范圍按數字升序進行排序。
static <T> void
sort(T[] a, Comparator<? super T> c)
根據指定比較器產生的順序對指定對象數組進行排序。
static <T> void
sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c)
根據指定比較器產生的順序對指定對象數組的空迅指定范圍進行排序。
。總之記得查文檔，文檔里都有
⑤ java演算法面試題：排序都有哪幾種方法
一、冒泡排序
[java] view plain
package sort.bubble;
import java.util.Random;
/**
* 依次比較相鄰的兩個數，將小數放在前面，大數放在後面
* 冒泡排序，具有穩定性
* 時間復雜度為O（n^2）
* 不及堆排序，快速排序O（nlogn，底數為2）
* @author liangge
*
*/
public class Main {
public static void main(String[] args) {
Random ran = new Random();
int[] sort = new int[10];
for(int i = 0 ; i < 10 ; i++){
sort[i] = ran.nextInt(50);
}
System.out.print("排序前的數組為");
for(int i : sort){
System.out.print(i+" ");
}
buddleSort(sort);
System.out.println();
System.out.print("排序後的數組為");
for(int i : sort){
System.out.print(i+" ");
}
}
/**
* 冒泡排序
* @param sort
*/
private static void buddleSort(int[] sort){
for(int i=1;i<sort.length;i++){
for(int j=0;j<sort.length-i;j++){
if(sort[j]>sort[j+1]){
int temp = sort[j+1];
sort[j+1] = sort[j];
sort[j] = temp;
}
}
}
}
}
二、選擇排序
[java] view plain
package sort.select;
import java.util.Random;
/**
* 選擇排序
* 每一趟從待排序的數據元素中選出最小（或最大）的一個元素，
* 順序放在已排好序的數列的最後，直到全部待排序的數據元素排完。
* 選擇排序是不穩定的排序方法。
* @author liangge
*
*/
public class Main {
public static void main(String[] args) {
Random ran = new Random();
int[] sort = new int[10];
for (int i = 0; i < 10; i++) {
sort[i] = ran.nextInt(50);
}
System.out.print("排序前的數組為");
for (int i : sort) {
System.out.print(i + " ");
}
selectSort(sort);
System.out.println();
System.out.print("排序後的數組為");
for (int i : sort) {
System.out.print(i + " ");
}
}
/**
* 選擇排序
* @param sort
*/
private static void selectSort(int[] sort){
for(int i =0;i<sort.length-1;i++){
for(int j = i+1;j<sort.length;j++){
if(sort[j]<sort[i]){
int temp = sort[j];
sort[j] = sort[i];
sort[i] = temp;
}
}
}
}
}
三、快速排序
[java] view plain
package sort.quick;
/**
* 快速排序 通過一趟排序將要排序的數據分割成獨立的兩部分， 其中一部分的所有數據都比另外一部分的所有數據都要小，
* 然後再按此方法對這兩部分數據分別進行快速排序， 整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。
* @author liangge
*
*/
public class Main {
public static void main(String[] args) {
int[] sort = { 54, 31, 89, 33, 66, 12, 68, 20 };
System.out.print("排序前的數組為：");
for (int data : sort) {
System.out.print(data + " ");
}
System.out.println();
quickSort(sort, 0, sort.length - 1);
System.out.print("排序後的數組為：");
for (int data : sort) {
System.out.print(data + " ");
}
}
/**
* 快速排序
* @param sort 要排序的數組
* @param start 排序的開始座標
* @param end 排序的結束座標
*/
public static void quickSort(int[] sort, int start, int end) {
// 設置關鍵數據key為要排序數組的第一個元素，
// 即第一趟排序後，key右邊的數全部比key大，key左邊的數全部比key小
int key = sort[start];
// 設置數組左邊的索引，往右移動判斷比key大的數
int i = start;
// 設置數組右邊的索引，往左移動判斷比key小的數
int j = end;
// 如果左邊索引比右邊索引小，則還有數據沒有排序
while (i < j) {
while (sort[j] > key && j > start) {
j--;
}
while (sort[i] < key && i < end) {
i++;
}
if (i < j) {
int temp = sort[i];
sort[i] = sort[j];
sort[j] = temp;
}
}
// 如果左邊索引比右邊索引要大，說明第一次排序完成，將sort[j]與key對換，
// 即保持了key左邊的數比key小，key右邊的數比key大
if (i > j) {
int temp = sort[j];
sort[j] = sort[start];
sort[start] = temp;
}
//遞歸調用
if (j > start && j < end) {
quickSort(sort, start, j - 1);
quickSort(sort, j + 1, end);
}
}
}
[java] view plain
/**
* 快速排序
*
* @param a
* @param low
* @param high
* voidTest
*/
public static void kuaisuSort(int[] a, int low, int high)
{
if (low >= high)
{
return;
}
if ((high - low) == 1)
{
if (a[low] > a[high])
{
swap(a, low, high);
return;
}
}
int key = a[low];
int left = low + 1;
int right = high;
while (left < right)
{
while (left < right && left <= high)// 左邊向右
{
if (a[left] >= key)
{
break;
}
left++;
}
while (right >= left && right > low)
{
if (a[right] <= key)
{
break;
}
right--;
}
if (left < right)
{
swap(a, left, right);
}
}
swap(a, low, right);
kuaisuSort(a, low, right);
kuaisuSort(a, right + 1, high);
}
四、插入排序
[java] view plain
package sort.insert;
/**
* 直接插入排序
* 將一個數據插入到已經排好序的有序數據中,從而得到一個新的、個數加一的有序數據
* 演算法適用於少量數據的排序，時間復雜度為O(n^2)。是穩定的排序方法。
*/
import java.util.Random;
public class DirectMain {
public static void main(String[] args) {
Random ran = new Random();
int[] sort = new int[10];
for (int i = 0; i < 10; i++) {
sort[i] = ran.nextInt(50);
}
System.out.print("排序前的數組為");
for (int i : sort) {
System.out.print(i + " ");
}
directInsertSort(sort);
System.out.println();
System.out.print("排序後的數組為");
for (int i : sort) {
System.out.print(i + " ");
}
}
/**
* 直接插入排序
*
* @param sort
*/
private static void directInsertSort(int[] sort) {
for (int i = 1; i < sort.length; i++) {
int index = i - 1;
int temp = sort[i];
while (index >= 0 && sort[index] > temp) {
sort[index + 1] = sort[index];
index--;
}
sort[index + 1] = temp;
}
}
}
順便添加一份，差不多的
[java] view plain
public static void charuSort(int[] a)
{
int len = a.length;
for (int i = 1; i < len; i++)
{
int j;
int temp = a[i];
for (j = i; j > 0; j--)//遍歷i之前的數字
{
//如果之前的數字大於後面的數字，則把大的值賦到後面
if (a[j - 1] > temp)
{
a[j] = a[j - 1];
} else
{
break;
}
}
a[j] = temp;
}
}
把上面整合起來的一份寫法：
[java] view plain
/**
* 插入排序:
*
*/
public class InsertSort {
public void sort(int[] data) {
for (int i = 1; i < data.length; i++) {
for (int j = i; (j > 0) && (data[j] < data[j - 1]); j--) {
swap(data, j, j - 1);
}
}
}
private void swap(int[] data, int i, int j) {
int temp = data[i];
data[i] = data[j];
data[j] = temp;
}
}
五、順便貼個二分搜索法
[java] view plain
package search.binary;
public class Main {
public static void main(String[] args) {
int[] sort = {1,2,3,4,5,6,7,8,9,10};
int mask = binarySearch(sort,6);
System.out.println(mask);
}
/**
* 二分搜索法，返回座標，不存在返回-1
* @param sort
* @return
*/
private static int binarySearch(int[] sort,int data){
if(data<sort[0] || data>sort[sort.length-1]){
return -1;
}
int begin = 0;
int end = sort.length;
int mid = (begin+end)/2;
while(begin <= end){
mid = (begin+end)/2;
if(data > sort[mid]){
begin = mid + 1;
}else if(data < sort[mid]){
end = mid - 1;
}else{
return mid;
}
}
return -1;
}
}
⑥ 用Java實現幾種常見的排序演算法
用Java語言實現的各種排序，包括插入排序、冒泡排序、選擇排序、Shell排序、快速排序、歸並排序、堆排序、SortUtil等。
插入排序：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;(j0)&&(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 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;ji;j--){
⑦ java中Arrays.sort使用的是什麼演算法
Arrays.sort()
先來看看Arrays.sort();，一點進這個方法會看到是這樣子的
publicstaticvoidsort(int[]a){
DualPivotQuicksort.sort(a,0,a.length-1,null,0,0);
}123
果然沒這么簡單，DualPivotQuicksort翻譯過來就是雙軸快速排序，關於雙軸排序可以去這里http://www.cnblogs.com/nullzx/p/5880191.html看看。那再次點進去，可以發現有這么一段代碼
if(right-left<QUICKSORT_THRESHOLD){
sort(a,left,right,true);
return;
}1234
可以發現如果數組的長度小於QUICKSORT_THRESHOLD的話就會使用這個雙軸快速排序，而這個值是286。
那如果大於286呢，它就會堅持數組的連續升序和連續降序性好不好，如果好的話就用歸並排序，不好的話就用快速排序，看下面這段注釋就可以看出
*Thearrayisnothighlystructured,
*.
123
那現在再回到上面的決定用雙軸快速排序的方法上，再點進去，發現又會多一條判斷
//Useinsertionsortontinyarrays
if(length<INSERTION_SORT_THRESHOLD)
123
即如果數組長度小於INSERTION_SORT_THRESHOLD(值為47)的話，那麼就會用插入排序了，不然再用雙軸快速排序。
所以總結一下Arrays.sort()方法，如果數組長度大於等於286且連續性好的話，就用歸並排序，如果大於等於286且連續性不好的話就用雙軸快速排序。如果長度小於286且大於等於47的話就用雙軸快速排序，如果長度小於47的話就用插入排序。真是有夠繞的~
⑧ java中的SORT怎麼用
Java中的Sort（排序）通常指的是Collections.sort() 對 List 的排序，該排序方式有兩種不同改的使用方法：
第一種是list中的對象實現Comparable介面，如下
public class User implements Comparable<User>{
private String name;
private Integer order;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getOrder() {
return order;
}
public void setOrder(Integer order) {
this.order = order;
}
public int compareTo(User arg0) {
return this.getOrder().compareTo(arg0.getOrder());
}
}
此時可以直接排序
public static void main(String[] args) {
User user1 = new User();
user1.setName("a");
user1.setOrder(1);
User user2 = new User();
user2.setName("b");
user2.setOrder(2);
List<User> list = new ArrayList<User>();
//此處add user2再add user1
list.add(user2);
list.add(user1);
Collections.sort(list);
for(User u : list){
System.out.println(u.getName());
}
}
第二種方法是根據Collections.sort重載方法來實現，例如：
public static void main(String[] args) {
User user1 = new User();
user1.setName("a");
user1.setOrder(1);
User user2 = new User();
user2.setName("b");
user2.setOrder(2);
List<User> list = new ArrayList<User>();
list.add(user2);
list.add(user1);
Collections.sort(list,new Comparator<User>(){
public int compare(User arg0, User arg1) {
return arg0.getOrder().compareTo(arg1.getOrder());
}
});
for(User u : list){
System.out.println(u.getName());
}
}
⑨ Java:使用sort方法對整個數組或部分數組進行排序的問題
額，他只是為了讓你明白sort(char,1,3)是從第1個開始，冊梁到第3個（但是不包州首運括芹段第3個）的字元進行排序。
⑩ 用JAVA實現快速排序演算法
public void quickSort(int left,int right,int a[])
{
int l=left;
int r=right;
int pivot=a[(l+r)/2];//轉軸數
int temp=0;
while(l<r)
{
while(a[l]<pivot)l++;
while(a[r]>pivot)r--;
if(l>=r)break;
temp=a[l];
a[l]=a[r];
a[r]=temp;
if(a[l]==pivot)r--;
if(a[r]==pivot)l++;
}
if(l==r)
{
l++;
r--;
}
if(left<r)quickSort(left,r,a);
if(right>l)quickSort(l,right,a);
}