java數組排序示例(冒泡排序、疾速排序、希爾排序、選擇排序)。本站提示廣大學習愛好者：（java數組排序示例(冒泡排序、疾速排序、希爾排序、選擇排序)）文章只能為提供參考，不一定能成為您想要的結果。以下是java數組排序示例(冒泡排序、疾速排序、希爾排序、選擇排序)正文
疾速排序法重要是應用了Arrays中的一個辦法Arrays.sort（）完成。
冒泡法是應用遍歷數組停止比擬，經由過程赓續的比擬將最小值或許最年夜值一個一個的遍歷出來。
選擇排序法是將數組的第一個數據作為最年夜或許最小的值，然後經由過程比擬輪回，輸入有序的數組。
拔出排序是選擇一個數組中的數據，經由過程赓續的拔出比擬最初停止排序。
package com.firewolf.sort;
public class MySort {
/**
* @param args
*/
public static void main(String[] args) {
int array[] = {45,32,54,12,43,65,11,3,43,6,33,90,44,1,178};
MySort mySort = new MySort();
mySort.insertSort(array);
System.out.print("拔出排序成果 ： ");
mySort.printArray(array);
System.out.println();
mySort.bubbleSort(array);
System.out.print("冒泡排序成果 ： ");
mySort.printArray(array);
mySort.qsort(array);
System.out.println();
System.out.print("疾速排序成果 ： ");
mySort.printArray(array);
mySort.shellSort(array);
System.out.println();
System.out.print("希爾排序成果 ： ");
mySort.printArray(array);
mySort.selectSort(array);
System.out.println();
System.out.print("選擇排序成果 ： ");
mySort.printArray(array);
}
/**
* 直接拔出排序
* 根本思惟：在要排序的一組數中，假定後面(n-1)[n>=2] 個數曾經是排好次序的，如今要把第n個數插到後面的有序數中，使得這n個數也是排好次序的。如斯重復輪回，直到全體排好次序
*/
public void insertSort(int[] array){
int temp=0;
for(int i=1;i<array.length;i++){
int j=i-1;
temp=array[i];
for(;j>=0&&temp<array[j];j--){
array[j+1]=array[j]; //將年夜於temp的值全體後移一個單元
}
array[j+1]=temp;
}
}
/**
* 冒泡排序
* 根本思惟：在要排序的一組數中，對以後還未排好序的規模內的全體數，自上而下對相鄰的兩個數順次停止比擬和調劑，讓較年夜的數往下沉，較小的往上冒。即：每當兩相鄰的數比擬後發明它們的排序與排序請求相反時，就將它們交換。
*/
public void bubbleSort(int[] array) {
int temp;
for(int i=0;i<array.length;i++){//趟數
for(int j=0;j<array.length-i-1;j++){//比擬次數
if(array[j]>array[j+1]){
temp=array[j];
array[j]=array[j+1];
array[j+1]=temp;
}
}
}
}
/**
* 疾速排序
* 根本思惟：選擇一個基准元素,平日選擇第一個元素或許最初一個元素,經由過程一趟掃描，將待排序列分紅兩部門,一部門比基准元素小,一部門年夜於等於基准元素,此時基准元素在其排好序後的准確地位,然後再用異樣的辦法遞歸地排序劃分的兩部門。
* @param array
*/
public void qsort(int array[]){
if(array.length>1){
_qsort(array,0,array.length-1);
}
}
/**
* 一趟疾速排序
* @param array
*/
private void _qsort(int[] array,int low,int high){
if(low < high){
int middle = getMiddle(array, low, high);
_qsort(array,low,middle-1);
_qsort(array, middle+1, high);
}
}
/**
* 獲得中央值
*/
private int getMiddle(int[] array,int low,int high){
int tmp = array[low];
while(low < high){
while(low < high && array[high] >= tmp)
high--;
array[low] = array[high];
while(low<high && array[low]<=tmp)
low++;
array[high] = array[low];
}
array[low] = tmp;
return low;
}
/**
* 簡略選擇排序
* 根本思惟：在要排序的一組數中，選出最小的一個數與第一個地位的數交流；然後在剩下的數傍邊再找最小的與第二個地位的數交流，如斯輪回到倒數第二個數和最初一個數比擬為止。
* @param array
*/
public void selectSort(int[] array){
int position=0;
for(int i=0;i<array.length;i++){
int j=i+1;
position=i;
int temp=array[i];
for(;j<array.length;j++){
if(array[j]<temp){
temp=array[j];
position=j;
}
}
array[position]=array[i];
array[i]=temp;
}
}
/**
* 希爾排序（最小增量排序）
* 根本思惟：算法先將要排序的一組數按某個增量d（n/2,n為要排序數的個數）分紅若干組，每組中記載的下標相差d.對每組中全體元素停止直接拔出排序，然後再用一個較小的增量（d/2）對它停止分組，在每組中再停止直接拔出排序。當增量減到1時，停止直接拔出排序後，排序完成。
* @param array
*/
public void shellSort(int[] array){
double d1=array.length;
int temp=0;
while(true){
d1= Math.ceil(d1/2);
int d=(int) d1;
for(int x=0;x<d;x++){
for(int i=x+d;i<array.length;i+=d){
int j=i-d;
temp=array[i];
for(;j>=0&&temp<array[j];j-=d){
array[j+d]=array[j];
}
array[j+d]=temp;
}
}
if(d==1)
break;
}
}
/**
* 打印數組中的一切元素
*/
public void printArray(int[] array){
for (int i = 0; i < array.length; i++) {
System.out.print(array[i]+" ");
}
}
}
上面是幾種排序辦法離開應用的示例
應用Arrays帶有的排序辦法疾速排序
import java.util.Arrays;
public class Test2{
public static void main(String[] args){
int[] a={5,4,2,4,9,1};
Arrays.sort(a); //停止排序
for(int i: a){
System.out.print(i);
}
}
}
冒泡排序算法
public static int[] bubbleSort(int[] args){//冒泡排序算法
for(int i=0;i<args.length-1;i++){
for(int j=i+1;j<args.length;j++){
if (args[i]>args[j]){
int temp=args[i];
args[i]=args[j];
args[j]=temp;
}
}
}
return args;
}
選擇排序算法
public static int[] selectSort(int[] args){//選擇排序算法
for (int i=0;i<args.length-1 ;i++ ){
int min=i;
for (int j=i+1;j<args.length ;j++ ){
if (args[min]>args[j]){
min=j;
}
}
if (min!=i){
int temp=args[i];
args[i]=args[min];
args[min]=temp;
}
}
return args;
}
拔出排序算法
public static int[] insertSort(int[] args){//拔出排序算法
for(int i=1;i<args.length;i++){
for(int j=i;j>0;j--){
if (args[j]<args[j-1]){
int temp=args[j-1];
args[j-1]=args[j];
args[j]=temp;
}else break;
}
}
return args;
}
以上就是java中的四種排序辦法。分歧的辦法效力紛歧樣，上面是分歧的算法的比擬和數據交流時的年夜O表現。
冒泡排序：比擬O(N2) 數據交流O(N2)
選擇排序：比擬O(N2) 數據交流O(N)
拔出排序：比擬O(N2) 復制數據O(N)
在現實運用中，我們要盡可能選擇效力高的算法。
