⑴ java 編寫一個程序,輸入3個整數,然後程序將對這三個整數按照從大到小進行排列
可以實現比較器Comparator來定製排序方案，同時使用Colletions.sort的方式進行排序，代碼如下：
public void sortDesc(List<Long> s){
Collections.sort(s, new Comparator<Long>() {
public int compare(Long o1, Long o2) {
Long result = o2 - o1;
return result.intValue();
}
});
s.forEach(item->{
System.out.print(item +" ");
});
}
同時常用的比較排序演算法主要有：型團冒泡排序，選擇排序，插入排序，歸並排序，堆排序，快速排序等。
java的冒泡排序實現如下：頃租拍
publicstaticvoidbubbleSort(int[]arr){for(inti=0;i<arr.length-1;i++){for(intj=0;j<arr.length-i-1;j++){//-1為了防止溢出if(arr[j]>arr[j+1]){inttemp=arr[j];雀羨arr[j]=arr[j+1];arr[j+1]=temp;}}}}
還有非比較排序，時間復雜度可以達到O(n)，主要有：計數排序，基數排序，桶排序等。
⑵ 數據結構 java開發中常用的排序演算法有哪些
排序演算法有很多，所以在特定情景中使用哪一種演算法很重要。為了選擇合適的演算法，可以按照建議的順序考慮以下標准：
（1）執行時間
（2）存儲空間
（3）編程工作
對於數據量較小的情形，（1）（2）差別不大，主要考慮（3）；而對於數據量大的，（1）為首要。
主要排序法有：
一、冒泡（Bubble）排序——相鄰交換
二、選擇排序——每次最小/大排在相應的位置
三、插入排序——將下一個插入已排好的序列中
四、殼（Shell）排序——縮小增量
五、歸並排序
六、快速排序
七、堆排序
八、拓撲排序
一、冒泡（Bubble）排序
----------------------------------Code 從小到大排序n個數------------------------------------
void BubbleSortArray()
{
for(int i=1;i<n;i++)
{
for(int j=0;i<n-i;j++)
{
if(a[j]>a[j+1])//比較交換相鄰元素
{
int temp;
temp=a[j]; a[j]=a[j+1]; a[j+1]=temp;
}
}
}
}
-------------------------------------------------Code------------------------------------------------
效率 O（n²）,適用於排序小列表。
二、選擇排序
----------------------------------Code 從小到大排序n個數--------------------------------
void SelectSortArray()
{
int min_index;
for(int i=0;i<n-1;i++)
{
min_index=i;
for(int j=i+1;j<n;j++)//每次掃描選擇最小項
if(arr[j]<arr[min_index]) min_index=j;
if(min_index!=i)//找到最小項交換，即將這一項移到列表中的正確位置
{
int temp;
temp=arr[i]; arr[i]=arr[min_index]; arr[min_index]=temp;
}
}
}
-------------------------------------------------Code-----------------------------------------
效率O（n²），適用於排序小的列表。
三、插入排序
--------------------------------------------Code 從小到大排序n個數-------------------------------------
void InsertSortArray()
{
for(int i=1;i<n;i++)//循環從第二個數組元素開始，因為arr[0]作為最初已排序部分
{
int temp=arr[i];//temp標記為未排序第一個元素
int j=i-1;
while (j>=0 && arr[j]>temp)/*將temp與已排序元素從小到大比較，尋找temp應插入的位置*/
{
arr[j+1]=arr[j];
j--;
}
arr[j+1]=temp;
}
}
------------------------------Code--------------------------------------------------------------
最佳效率O（n）；最糟效率O（n²）與冒泡、選擇相同，適用於排序小列表
若列表基本有序，則插入排序比冒泡、選擇更有效率。
四、殼（Shell）排序——縮小增量排序
-------------------------------------Code 從小到大排序n個數-------------------------------------
void ShellSortArray()
{
for(int incr=3;incr<0;incr--)//增量遞減，以增量3，2，1為例
{
for(int L=0;L<(n-1)/incr;L++)//重復分成的每個子列表
{
for(int i=L+incr;i<n;i+=incr)//對每個子列表應用插入排序
{
int temp=arr[i];
int j=i-incr;
while(j>=0&&arr[j]>temp)
{
arr[j+incr]=arr[j];
j-=incr;
}
arr[j+incr]=temp;
}
}
}
}
--------------------------------------Code-------------------------------------------
適用於排序小列表。
效率估計O（nlog2^n）~O（n^1.5），取決於增量值的最初大小。建議使用質數作為增量值，因為如果增量值是2的冪，則在下一個通道中會再次比較相同的元素。
殼（Shell）排序改進了插入排序，減少了比較的次數。是不穩定的排序，因為排序過程中元素可能會前後跳躍。
五、歸並排序
----------------------------------------------Code 從小到大排序---------------------------------------
void MergeSort(int low,int high)
{
if(low>=high) return;//每個子列表中剩下一個元素時停止
else int mid=(low+high)/2;/*將列表劃分成相等的兩個子列表,若有奇數個元素，則在左邊子列表大於右側子列表*/
MergeSort(low,mid);//子列表進一步劃分
MergeSort(mid+1,high);
int [] B=new int [high-low+1];//新建一個數組，用於存放歸並的元素
for(int i=low,j=mid+1,k=low;i<=mid && j<=high;k++)/*兩個子列表進行排序歸並，直到兩個子列表中的一個結束*/
{
if (arr[i]<=arr[j];)
{
B[k]=arr[i];
I++;
}
else
{ B[k]=arr[j]; j++; }
}
for( ;j<=high;j++,k++)//如果第二個子列表中仍然有元素，則追加到新列表
B[k]=arr[j];
for( ;i<=mid;i++,k++)//如果在第一個子列表中仍然有元素，則追加到新列表中
B[k]=arr[i];
for(int z=0;z<high-low+1;z++)//將排序的數組B的 所有元素復制到原始數組arr中
arr[z]=B[z];
}
-----------------------------------------------------Code---------------------------------------------------
效率O（nlogn），歸並的最佳、平均和最糟用例效率之間沒有差異。
適用於排序大列表，基於分治法。
六、快速排序
------------------------------------Code--------------------------------------------
/*快速排序的演算法思想：選定一個樞紐元素，對待排序序列進行分割，分割之後的序列一個部分小於樞紐元素，一個部分大於樞紐元素，再對這兩個分割好的子序列進行上述的過程。*/ void swap(int a,int b){int t;t =a ;a =b ;b =t ;}
int Partition(int [] arr,int low,int high)
{
int pivot=arr[low];//採用子序列的第一個元素作為樞紐元素
while (low < high)
{
//從後往前栽後半部分中尋找第一個小於樞紐元素的元素
while (low < high && arr[high] >= pivot)
{
--high;
}
//將這個比樞紐元素小的元素交換到前半部分
swap(arr[low], arr[high]);
//從前往後在前半部分中尋找第一個大於樞紐元素的元素
while (low <high &&arr [low ]<=pivot )
{
++low ;
}
swap (arr [low ],arr [high ]);//將這個樞紐元素大的元素交換到後半部分
}
return low ;//返回樞紐元素所在的位置
}
void QuickSort(int [] a,int low,int high)
{
if (low <high )
{
int n=Partition (a ,low ,high );
QuickSort (a ,low ,n );
QuickSort (a ,n +1,high );
}
}
----------------------------------------Code-------------------------------------
平均效率O（nlogn），適用於排序大列表。
此演算法的總時間取決於樞紐值的位置；選擇第一個元素作為樞紐，可能導致O（n²）的最糟用例效率。若數基本有序，效率反而最差。選項中間值作為樞紐，效率是O（nlogn）。
基於分治法。
七、堆排序
最大堆：後者任一非終端節點的關鍵字均大於或等於它的左、右孩子的關鍵字，此時位於堆頂的節點的關鍵字是整個序列中最大的。
思想：
(1)令i=l,並令temp＝ kl ;
(2)計算i的左孩子j=2i+1;
(3)若j<＝n－1，則轉(4),否則轉(6);
(4)比較kj和kj+1,若kj+1>kj,則令j＝j＋1，否則j不變；
(5)比較temp和kj，若kj>temp，則令ki等於kj，並令i=j,j=2i+1,並轉(3),否則轉(6)
(6)令ki等於temp，結束。
-----------------------------------------Code---------------------------
void HeapSort(SeqIAst R)
{ //對R[1..n]進行堆排序，不妨用R[0]做暫存單元 int I; BuildHeap(R)； //將R[1-n]建成初始堆for(i=n;i>1；i--) //對當前無序區R[1..i]進行堆排序，共做n-1趟。{ R[0]=R[1]; R[1]=R[i]; R[i]=R[0]; //將堆頂和堆中最後一個記錄交換 Heapify(R,1,i-1); //將R[1..i-1]重新調整為堆，僅有R[1]可能違反堆性質 } } ---------------------------------------Code--------------------------------------
堆排序的時間，主要由建立初始堆和反復重建堆這兩部分的時間開銷構成，它們均是通過調用Heapify實現的。
堆排序的最壞時間復雜度為O(nlgn)。堆排序的平均性能較接近於最壞性能。 由於建初始堆所需的比較次數較多，所以堆排序不適宜於記錄數較少的文件。 堆排序是就地排序，輔助空間為O(1)， 它是不穩定的排序方法。
堆排序與直接插入排序的區別:
直接選擇排序中，為了從R[1..n]中選出關鍵字最小的記錄，必須進行n-1次比較，然後在R[2..n]中選出關鍵字最小的記錄，又需要做n-2次比較。事實上，後面的n-2次比較中，有許多比較可能在前面的n-1次比較中已經做過，但由於前一趟排序時未保留這些比較結果，所以後一趟排序時又重復執行了這些比較操作。
堆排序可通過樹形結構保存部分比較結果，可減少比較次數。
八、拓撲排序
例 ：學生選修課排課先後順序
拓撲排序：把有向圖中各頂點按照它們相互之間的優先關系排列成一個線性序列的過程。
方法：
在有向圖中選一個沒有前驅的頂點且輸出
從圖中刪除該頂點和所有以它為尾的弧
重復上述兩步，直至全部頂點均已輸出（拓撲排序成功），或者當圖中不存在無前驅的頂點（圖中有迴路）為止。
---------------------------------------Code--------------------------------------
void TopologicalSort()/*輸出拓撲排序函數。若G無迴路，則輸出G的頂點的一個拓撲序列並返回OK，否則返回ERROR*/
{
int indegree[M];
int i,k,j;
char n;
int count=0;
Stack thestack;
FindInDegree(G,indegree);//對各頂點求入度indegree[0....num]
InitStack(thestack);//初始化棧
for(i=0;i<G.num;i++)
Console.WriteLine("結點"+G.vertices[i].data+"的入度為"+indegree[i]);
for(i=0;i<G.num;i++)
{
if(indegree[i]==0)
Push(thestack.vertices[i]);
}
Console.Write("拓撲排序輸出順序為：");
while(thestack.Peek()!=null)
{
Pop(thestack.Peek());
j=locatevex(G,n);
if (j==-2)
{
Console.WriteLine("發生錯誤，程序結束。");
exit();
}
Console.Write(G.vertices[j].data);
count++;
for(p=G.vertices[j].firstarc;p!=NULL;p=p.nextarc)
{
k=p.adjvex;
if (!(--indegree[k]))
Push(G.vertices[k]);
}
}
if (count<G.num)
Cosole.WriteLine("該圖有環，出現錯誤，無法排序。");
else
Console.WriteLine("排序成功。");
}
----------------------------------------Code--------------------------------------
演算法的時間復雜度O（n+e）。
⑶ 寫一個簡單的JAVA排序程序
// 排序
public class Array
{
public static int[] random(int n) //產生n個隨機數，返回整型數組
{
if (n>0)
{
int table[] = new int[n];
for (int i=0; i<table.length; i++)
table[i] = (int)(Math.random()*100); //產生一個0～100之間的隨機數
return table; //返回一個數組
}
return null;
}
public static void print(int[] table) //輸出數組元素
{
if (table!=null)
for (int i=0; i<table.length; i++)
System.out.print(" "+table[i]);
System.out.println();
}
public static void insertSort(int[] table) //直接插入排序
{ //數組是引用類型，元素值將被改變
System.out.println("直接插入排序");
for (int i=1; i<table.length; i++) //n-1趟掃描
{
int temp=table[i], j; //每趟將table[i]插入到前面已排序的序列中
// System.out.print("移動");
for (j=i-1; j>-1 && temp<table[j]; j--) //將前面較大元素向後移動
{
// System.out.print(table[j]+", ");
table[j+1] = table[j];
}
table[j+1] = temp; //temp值到達插入位置
System.out.print("第"+i+"趟: ");
print(table);
}
}
public static void shellSort(int[] table) //希爾排序
{
System.out.println("希爾排序");
for (int delta=table.length/2; delta>0; delta/=2) //控制增量，增量減半，若干趟掃描
{
for (int i=delta; i<table.length; i++) //一趟中若干組，每個元素在自己所屬組內進行直接插入排序
{
int temp = table[i]; //當前待插入元素
int j=i-delta; //相距delta遠
while (j>=0 && temp<table[j]) //一組中前面較大的元素向後移動
{
table[j+delta] = table[j];
j-=delta; //繼續與前面的元素比較
}
table[j+delta] = temp; //插入元素位置
}
System.out.print("delta="+delta+" ");
print(table);
}
}
private static void swap(int[] table, int i, int j) //交換數組中下標為i、j的元素
{
if (i>=0 && i<table.length && j>=0 && j<table.length && i!=j) //判斷i、j是否越界
{
int temp = table[j];
table[j] = table[i];
table[i] = temp;
}
}
public static void bubbleSort(int[] table) //冒泡排序
{
System.out.println("冒泡排序");
boolean exchange=true; //是否交換的標記
for (int i=1; i<table.length && exchange; i++) //有交換時再進行下一趟，最多n-1趟
{
exchange=false; //假定元素未交換
for (int j=0; j<table.length-i; j++) //一次比較、交換
if (table[j]>table[j+1]) //反序時，交換
{
int temp = table[j];
table[j] = table[j+1];
table[j+1] = temp;
exchange=true; //有交換
}
System.out.print("第"+i+"趟: ");
print(table);
}
}
public static void quickSort(int[] table) //快速排序
{
quickSort(table, 0, table.length-1);
}
private static void quickSort(int[] table, int low, int high) //一趟快速排序，遞歸演算法
{ //low、high指定序列的下界和上界
if (low<high) //序列有效
{
int i=low, j=high;
int vot=table[i]; //第一個值作為基準值
while (i!=j) //一趟排序
{
while (i<j && vot<=table[j]) //從後向前尋找較小值
j--;
if (i<j)
{
table[i]=table[j]; //較小元素向前移動
i++;
}
while (i<j && table[i]<vot) //從前向後尋找較大值
i++;
if (i<j)
{
table[j]=table[i]; //較大元素向後移動
j--;
}
}
table[i]=vot; //基準值的最終位置
System.out.print(low+".."+high+", vot="+vot+" ");
print(table);
quickSort(table, low, j-1); //前端子序列再排序
quickSort(table, i+1, high); //後端子序列再排序
}
}
public static void selectSort(int[] table) //直接選擇排序
{
System.out.println("直接選擇排序");
for (int i=0; i<table.length-1; i++) //n-1趟排序
{ //每趟在從table[i]開始的子序列中尋找最小元素
int min=i; //設第i個數據元素最小
for (int j=i+1; j<table.length; j++) //在子序列中查找最小值
if (table[j]<table[min])
min = j; //記住最小元素下標
if (min!=i) //將本趟最小元素交換到前邊
{
int temp = table[i];
table[i] = table[min];
table[min] = temp;
}
System.out.print("第"+i+"趟: ");
print(table);
}
}
private static void sift(int[] table, int low, int high) //將以low為根的子樹調整成最小堆
{ //low、high是序列下界和上界
int i=low; //子樹的根
int j=2*i+1; //j為i結點的左孩子
int temp=table[i]; //獲得第i個元素的值
while (j<=high) //沿較小值孩子結點向下篩選
{
if (j<high && table[j]>table[j+1]) //數組元素比較（改成<為最大堆）
j++; //j為左右孩子的較小者
if (temp>table[j]) //若父母結點值較大（改成<為最大堆）
{
table[i]=table[j]; //孩子結點中的較小值上移
i=j; //i、j向下一層
j=2*i+1;
}
else
j=high+1; //退出循環
}
table[i]=temp; //當前子樹的原根值調整後的位置
System.out.print("sift "+low+".."+high+" ");
print(table);
}
public static void heapSort(int[] table)
{
System.out.println("堆排序");
int n=table.length;
for (int j=n/2-1; j>=0; j--) //創建最小堆
sift(table, j, n-1);
// System.out.println("最小堆？ "+isMinHeap(table));
for (int j=n-1; j>0; j--) //每趟將最小值交換到後面，再調整成堆
{
int temp = table[0];
table[0] = table[j];
table[j] = temp;
sift(table, 0, j-1);
}
}
public static void mergeSort(int[] X) //歸並排序
{
System.out.println("歸並排序");
int n=1; //已排序的子序列長度，初值為1
int[] Y = new int[X.length]; //Y數組長度同X數組
do
{
mergepass(X, Y, n); //一趟歸並，將X數組中各子序列歸並到Y中
print(Y);
n*=2; //子序列長度加倍
if (n<X.length)
{
mergepass(Y, X, n); //將Y數組中各子序列再歸並到X中
print(X);
n*=2;
}
} while (n<X.length);
}
private static void mergepass(int[] X, int[] Y, int n) //一趟歸並
{
System.out.print("子序列長度n="+n+" ");
int i=0;
while (i<X.length-2*n+1)
{
merge(X,Y,i,i+n,n);
i += 2*n;
}
if (i+n<X.length)
merge(X,Y,i,i+n,n); //再一次歸並
else
for (int j=i; j<X.length; j++) //將X剩餘元素復制到Y中
Y[j]=X[j];
}
private static void merge(int[] X, int[] Y, int m, int r, int n) //一次歸並
{
int i=m, j=r, k=m;
while (i<r && j<r+n && j<X.length) //將X中兩個相鄰子序列歸並到Y中
if (X[i]<X[j]) //較小值復制到Y中
Y[k++]=X[i++];
else
Y[k++]=X[j++];
while (i<r) //將前一個子序列剩餘元素復制到Y中
Y[k++]=X[i++];
while (j<r+n && j<X.length) //將後一個子序列剩餘元素復制到Y中
Y[k++]=X[j++];
}
public static void main(String[] args)
{
// int[] table = {52,26,97,19,66,8,49};//Array.random(9);{49,65,13,81,76,97,38,49};////{85,12,36,24,47,30,53,91,76};//;//{4,5,8,1,2,7,3,6};// {32,26,87,72,26,17};//
int[] table = {13,27,38,49,97,76,49,81}; //最小堆
System.out.print("關鍵字序列: ");
Array.print(table);
// Array.insertSort(table);
// Array.shellSort(table);
// Array.bubbleSort(table);
// Array.quickSort(table);
// Array.selectSort(table);
// Array.heapSort(table);
// Array.mergeSort(table);
System.out.println("最小堆序列? "+Array.isMinHeap(table));
}
//第9章習題
public static boolean isMinHeap(int[] table) //判斷一個數據序列是否為最小堆
{
if (table==null)
return false;
int i = table.length/2 -1; //最深一棵子樹的根結點
while (i>=0)
{
int j=2*i+1; //左孩子
if (j<table.length)
if (table[i]>table[j])
return false;
else
if (j+1<table.length && table[i]>table[j+1]) //右孩子
return false;
i--;
}
return true;
}
}
/*
程序運行結果如下：
關鍵字序列: 32 26 87 72 26 17 8 40
直接插入排序
第1趟排序: 26 32 87 72 26 17 8 40
第2趟排序: 26 32 87 72 26 17 8 40
第3趟排序: 26 32 72 87 26 17 8 40
第4趟排序: 26 26 32 72 87 17 8 40 //排序演算法穩定
第5趟排序: 17 26 26 32 72 87 8 40
第6趟排序: 8 17 26 26 32 72 87 40
第7趟排序: 8 17 26 26 32 40 72 87
關鍵字序列: 42 1 74 25 45 29 87 53
直接插入排序
第1趟排序: 1 42 74 25 45 29 87 53
第2趟排序: 1 42 74 25 45 29 87 53
第3趟排序: 1 25 42 74 45 29 87 53
第4趟排序: 1 25 42 45 74 29 87 53
第5趟排序: 1 25 29 42 45 74 87 53
第6趟排序: 1 25 29 42 45 74 87 53
第7趟排序: 1 25 29 42 45 53 74 87
關鍵字序列: 21 12 2 40 99 97 68 57
直接插入排序
第1趟排序: 12 21 2 40 99 97 68 57
第2趟排序: 2 12 21 40 99 97 68 57
第3趟排序: 2 12 21 40 99 97 68 57
第4趟排序: 2 12 21 40 99 97 68 57
第5趟排序: 2 12 21 40 97 99 68 57
第6趟排序: 2 12 21 40 68 97 99 57
第7趟排序: 2 12 21 40 57 68 97 99
關鍵字序列: 27 38 65 97 76 13 27 49 55 4
希爾排序
delta=5 13 27 49 55 4 27 38 65 97 76
delta=2 4 27 13 27 38 55 49 65 97 76
delta=1 4 13 27 27 38 49 55 65 76 97
關鍵字序列: 49 38 65 97 76 13 27 49 55 4 //嚴書
希爾排序
delta=5 13 27 49 55 4 49 38 65 97 76
delta=2 4 27 13 49 38 55 49 65 97 76 //與嚴書不同
delta=1 4 13 27 38 49 49 55 65 76 97
關鍵字序列: 65 34 25 87 12 38 56 46 14 77 92 23
希爾排序
delta=6 56 34 14 77 12 23 65 46 25 87 92 38
delta=3 56 12 14 65 34 23 77 46 25 87 92 38
delta=1 12 14 23 25 34 38 46 56 65 77 87 92
關鍵字序列: 84 12 43 62 86 7 90 91
希爾排序
delta=4 84 7 43 62 86 12 90 91
delta=2 43 7 84 12 86 62 90 91
delta=1 7 12 43 62 84 86 90 91
關鍵字序列: 32 26 87 72 26 17
冒泡排序
第1趟排序: 26 32 72 26 17 87
第2趟排序: 26 32 26 17 72 87
第3趟排序: 26 26 17 32 72 87
第4趟排序: 26 17 26 32 72 87
第5趟排序: 17 26 26 32 72 87
關鍵字序列: 1 2 3 4 5 6 7 8
冒泡排序
第1趟排序: 1 2 3 4 5 6 7 8
關鍵字序列: 1 3 2 4 5 8 6 7
冒泡排序
第1趟排序: 1 2 3 4 5 6 7 8
第2趟排序: 1 2 3 4 5 6 7 8
關鍵字序列: 4 5 8 1 2 7 3 6
冒泡排序
第1趟排序: 4 5 1 2 7 3 6 8
第2趟排序: 4 1 2 5 3 6 7 8
第3趟排序: 1 2 4 3 5 6 7 8
第4趟排序: 1 2 3 4 5 6 7 8
第5趟排序: 1 2 3 4 5 6 7 8
關鍵字序列: 38 26 97 19 66 1 5 49
0..7, vot=38 5 26 1 19 38 66 97 49
0..3, vot=5 1 5 26 19 38 66 97 49
2..3, vot=26 1 5 19 26 38 66 97 49
5..7, vot=66 1 5 19 26 38 49 66 97
關鍵字序列: 38 5 49 26 19 97 1 66
0..7, vot=38 1 5 19 26 38 97 49 66
0..3, vot=1 1 5 19 26 38 97 49 66
1..3, vot=5 1 5 19 26 38 97 49 66
2..3, vot=19 1 5 19 26 38 97 49 66
5..7, vot=97 1 5 19 26 38 66 49 97
5..6, vot=66 1 5 19 26 38 49 66 97
關鍵字序列: 49 38 65 97 76 13 27 49
0..7, vot=49 49 38 27 13 49 76 97 65
0..3, vot=49 13 38 27 49 49 76 97 65
0..2, vot=13 13 38 27 49 49 76 97 65
1..2, vot=38 13 27 38 49 49 76 97 65
5..7, vot=76 13 27 38 49 49 65 76 97
關鍵字序列: 27 38 65 97 76 13 27 49 55 4
low=0 high=9 vot=27 4 27 13 27 76 97 65 49 55 38
low=0 high=2 vot=4 4 27 13 27 76 97 65 49 55 38
low=1 high=2 vot=27 4 13 27 27 76 97 65 49 55 38
low=4 high=9 vot=76 4 13 27 27 38 55 65 49 76 97
low=4 high=7 vot=38 4 13 27 27 38 55 65 49 76 97
low=5 high=7 vot=55 4 13 27 27 38 49 55 65 76 97
關鍵字序列: 38 26 97 19 66 1 5 49
直接選擇排序
第0趟排序: 1 26 97 19 66 38 5 49
第1趟排序: 1 5 97 19 66 38 26 49
第2趟排序: 1 5 19 97 66 38 26 49
第3趟排序: 1 5 19 26 66 38 97 49
第4趟排序: 1 5 19 26 38 66 97 49
第5趟排序: 1 5 19 26 38 49 97 66
第6趟排序: 1 5 19 26 38 49 66 97
最小堆
關鍵字序列: 81 49 76 27 97 38 49 13 65
sift 3..8 81 49 76 13 97 38 49 27 65
sift 2..8 81 49 38 13 97 76 49 27 65
sift 1..8 81 13 38 27 97 76 49 49 65
sift 0..8 13 27 38 49 97 76 49 81 65
13 27 38 49 97 76 49 81 65
sift 0..7 27 49 38 65 97 76 49 81 13
sift 0..6 38 49 49 65 97 76 81 27 13
sift 0..5 49 65 49 81 97 76 38 27 13
sift 0..4 49 65 76 81 97 49 38 27 13
sift 0..3 65 81 76 97 49 49 38 27 13
sift 0..2 76 81 97 65 49 49 38 27 13
sift 0..1 81 97 76 65 49 49 38 27 13
sift 0..0 97 81 76 65 49 49 38 27 13
最大堆
關鍵字序列: 49 65 13 81 76 27 97 38 49
sift 3..8 49 65 13 81 76 27 97 38 49
sift 2..8 49 65 97 81 76 27 13 38 49
sift 1..8 49 81 97 65 76 27 13 38 49
sift 0..8 97 81 49 65 76 27 13 38 49
97 81 49 65 76 27 13 38 49
sift 0..7 81 76 49 65 49 27 13 38 97
sift 0..6 76 65 49 38 49 27 13 81 97
sift 0..5 65 49 49 38 13 27 76 81 97
sift 0..4 49 38 49 27 13 65 76 81 97
sift 0..3 49 38 13 27 49 65 76 81 97
sift 0..2 38 27 13 49 49 65 76 81 97
sift 0..1 27 13 38 49 49 65 76 81 97
sift 0..0 13 27 38 49 49 65 76 81 97
關鍵字序列: 52 26 97 19 66 8 49
歸並排序
子序列長度n=1 26 52 19 97 8 66 49
子序列長度n=2 19 26 52 97 8 49 66
子序列長度n=4 8 19 26 49 52 66 97
關鍵字序列: 13 27 38 49 97 76 49 81 65
最小堆序列? true
*/
⑷ Java的排序演算法有哪些
排序： 插入，冒泡，選擇，Shell,快速排序
⑸ java 編寫一個程序,輸入3個整數,然後程序將對這三個整數按照從大到小進行排列
輸入三個數你可以這樣
Scanner in=new Scanner(System.in);
int a=in.nextInt();
Scanner in=new Scanner(System.in);
int b=in.nextInt();
Scanner in=new Scanner(System.in);
int c=in.nextInt();
然後對三個數進行比較。
int tmp=0；
if(a<b){
tmp=a;
a=b;
b=tmp;
}
if(a<c){
tmp=a;
a=c;
c=tmp;
}
if(b<c){
tmp=b;
b=c;
c=tmp;
}
System.out.println(a+" "+b+" "+c);
這就可以了，自己想想動動腦子才能靈活運用，如果只是給你代碼，你只會復制粘貼。
⑹ java十大演算法
演算法一：快速排序演算法
快速排序是由東尼·霍爾所發展的一種排序演算法。在平均狀況下，排序 n 個項目要Ο(n log n)次比較。在最壞狀況下則需要Ο(n2)次比較，但這種狀況並不常見。事實上，快速排序通常明顯比其他Ο(n log n) 演算法更快，因為它的內部循環（inner loop）可以在大部分的架構上很有效率地被實現出來。
快速排序使用分治法（Divide and conquer）策略來把一個串列（list）分為兩個子串列（sub-lists）。
演算法步驟：
1 從數列中挑出一個元素，稱為 "基準"（pivot），
2 重新排序數列，所有元素比基準值小的擺放在基準前面，所有元素比基準值大的擺在基準的後面（相同的數可以到任一邊）。在這個分區退出之後，該基準就處於數列的中間位置。這個稱為分區（partition）操作。
3 遞歸地（recursive）把小於基準值元素的子數列和大於基準值元素的子數列排序。
遞歸的最底部情形，是數列的大小是零或一，也就是永遠都已經被排序好了。雖然一直遞歸下去，但是這個演算法總會退出，因為在每次的迭代（iteration）中，它至少會把一個元素擺到它最後的位置去。
演算法二：堆排序演算法
堆排序（Heapsort）是指利用堆這種數據結構所設計的一種排序演算法。堆積是一個近似完全二叉樹的結構，並同時滿足堆積的性質：即子結點的鍵值或索引總是小於（或者大於）它的父節點。
堆排序的平均時間復雜度為Ο(nlogn) 。
演算法步驟：
創建一個堆H[0..n-1]
把堆首（最大值）和堆尾互換
3. 把堆的尺寸縮小1，並調用shift_down(0),目的是把新的數組頂端數據調整到相應位置
4. 重復步驟2，直到堆的尺寸為1
演算法三：歸並排序
歸並排序（Merge sort，台灣譯作：合並排序）是建立在歸並操作上的一種有效的排序演算法。該演算法是採用分治法（Divide and Conquer）的一個非常典型的應用。
演算法步驟：
1. 申請空間，使其大小為兩個已經排序序列之和，該空間用來存放合並後的序列
2. 設定兩個指針，最初位置分別為兩個已經排序序列的起始位置
3. 比較兩個指針所指向的元素，選擇相對小的元素放入到合並空間，並移動指針到下一位置
4. 重復步驟3直到某一指針達到序列尾
5. 將另一序列剩下的所有元素
⑺ java問題
只要加到比較方法之中就可以
如：比較方法如下
for(int i=0;i<100;i++)
for(int j=i;j<100;j++){
if(array[i]>array[j]){
int temp=array[i];
array[i]=array[j];
array[j]=temp;
}
}
把：：
比較次數compare_count、交換次數exchange_count、探測次數probe_count）加到裡面就可以
for(int i=0,compare_count=0;i<100;i++)
for(int j=i;j<100;j++){
if(array[i]>array[j]){
compare_count++;
int temp=array[i];
array[i]=array[j];
array[j]=temp;
exchange_count++;
}
}
就可以了
各種排序方法的綜合比較
一、時間性能
按平均的時間性能來分，有三類排序方法：
時間復雜度為O(nlogn)的方法有：快速排序、堆排序和歸並排序，其中以快速排序為最好；
時間復雜度為O(n2)的有：直接插入排序、起泡排序和簡單選擇排序，其中以直接插入為最好，特別是對那些對關鍵字近似有序的記錄序列尤為如此；
時間復雜度為O(n)的排序方法只有，基數排序。
當待排記錄序列按關鍵字順序有序時，直接插入排序和起泡排序能達到O(n)的時間復雜度;而對於快速排序而言，這是最不好的情況，此時的時間性能蛻化為O(n2)，因此是應該盡量避免的情況。
簡單選擇排序、堆排序和歸並排序的時間性能不隨記錄序列中關鍵字的分布而改變。
二、空間性能
指的是排序過程中所需的輔助空間大小。
1. 所有的簡單排序方法(包括：直接插入、起泡和簡單選擇)和堆排序的空間復雜度為O(1)；
2. 快速排序為O(logn )，為棧所需的輔助空間;
3. 歸並排序所需輔助空間最多，其空間復雜度為O(n );
4.鏈式基數排序需附設隊列首尾指針，則空間復雜度為O(rd )。
三、排序方法的穩定性能
1. 穩定的排序方法指的是，對於兩個關鍵字相等的記錄，它們在序列中的相對位置，在排序之前和經過排序之後，沒有改變。
2. 當對多關鍵字的記錄序列進行LSD方法排序時，必須採用穩定的排序方法。
3. 對於不穩定的排序方法，只要能舉出一個實例說明即可。
4. 快速排序和堆排序是不穩定的排序方法。
四、關於「排序方法的時間復雜度的下限」
本章討論的各種排序方法，除基數排序外，其它方法都是基於「比較關鍵字」進行排序的排序方法，可以證明，這類排序法可能達到的最快的時間復雜度為O(n logn )。(基數排序不是基於「比較關鍵字」的排序方法,所以它不受這個限制)。
可以用一棵判定樹來描述這類基於「比較關鍵字」進行排序的排序方法。
例如，對三個關鍵字進行排序的判定樹如下：
描述排序的判定樹有兩個特點：
1.樹上的每一次「比較」都是必要的;
2.樹上的葉子結點包含所有可能情況。
則由上圖所示「判定樹的深度為4」可以推出「至多進行三次比較」即可完成對三個關鍵字的排序。反過來說，由此判定樹可見，考慮最壞情況，「至少要進行三次比較」才能完成對三個關鍵字的排序。
對三個關鍵字進行排序的判定樹深度是唯一的。即無論按什麼先後順序去進行比較，所得判定樹的深度都是3。
當關鍵字的個數超過3之後，不同的排序方法其判定樹的深度不同。例如，對4個關鍵字進行排序時，直接插入的判定樹的深度為6, 而折半插入的判定樹的深度為5。
可以證明，對4個關鍵字進行排序，至少需進行5次比較。因為，4個關鍵字排序的結果有4!=24種可能，即排序的判定樹上必須有24個葉子結點，其深度的最小值為6。
一般情況下，對n個關鍵字進行排序，可能得到的結果有n! 種，由於含n! 個葉子結點的二叉樹的深度不小於 , 則對n個關鍵字進行排序的比較次數至少是
。利用斯蒂林近似公式
所以，基於「比較關鍵字」進行排序的排序方法，可能達到的最快的時間復雜度為O(n logn )。
快速排序是對冒泡排序的一種改進。它的基本思想是：通過一躺排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一不部分的所有數據都要小，然後再按次方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。
假設要排序的數組是A[1]……A[N]，首先任意選取一個數據（通常選用第一個數據）作為關鍵數據，然後將所有比它的數都放到它前面，所有比它大的數都放到它後面，這個過程稱為一躺快速排序。一躺快速排序的演算法是：
1）、設置兩個變數I、J，排序開始的時候I：=1，J：=N；
2）以第一個數組元素作為關鍵數據，賦值給X，即X：=A[1]；
3）、從J開始向前搜索，即由後開始向前搜索（J：=J-1），找到第一個小於X的值，兩者交換；
4）、從I開始向後搜索，即由前開始向後搜索（I：=I+1），找到第一個大於X的值，兩者交換；
5）、重復第3、4步，直到I=J；
例如：待排序的數組A的值分別是：（初始關鍵數據X：=49）
A[1] A[2] A[3] A[4] A[5] A[6] A[7]：
49 38 65 97 76 13 27
進行第一次交換後： 27 38 65 97 76 13 49
( 按照演算法的第三步從後面開始找
進行第二次交換後： 27 38 49 97 76 13 65
( 按照演算法的第四步從前面開始找>X的值，65>49,兩者交換，此時I：=3 )
進行第三次交換後： 27 38 13 97 76 49 65
( 按照演算法的第五步將又一次執行演算法的第三步從後開始找
進行第四次交換後： 27 38 13 49 76 97 65
( 按照演算法的第四步從前面開始找大於X的值，97>49,兩者交換，此時J：=4 )
此時再執行第三不的時候就發現I=J，從而結束一躺快速排序，那麼經過一躺快速排序之後的結果是：27 38 13 49 76 97 65，即所以大於49的數全部在49的後面，所以小於49的數全部在49的前面。
快速排序就是遞歸調用此過程——在以49為中點分割這個數據序列，分別對前面一部分和後面一部分進行類似的快速排序，從而完成全部數據序列的快速排序，最後把此數據序列變成一個有序的序列，根據這種思想對於上述數組A的快速排序的全過程如圖6所示：
初始狀態 {49 38 65 97 76 13 27}
進行一次快速排序之後劃分為 {27 38 13} 49 {76 97 65}
分別對前後兩部分進行快速排序 {13} 27 {38}
結束 結束 {49 65} 76 {97}
49 {65} 結束
結束
圖6 快速排序全過程
1）、設有N（假設N=10）個數，存放在S數組中；
2）、在S[1。。N]中任取一個元素作為比較基準，例如取T=S[1]，起目的就是在定出T應在排序結果中的位置K，這個K的位置在：S[1。。K-1]<=S[K]<=S[K+1..N]，即在S[K]以前的數都小於S[K]，在S[K]以後的數都大於S[K]；
3）、利用分治思想（即大化小的策略）可進一步對S[1。。K-1]和S[K+1。。N]兩組數據再進行快速排序直到分組對象只有一個數據為止。 1 2 3 4 5 6 7 8 9 10
如具體數據如下，那麼第一躺快速排序的過程是：
數組下標：
45 36 18 53 72 30 48 93 15 36
5） 36 36 18 15 30 45 48 93 72 534） 36 36 18 15 45 30 48 93 72 533） 36 36 18 15 72 30 48 93 45 532） 36 36 18 45 72 30 48 93 15 53
program kuaisu(input,output);
const n=10;
var
s:array[1..10] of integer;
k,l,m:integer;
procere qsort(lx,rx:integer);
var
I,j,t:integer;
Begin
I:lx;j:rx;t:s[I];
Repeat
While (s[j]>t) and (j>I) do
Begin
k:=k+1;
j:=j-1
end;
if I<j then
begin
s[I]:=s[j];I:=I+1;l:=l+1;
while (s[I]<t) and (I<j) do
begin
k:=k+1;
I:=I+1
End;
If I<j then
begin
S[j]:=s[I];j:=j-1;l:=l+1;
End;
End;
Until I=j;
S[I]:=t;I:=I+1;j:=j-1;l:=l+1;
If lx<j then qsort(lx,j);
If I<rx then qsort(I,rx)
End;{過程qsort結束}
Begin
Writeln('input 10 integer num:');
For m:=1 to n do read(s[m]);
K:=0;l:=0;
Qsort(l,n);
Writeln('排序後結果是：')；
For m:=1 to n do write(s[m]:4)
End.
通過一躺排序將45放到應該放的位置K，這里K=6，那麼再對S[1。。5]和S[6。。10]分別進行快速排序。程序代碼如下：<49,兩者交換，此時J:=6>