java演算法排序演算法
package temp;
import sun.misc.Sort;
/**
* @author zengjl
* @version 1.0
* @since 2007-08-22
* @Des java幾種基本排序方法
*/
/**
* SortUtil:排序方法
* 關於對排序方法的選擇：這告訴我們，什麼時候用什麼排序最好。當人們渴望先知道排在前面的是誰時，
* 我們用選擇排序；當我們不斷拿到新的數並想保持已有的數始終有序時，我們用插入排序；當給出的數
* 列已經比較有序，只需要小幅度的調整一下時，我們用冒泡排序。
*/
public class SortUtil extends Sort {
/**
* 插入排序法
* @param data
* @Des 插入排序(Insertion Sort)是，每次從數列中取一個還沒有取出過的數，並按照大小關系插入到已經取出的數中使得已經取出的數仍然有序。
*/
public int[] insertSort(int[] data) {
1/11頁
int temp;
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);
}
}
return data;
}
/**
* 冒泡排序法
* @param data
* @return
* @Des 冒泡排序(Bubble Sort)分為若干趟進行，每一趟排序從前往後比較每兩個相鄰的元素的大小（因此一趟排序要比較n-1對位置相鄰的數）並在
* 每次發現前面的那個數比緊接它後的數大時交換位置；進行足夠多趟直到某一趟跑完後發現這一趟沒有進行任何交換操作（最壞情況下要跑n-1趟，
* 這種情況在最小的數位於給定數列的最後面時發生）。事實上，在第一趟冒泡結束後，最後面那個數肯定是最大的了，於是第二次只需要對前面n-1
* 個數排序，這又將把這n-1個數中最小的數放到整個數列的倒數第二個位置。這樣下去，冒泡排序第i趟結束後後面i個數都已經到位了，第i+1趟實
* 際上只考慮前n-i個數（需要的比較次數比前面所說的n-1要小）。這相當於用數學歸納法證明了冒泡排序的正確性
② 用JAVA實現快速排序演算法
本人特地給你編的代碼
親測
public class QuickSort {
public static int Partition(int a[],int p,int r){
x=a[r-1];
int i=p-1;
int temp;
for(int j=p;j<=r-1;j++){
if(a[j-1]<=x){
// swap(a[j-1],a[i-1]);
i++;
temp=a[j-1];
a[j-1]=a[i-1];
a[i-1]=temp;
}
}
//swap(a[r-1,a[i+1-1]);
temp=a[r-1];
a[r-1]=a[i+1-1];
a[i+1-1]=temp;
return i+1;
}
public static void QuickSort(int a[],int p,int r){
if(p<r){
int q=Partition(a,p,r);
QuickSort(a,p,q-1);
QuickSort(a,q+1,r);
}
}
public static void main(String[] stra){
int a[]={23,53,77,36,84,76,93,13,45,23};
QuickSort(a,1,10);
for (int i=1;i<=10;i++)
System.out.println(a[i-1]);
}
}
③ 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) 最壞情況; 對於大的、亂數串列一般相信是最快的已知排序
等。
④ 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;
}
}
⑤ Java的排序演算法有哪些
java的排序大的分類可以分為兩種：內排序和外排序。在排序過程中，全部記內錄存放在內存，則稱容為內排序，如果排序過程中需要使用外存，則稱為外排序。下面講的排序都是屬於內排序。
1.插入排序：直接插入排序、二分法插入排序、希爾排序。
2.選擇排序：簡單選擇排序、堆排序。
3.交換排序：冒泡排序、快速排序。
4.歸並排序
5.基數排序
⑥ 排序演算法 java編程
public class Sort
{
//選擇排序
public static void selectSort(char[] data)
{
int i,j,mx;
char temp;
for(i = 0; i<data.length-1; i++)
{
mx = i ;
for(j = i+1 ; j<data.length; j++)
{
if(data[mx] < data[j])
mx = j ;
}
temp = data[i];
data[i] = data[mx];
data[mx] = temp;
}
}
//插入排序
public static void insertSort(char[] data)
{
int i,j,mx;
char key ;
for(i=1; i < data.length -1; i++)
{
key = data[i];
mx = i;
for(j= i-1;j>0;j--)
{
if(key>data[j])
{
data[j+1] = data[j];
mx = j ;
}
}
data[mx]=key;
}
}
//顯示數據
public static void showData(char[] data)
{
int i;
for(i=0; i<data.length; i++)
System.out.print(data[i]+" ");
System.out.println();
}
public static void main(String[] args)
{
char[] data = {'9','8','7','6','5','4','3','2','1'};
Sort.selectSort(data);
Sort.showData(data);
Sort.insertSort(data);
Sort.showData(data);
}
}
這個程序還不夠你的要求,你可以再修改修改
⑦ Java演算法 排序問題
用到了Enumeration，代碼如下：
import java.util.Enumeration;
/**
* N個要素序列生成，個數為N!
*/
public class PermEnum implements Enumeration {
private int n;
private int c[], k;
private Object[] objs;
public PermEnum(Object[] items) {
n = items.length;
c = new int[n + 1];
for (int i = 0; i <= n; i++) {
c[i] = i;
}
objs = items;
k = 1;
}
public boolean hasMoreElements() {
return k < n;
}
public Object nextElement() {
int i = 0;
if ((k & 1) != 0) {
i = c[k];
}
Object tmp = objs[k];
objs[k] = objs[i];
objs[i] = tmp;
k = 1;
while (c[k] == 0) {
c[k] = k++;
}
c[k]--;
return objs;
}
// TEST輸出
public static void main(String[] args) {
String[] strs = {"1", "2", "3", "4"}; // 這里可以自己定義
System.out.println("N=" + strs.length);
Enumeration e = new PermEnum(strs);
int count = 0;
while (e.hasMoreElements()) {
String[] a = (String[]) e.nextElement();
System.out.print("[" + a[0]);
for (int i = 1; i < a.length; i++)
System.out.print(", " + a[i]);
System.out.println("]");
count++;
}
System.out.println("count=" + count);
}
}
⑧ JAVA 100個數字用演算法排序
classSortTest{//冒泡排序
publicvoidsort(int[]args){
for(intm:args){
System.out.print("排序前"+args[m]+"");
}
inttime1=0,time2=0;
for(inti=0;i<args.length-1;i++){
++time1;
for(intj=i+1;j<args.length;j++){
++time2;
inttemp;
if(args[i]>args[j]){
temp=args[j];
args[j]=args[i];
args[i]=temp;
}
}
}
System.out.println();
System.out.println("外循環次數："+time1+"內循環次數："+time2);
for(intn:args){
System.out.print("排序後"+n+"");
}
}
publicstaticvoidmain(String[]args){
int[]arg=newint[]{2,1,4,5,8,7,6,3,9,0};
newSortTest().sort(arg);
}
}
//降序排列循環次數最少
//輸出結果為：
//排序前4排序前1排序前8排序前7排序前9排序前3排序前6排序前5排序前0排序前2
//外循環次數：9內循環次數：45
//排序後0排序後1排序後2排序後3排序後4排序後5排序後6排序後7排序後8排序後9importjava.util.ArrayList;
importjava.util.Arrays;
importjava.util.Collections;
importjava.util.List;
importjava.util.Random;
/**
*classname:RapidSort
*description:Java快速排序法：數組和集合
*@authorJr
*
*/
publicclassRapidSort{
publicstaticvoidQuickSort(inte[],intfirst,intend){
inti=first,j=end,temp=e[first];
while(i<j){
while(i<j&&e[j]>=temp)
j--;
e[i]=e[j];
while(i<j&&e[i]<=temp)
i++;
e[j]=e[i];
}
e[i]=temp;
if(first<i-1)
QuickSort(e,first,i-1);
if(end>i+1)
QuickSort(e,i+1,end);
}
publicstaticvoidmain(String[]args){
intarr[]={49,38,65,97,76,13,27,49};
intlen=8;
inti;
System.out.printf("beforesort ");
for(i=0;i<len;i++)
System.out.printf("%d",arr[i]);
System.out.printf(" ");
QuickSort(arr,0,len-1);
System.out.printf("aftersorted ");
for(i=0;i<len;i++)
System.out.printf("%d",arr[i]);
}
}
結果：
beforesort
4938659776132749
aftersorted
1327384949657697