排序算法可以分為內部排序和外部排序，內部排序是數據記錄在內存中進行排序，而外部排序是因排序的數據很大，一次不能容納全部的排序記錄，在排序過程中需要訪問外存。常見的內部排序算法有：插入排序、希爾排序、選擇排序、冒泡排序、歸并排序、快速排序、堆排序！

1.排序

（1）冒泡排序

重復地走訪過要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。走訪數列的工作是重復地進行直到沒有再需要交換，也就是說該數列已經排序完成。時間復雜度O（n2），為穩定算法。

將數依次進行比較，并將大（或小）的，網后放，如下：

public static void bubbleSort(int[]arr){
for(int i=0;i<arr.length-1;i++){
for(int j=0;j<arr.length-i-1;j++){
//-1為了防止溢出
if(arr[j]>arr[j+1]){
//把大的數放在后面
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
}

（2）快速排序

通過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一部分的所有數據都要小，然后再按此方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。

public static void quickSort(int[]numbers,int low,int high){
if(low<high){
int middle=getMiddle(numbers,low,high);
//將numbers數組進行一分為二
quickSort(numbers,low,middle-1);
//對低字段表進行遞歸排序
quickSort(numbers,middle+1,high);
//對高字段表進行遞歸排序
}
}

（3）選擇排序

每一次從待排序的數據元素中選出最小（或最大）的一個元素，存放在序列的起始位置，直到全部待排序的數據元素排完。選擇排序是不穩定的排序方法（比如序列[5，5，3]第一次就將第一個[5]與[3]交換，導致第一個5挪動到第二個5后面）。

public static void selectSort(int[]a){
int minIndex=0;
int temp=0;
for(int i=0;i<a.length-1;i++){
minIndex=i;
//無序區的最小數據數組下標
for(intj=i+1;j<a.length;j++){
//在無序區中找到最小數據并保存其數組下標
if(a[j]<a[minIndex]){
minIndex=j;
}
}

//將最小元素放到本次循環的前端
temp=a;
a=a[minIndex];
a[minIndex]=temp;
}
}

（4）插入排序

每步將一個待排序的記錄，按其順序碼大小插入到前面已經排序的字序列的合適位置（從后向前找到合適位置后），直到全部插入排序完為止。

每一個數和它前面的數依次進行比較，因為前面的數的順序是已經排好的

private static int[]insertSort(int[]arr){
for(int i=1;i<arr.length;i++){
for(int j=i;j>0;j--){
if(arr[j]<arr[j-1]){
int temp=arr[j];
arr[j]=arr[j-1];
arr[j-1]=temp;
}else{
break;
}
}
}
return arr;
}

（5）希爾排序

把記錄按下標的一定增量分組，對每組使用直接插入排序算法排序；隨著增量逐漸減少，每組包含的關鍵詞越來越多，當增量減至1時，整個文件恰被分成一組，算法便終止。

public static void main(String[]args)
{
int[]a={49,38,65,97,76,13,27,49,78,34,12,64,1};
//希爾排序
int d=a.length;
while(true){
d=d/2;
for(int x=0;x<d;x++){
for(int i=x+d;i<a.length;i=i+d){
int temp=a;
int j;
for(j=i-d;j>=0&&a[j]>temp;j=j-d){
a[j+d]=a[j];
}
a[j+d]=temp;
}
}
if(d==10){
break;
}
}
}

（6）歸并排序

建立在歸并操作上的一種有效的排序算法,該算法是采用分治法（Divide and Conquer）的一個非常典型的應用。將已有序的子序列合并，得到完全有序的序列；即先使每個子序列有序，再使子序列段間有序。若將兩個有序表合并成一個有序表，稱為二路歸并。時間復雜度O(n log n)。

public static int[]sort(int[]nums,int low,int high){
int mid=(low+high)/2;
if(low<high){
//左邊
sort(nums,low,mid);
//右邊
sort(nums,mid+1,high);
//左右歸并
merge(nums,low,mid,high);
}
return nums;
}

以上就是動力節點java培訓機構的小編針對“編程技術分享之Java簡單算法的學習”的內容進行的回答，希望對大家有所幫助，如有疑問，請在線咨詢，有專業老師隨時為你服務。