排序： 插入，冒泡，選擇，Shell,快速排序
2. java排序演算法有多少種
演算法和語言無關吧，語言只是把具體的演算法實現出來而已。據我了解的排序演算法11-13種。排序演算法嘛 主要就是個思想而已。不同的演算法時間復雜度不一樣，空間復雜度也不一樣，當然執行的效率也不一樣。當然採用哪種演算法還取決於你要實現什麼樣的功能。就好比說：要同時盡快的找出最大最小，或者盡快的找出最值的位置等等。冒泡排序（bubble sort） — O(n2)
雞尾酒排序 (Cocktail sort, 雙向的冒泡排序) — O(n2)
插入排序 （insertion sort）— O(n2)
桶排序 （bucket sort）— O(n); 需要 O(k) 額外 記憶體
計數排序 (counting sort) — O(n+k); 需要 O(n+k) 額外 記憶體
歸並排序 （merge sort）— O(n log n); 需要 O(n) 額外記憶體
原地歸並排序 — O(n2)
二叉樹排序 （Binary tree sort） — O(n log n); 需要 O(n) 額外記憶體
鴿巢排序 (Pigeonhole sort) — O(n+k); 需要 O(k) 額外記憶體
基數排序 （radix sort）— O(n·k); 需要 O(n) 額外記憶體
Gnome sort — O(n2)
Library sort — O(n log n) with high probability, 需要 (1+ε)n 額外記憶體不穩定
選擇排序 （selection sort）— O(n2)
希爾排序 （shell sort）— O(n log n) 如果使用最佳的現在版本
Comb sort — O(n log n)
堆排序 （heapsort）— O(n log n)
Smoothsort — O(n log n)
快速排序 （quicksort）— O(n log n) 期望時間, O(n2) 最壞情況; 對於大的、亂數串列一般相信是最快的已知排序
等。
3. java怎麼實現排序
Java實現幾種常見排序方法
日常操作中常見的排序方法有：冒泡排序、快速排序、選擇排序、插入排序、希爾排序，甚至還有基數排序、雞尾酒排序、桶排序、鴿巢排序、歸並排序等。
以下常見演算法的定義
1. 插入排序：插入排序基本操作就是將一個數據插入到已經排好序的有序數據中，從而得到一個新的、個數加一的有序數據，演算法適用於少量數據的排序，時間復雜度為O(n^2)。是穩定的排序方法。插入排序的基本思想是：每步將一個待排序的紀錄，按其關鍵碼值的大小插入前面已經排序的文件中適當位置上，直到全部插入完為止。
2. 選擇排序：選擇排序（Selection sort）是一種簡單直觀的排序演算法。它的工作原理是每一次從待排序的數據元素中選出最小（或最大）的一個元素，存放在序列的起始位置，直到全部待排序的數據元素排完。 選擇排序是不穩定的排序方法。
3. 冒泡排序：冒泡排序（Bubble Sort），是一種計算機科學領域的較簡單的排序演算法。它重復地走訪過要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。走訪數列的工作是重復地進行直到沒有再需要交換，也就是說該數列已經排序完成。這個演算法的名字由來是因為越大的元素會經由交換慢慢「浮」到數列的頂端。
4. 快速排序：快速排序（Quicksort）是對冒泡排序的一種改進。它的基本思想是：通過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一部分的所有數據都要小，然後再按此方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。
5. 歸並排序：歸並排序是建立在歸並操作上的一種有效的排序演算法,該演算法是採用分治法（Divide and Conquer）的一個非常典型的應用。將已有序的子序列合並，得到完全有序的序列；即先使每個子序列有序，再使子序列段間有序。若將兩個有序表合並成一個有序表，稱為二路歸並。
6. 希爾排序：希爾排序(Shell Sort)是插入排序的一種。也稱縮小增量排序，是直接插入排序演算法的一種更高效的改進版本。希爾排序是非穩定排序演算法。希爾排序是把記錄按下標的一定增量分組，對每組使用直接插入排序演算法排序；隨著增量逐漸減少，每組包含的關鍵詞越來越多，當增量減至1時，整個文件恰被分成一組，演算法便終止。
https://www.cnblogs.com/wangmingshun/p/5635292.html
4. java 請教排序演算法
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
* @author wsj
* @date 2010-5-16, 上午10:13:47
*/
public class Test1 {
public static void main(String[] args){
Integer arr1[]={6,3,4,5,1};
Integer arr2[]={3,4,7,9,0};
List<MyInteger> list1=new ArrayList<MyInteger>();
List<MyInteger> list2=new ArrayList<MyInteger>();
for (int i = 0; i < arr2.length; i++) {
list1.add(new MyInteger(arr1[i]));
list2.add(new MyInteger(arr2[i]));
}
System.out.print("數組A排序前:");
output(list1);
Collections.sort(list1);
System.out.print("數組A排序後:");
output(list1);
System.out.print("數組B排序前:");
output(list2);
Collections.sort(list2);
System.out.print("數組B排序後:");
output(list2);
List<MyInteger> allList=new ArrayList<MyInteger>();
allList.addAll(list1);
allList.addAll(list2);
System.out.print("合並排序前：");
output(allList);
Collections.sort(allList);
System.out.print("合並排序後：");
output(allList);
System.out.println("A數組占："+getCount(allList, list1)+" 個");
System.out.println("B數組占："+getCount(allList, list2)+" 個");
}
public static void output(List<MyInteger> list){
for (MyInteger m:list) {
System.out.print(m.val+",");
}
System.out.println();
}
public static int getCount(List<MyInteger> allList,List<MyInteger> list){
int count=0;
for (int i = 4; i>=0; i--) {
count=list.lastIndexOf(allList.get(i))+1;
if(count>0) return count;
}
return count;
}
}
class MyInteger implements Comparable<MyInteger>{
Integer val;
public MyInteger(Integer val) {
this.val = val;
}
@Override
public int compareTo(MyInteger o) {
if(o==null||o.val==null) return -1;
return -val.compareTo(o.val);
}
@Override
public boolean equals(Object obj) {
return val.equals(((MyInteger)obj).val);
}
}
5. Java 排序演算法（選擇、冒泡）等等
//選擇排序
publicstaticvoidselectionSort(int[] elements){
for(inti = 0; i < elements.length-1; ++i){
intk = i;
for(intj = i; j < elements.length; ++j){
if(elements[k] > elements[j]){
k = j;
}
}
if(k != i){//交換元素
inttemp = elements[i];
elements[i] = elements[k];
elements[k] = temp;
}
} }
//冒泡排序
static void bubblesort(int[] a){
int temp;
for(int i=0; i<a.length;++i){
for(int j=a.length-1;j>i;--j){
if(a[j] <a[j-1]){
temp = a[j];
a[j] = a[j-1];
a[j-1] = temp;
}
}
}
}
樓上說的沒錯，你得自己去學會解決問題。好好加油吧...
6. 冒泡排序演算法，java
原理：比較兩個相鄰的元素，將值大的元素交換至右端。
思路：依次比較相鄰的兩個數，將小數放在前面，大數放在後面。即在第一趟：首先比較第
1個和第2個數，將小數放前，大數放後。然後比較第2個數和第3個數，將小數放前，大
數放後，如此繼續，直至比較最後兩個數，將小數放前，大數放後。重復第一趟步驟，直至
全部排序完成。
publicclass BubbleSort {
publicstaticvoid main(String[] args) { int[] arr={12,45,23,67,56,34,99,123}; System.out.println("排序前數組為：");
for(int n:arr){
System.out.print(n+"");
}
for(int i=0;i<arr.length-1;i++){//外層循環控制排序趟數
for(int j=0;j<arr.length-1-i;j++){//內層循環控制每一趟排序多少次 if(arr[j]>arr[j+1]){ int temp=arr[j]; arr[j]=arr[j+1]; arr[j+1]=temp;
}
}
7. java選擇排序法
這是一個很簡單的選擇排序的方法,加了一些重點步驟的注釋,希望對您有幫助!(上次發錯了.這次是正確的版本)
public class ChooseSort {
public static void main(String[] args) {
int src[] = new int[]{25，15，42，16，12，36};
ChooseSort choose = new ChooseSort();
choose.doChooseSort(src);
}
private void doChooseSort(int[] src){
long start = System.currentTimeMillis();
for(int k=0;k<1000000;k++){
int temp;
for(int i=0;i<src.length;i++){
temp=src[i];
//最小數下標
int smallLocation=i;
for(int j=i+1;j<src.length;j++){
if(src[j]<temp){
//取出最小數
temp=src[j];
//最小數下標
smallLocation=j;
}
}
src[smallLocation]=src[i];
src[i]=temp;
}
}
System.out.println("選擇排序如下,耗時:"+ (System.currentTimeMillis() - start));
}
}
8. java的排序演算法怎麼寫所有的
public static void buildHeap(int [] a,int beg,int end){
int size = end-beg+1;
int temp;
for(int i = size/2;i>0;i--){
if((2*i+1<=end)&&a[i]<a[2*i+1]){
temp=a[i];
a[i]=a[2*i+1];
a[2*i+1]=temp;
}
if((2*i<=end)&&a[i]<a[2*i]){
temp=a[i];
a[i]=a[2*i];
a[2*i]=temp;
}
}
}
public static void heapSort(int [] a,int beg,int end){
int size = end-beg+1;
int temp;
for(int i =size;i>0;i--){
buildHeap(a, 1, i);
temp=a[1];
a[1]=a[i];
a[i]=temp;
}
}
public static void shellSort(int[] a,int wid){
int temp;int j;
for(int i=0;i<a.length;i++){
for(int k=i+wid;k<a.length;k+=wid){
j=k-wid;
temp=a[k];
while((j>=0)&&(temp<a[j])){
a[j+wid]=a[j];
j-=wid;
}
a[j+wid]=temp;
}
}
}
public static int partition(int[] a,int beg,int end){
int temp = a[beg];
while(beg<end){
while(beg<end&&a[end]>=temp){
end--;
}
a[beg]=a[end];
while((beg<end)&&(a[beg]<=temp))
{
beg++;
}
a[end]=a[beg];
}
a[beg]=temp;
return beg;
}
public static void quickSort(int[] a,int beg,int end){
if(beg<end){
int q = partition(a, beg, end);
quickSort(a, beg, q-1);
quickSort(a, q+1, end);
}
}
public static void insertSort(int[] a){
int temp;
int j;
for(int i=1;i<a.length;i++){
j=i-1;
temp=a[i];
while((j>=0)&&(temp<a[j])){
a[j+1]=a[j];
j--;
}
a[j+1]=temp;
}
}
9. 初學者：用java程序寫一個選擇排序演算法！
選擇排序法：
public class TSort{
public static void main(String args[]){
int a[]={12,45,2,5,26,56};
for(int i=0;i<a.length-1;i++){
int t;
for(int j=i+1;j<a.length;j++){
if(a[i]>a[j]){
t=a[i];a[i]=a[j];a[j]=t;
}
}
}
for(int i=0;i<a.length;i++){
System.out.print(a[i]+" ");
}
}
}