冒泡排序

依次比較相鄰的元素，若發現逆順序，則交換。小的向前換，大的向后換，本次循環完畢之后再次從頭開始掃描，直到某次掃描中沒有元素交換，說明每個元素都不比它后面的元素大，至此排序完成。

import java.util.Arrays;public class BubbleSort {public static void main(String[] args) {int[] arr=new int[] {5,7,2,9,4,1,0,5,7};System.out.println(Arrays.toString(arr));bubbleSort(arr);System.out.println(Arrays.toString(arr));}public static void bubbleSort(int[] arr) {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;}}}}}

結果展示

選擇排序

每一次從待排序的數據元素中選出最小（或最大）的一個元素，存放在序列的起始位置，直到全部待排序的數據元素排完。

import java.util.Arrays;public class SelectSort {public static void main(String[] args) {int[] arr = new int[] {3,4,5,7,1,2,0,3,6,8};selectSort(arr);System.out.println(Arrays.toString(arr));}public static void selectSort(int[] arr) {for(int i=0;i<arr.length;i++) {int minIndex=i;for(int j=i+1;j<arr.length;j++) {if(arr[minIndex]>arr[j]) {minIndex=j;}}if(i!=minIndex) {int temp=arr[i];arr[i]=arr[minIndex];arr[minIndex]=temp;}}}}

結果展示

插入排序

• 從第一個元素開始，該元素可以認為已經被排序
• 取出下一個元素，在已經排序的元素序列中從后向前掃描
• 如果該元素（已排序）大于新元素，將該元素移到下一位置
• 重復步驟3，直到找到已排序的元素小于或者等于新元素的位置
• 將新元素插入到該位置后
• 重復上面步驟

import java.util.Arrays;public class InsertSort {public static void main(String[] args) {int[] arr = new int[] {5,3,2,8,5,9,1,0};insertSort(arr);System.out.println(Arrays.toString(arr));}public static void insertSort(int[] arr) {for(int i=1;i<arr.length;i++) {if(arr[i]<arr[i-1]) {int temp=arr[i];int j;for(j=i-1;j>=0&&temp<arr[j];j--) arr[j+1]=arr[j];arr[j+1]=temp; }}}}

結果展示

希爾排序

希爾排序(Shell’s Sort)是插入排序的一種又稱“縮小增量排序”。希爾排序是把記錄按下標的一定增量分組，對每組使用直接插入排序算法排序；隨著增量逐漸減少，每組包含的關鍵詞越來越多，當增量減至1時，整個文件恰被分成一組，算法便終止。

import java.util.Arrays;public class ShellSort {public static void main(String[] args) {int[] arr = new int[] { 3, 5, 2, 7, 8, 1, 2, 0, 4, 7, 4, 3, 8 };System.out.println(Arrays.toString(arr));shellSort(arr);System.out.println(Arrays.toString(arr));}public static void shellSort(int[] arr) {int k = 1;for (int d = arr.length / 2; d > 0; d /= 2) {for (int i = d; i < arr.length; i++) {for (int j = i - d; j >= 0; j -= d) {if (arr[j] > arr[j + d]) {int temp = arr[j];arr[j] = arr[j + d];arr[j + d] = temp;}}}System.out.println( Arrays.toString(arr));k++;}}}

結果展示

堆排序

在堆的數據結構中，堆中的最大值總是位于根節點(在優先隊列中使用堆的話堆中的最小值位于根節點)。

堆中定義以下幾種操作：

• 最大堆調整：將堆的末端子節點作調整，使得子節點永遠小于父節 點創建最大堆：將堆所有數據重新排序。
• 堆排序：移除位在第一個數據的根節點，并做最大堆調整的遞歸運算。

import java.util.Arrays;public class HeapSort {public static void main(String[] args) {int[] arr = new int[] {9,6,8,7,0,1,10,4,2};heapSort(arr);System.out.println(Arrays.toString(arr));}public static void heapSort(int[] arr) {int start = (arr.length-1)/2;for(int i=start;i>=0;i--) {maxHeap(arr, arr.length, i);}for(int i=arr.length-1;i>0;i--) {int temp = arr[0];arr[0]=arr[i];arr[i]=temp;maxHeap(arr, i, 0);}}public static void maxHeap(int[] arr,int size,int index) {int leftNode = 2*index+1;int rightNode = 2*index+2;int max = index;if(leftNode<size&&arr[leftNode]>arr[max]) {max=leftNode;}if(rightNode<size&&arr[rightNode]>arr[max]) {max=rightNode;}if(max!=index) {int temp=arr[index];arr[index]=arr[max];arr[max]=temp;maxHeap(arr, size, max);}}}

結果展示

歸并排序

歸并操作的工作原理如下：

• 第一步：申請空間，使其大小為兩個已經 排序序列之和，該空間用來存放合并后的序列
• 第二步：設定兩個 指針，最初位置分別為兩個已經排序序列的起始位置
• 第三步：比較兩個指針所指向的元素，選擇相對小的元素放入到合并空間，并移動指針到下一位置重復步驟3直到某一指針超出序列尾，將另一序列剩下的所有元素直接復制到合并序列尾

import java.util.Arrays;public class MergeSort {public static void main(String[] args) {int[] arr = new int[] {1,3,5,2,4,6,8,10};System.out.println(Arrays.toString(arr));mergeSort(arr, 0, arr.length-1);System.out.println(Arrays.toString(arr));}public static void mergeSort(int[] arr,int low,int high) {int middle=(high+low)/2;if(low<high) {mergeSort(arr, low, middle);mergeSort(arr, middle+1, high);merge(arr,low,middle,high);}}public static void merge(int[] arr,int low,int middle, int high) {int[] temp = new int[high-low+1];int i=low;int j=middle+1;int index=0;while(i<=middle&&j<=high) {if(arr[i]<=arr[j]) {temp[index]=arr[i];i++;}else {temp[index]=arr[j];j++;}index++;}while(j<=high) {temp[index]=arr[j];j++;index++;}while(i<=middle) {temp[index]=arr[i];i++;index++;}for(int k=0;k<temp.length;k++) {arr[k+low]=temp[k];}}}

結果展示

快速排序

快速排序算法利用的是一趟快速排序,基本內容是選擇一個數作為準基數,然后利用這個準基數將遺傳數據分為兩個部分,第一部分比這個準基數小,都放在準基數的左邊,第二部分都比這個準基數大,放在準基數的右邊。

import java.util.Arrays;public class QuickSort {public static void main(String[] args) {int[] arr = new int[] {3,4,6,7,2,7,2,8,0,9,1};quickSort(arr,0,arr.length-1);System.out.println(Arrays.toString(arr));}public static void quickSort(int[] arr,int start,int end) {if(start<end) {int stard=arr[start];int low=start;int high=end;while(low<high) {while(low<high&&stard<=arr[high]) {high--;}arr[low]=arr[high];while(low<high&&arr[low]<=stard) {low++;}arr[high]=arr[low];}arr[low]=stard;quickSort(arr, start, low);quickSort(arr, low+1, end);}}}

結果展示

---

總結

以上是生活随笔為你收集整理的java冒泡排序_JAVA实现经典排序算法（冒泡排序、选择排序、插入排序、希尔排序、堆排序、归并排序、快速排序）...的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。