排序演算法：
-
內部排序：指將需要處理的所有的資料都載入到內部儲存器中進行排序
-
外部排序：當資料量過大，無法全部載入到記憶體中，需要藉助外部儲存器進行排序
-
常見的演算法分類：
5.1 氣泡排序
基本思想：通過對待排序從前往後（從下標小的元素開始），依次比較相鄰的元素的值，如是發現逆序則交換，使值較大的元素逐漸從前移向後部，像水底的起跑一樣。
總結規則：
- 一共進行n-1次大迴圈（陣列中有n個元素）
- 每一次排序的元素在逐漸的減少
- 如果在某次排序的過程中，沒有發生一次交換，說明排序已經完成了
public static int[] bubbleSort(int[] arr) {
int temp = 0;
boolean flag = false;
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
if(arr[j] > arr[j+1]){
flag = true;
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
if(!flag){
break;
}else {
flag = false;
}
}
return arr;
}
5.2 選擇排序
選擇排序也是屬於內部排序，是從要排序的資料中按照指定的規則挑選出某一元素，再依照規則交換位置達到排序的目的。
選擇排序的思想：
- 從arr[0]--arr[n-1]中找到最小的數值，然後交換arr[0]和最小值交換位置
- 從arr[1]--arr[n-1]中找到最小的數值，然後交換arr[1]和最小值交換位置
- ........
- 直到所有的資料進行交換完成
// 選擇排序，選擇陣列中的最小的元素與arr[0]進行交換，然後繼續在剩下的位置尋找次最小值與arr[1]交換，直到將所有的資料排序完成
public static int[] selectSort(int[] arr){
int temp = 0;
int index = 0;
for (int i = 0; i < arr.length-1; i++) {
index = i; // 初始最小值的索引為i
for (int j = i+1; j < arr.length; j++) {
//如果arr[j]小於arr[index]，則j為最小值的索引
if(arr[j] < arr[index]){
index = j;
}
}
// 交換最小值和arr[i]的位置
temp = arr[i];
arr[i] = arr[index];
arr[index] = temp;
}
return arr;
}
5.3 插入排序
插入排序屬於內部排序法，是對於欲排序的元素以插入的方式尋找該元素的適當位置。
插入排序的思想：把n個待排序的元素看做是一個有序表和無序表，開始時有序表中只含有一個元素，無序表中包含n-1個元素。排序的過程中，每次從無序表中取出第一個元素，把它插入到有序表中的適當位置，使之形成新的有序表。
程式碼的實現：
/**
* 插入排序，將列表看做一個有序表和一個無序表
* @param arr
* @return
*/
public static int[] insertSort(int[] arr){
int temp = 0;
int index = 0;
for (int i = 1; i < arr.length; i++) {
temp = arr[i];
index = i-1;
// 倒敘判斷從i-1到0進行判斷，如果出現temp>arr[index]，則說明arr[index+1]則為要插入的部分
while (index >= 0 && temp < arr[index]){
arr[index+1] = arr[index]; //依次移動資料
index --;
}
// 在arr[index+1]中插入資料
arr[index+1] = temp;
}
return arr;
}
5.4 希爾排序（ 縮小增量排序 ）
基本思想： 希爾排序是把記錄按下標的一定增量分組，對每組使用直接插入排序演算法排序；隨著增量逐漸減少，每組包含的關鍵詞越來越多，當增量減至1時，整個檔案恰被分成一組，演算法便終止。
安照一定的步長，將一定數量的資料分為一組。設定每組的資料增量為上一次增量的一半，然後將每組的資料量增加，陣列減少，直到只剩下一個陣列為止。
希爾排序方法：
- 對有序序列插入時採用交換法
- 對有序序列插入時採用移動法
/**
* 希爾交換法
* @param arr
* @return
*/
public static int[] shellSort(int[] arr){
int temp = 0;
int count = 0;
for(int gap = arr.length/2; gap > 0; gap /= 2){
for(int i=gap; i< arr.length; i++){
// 遍歷組中的所有資料，gap為步長
for(int j=i-gap; j >= 0; j -= gap){
if(arr[j] > arr[j+gap]){
temp = arr[j];
arr[j] = arr[j+gap];
arr[j+gap] = temp;
}
}
}
}
return arr;
}
// 移動位置（結合插入排序）
public static int[] shellMoveSort(int[] arr){
for(int gap = arr.length/2; gap > 0; gap /= 2){
for(int i=gap; i < arr.length; i++){
int j = i;
int temp = arr[j];
if(arr[j] < arr[j-gap]){
while (j - gap >= 0 && temp < arr[j - gap]){
arr[j] = arr[j-gap];
j -= gap;
}
arr[j] = temp;
}
}
}
return arr;
}
5.5 快速排序
基本思想：通過一次排序將要排序的資料分割成獨立的兩個部分，其中一部分的所有資料都比另一部分的所有資料都要小，然後按照這種方法對這兩個部分資料分佈進行快速排序，整個排序部分可以使用遞迴進行，以此達到整個資料變成有序序列。
思路分析：
- 假設陣列為arr，左側為left，右側為right，設定選擇的初始位置為
- 從左側開始查詢，找到大於等於mid的值為止，從右側也開始查詢，直到找到小於等於mid的值
- 直到找到
l<r的位置，然後遞迴進行快速排序。
/**
* 快速排序
*
* @param arr
* @param left
* @param right
* @return
*/
public static int[] quickSort(int[] arr, int left, int right) {
if (left >= right) return null;
// 如果陣列中left與right相等或者left大於right，則跳出程式
int l = left;
int r = right;
int mid = arr[(l + r) / 2];
int temp = 0;
while (l < r) {
while (l < r && arr[l] < mid) {
l++;
}
while (r > l && arr[r] > mid) {
r--;
}
if (l >= r) {
break;
}
temp = arr[l];
arr[l] = arr[r];
arr[r] = temp;
if (arr[l] == mid){
r--;
}
if (arr[r] == mid) {
l++;
}
}
quickSort(arr, left, l - 1);
quickSort(arr, r + 1, right);
return arr;
}
5.6 歸併排序
歸併排序是利用歸併的思想實現的排序方法，該演算法採用經典的分治策略（分治法將問題分為一些小的問題然後遞迴求解，而治階段則將分的階段得到的各答案“修補”在一起，即分而治之）
基本方法：
- 首先將陣列成分成兩個部分，一直拆分直到拆分到每個子陣列中只有一個元素
- 然後進行合併相同相鄰的拆分部分，按照順序進行合併，直到合併成完整的陣列
- 使用遞迴方法完成最好，時間複雜度為
O(nlogn)
/**
* 歸併排序
* @param arr
* @param left
* @param right
* @return
*/
public static int[] mergeSort(int[] arr, int left, int right){
// 如果left大於right，說明陣列中只有1個或者沒有資料，則將直接返回空
if(left >= right) return null;
int mid = (left + right)/2;
// 分割
mergeSort(arr, left, mid);
mergeSort(arr, mid+1, right);
int i = left;
int j = mid+1;
int t = 0;
int[] temp = new int[(right - left + 1)];
while (i <= mid && j <= right){
if(arr[i] <= arr[j]){
temp[t] = arr[i];
t ++;
i ++;
}else {
temp[t] = arr[j];
t ++;
j ++;
}
}
// 將剩餘的內容填充到temp中
while (i <= mid){
temp[t] = arr[i];
t++;
i++;
}
// 將剩餘的right內容填充到temp中
while (j <= right){
temp[t] = arr[j];
t++;
j++;
}
// 將temp資料拷貝到arr中
for(int k=left; k<=right; k++){
arr[k] = temp[k-left];
}
System.out.println("排序後的資料為：" + Arrays.toString(temp));
return arr;
}
5.7 基數排序
- 基數排序屬於“分配式排序”，又稱桶子法，它是通過鍵值的各個位的值，將要排序的元素分配到某些“桶”中，達到排序的作用
- 基數排序屬於穩定性的排序，基數排序法的是效率高的穩定性排序法
- 基數排序是桶排序的擴充
- 基數排序的實現方法：將整數位按照位數切割成不同的數字，然後按照每個位分別比較。
實現的方法：
- 定義一個二維陣列，表示10個桶，每一個桶就是一個一維陣列
- 為了防止在放入輸的時候資料溢位，則每個一維陣列（桶），大小定為arr.length
- 基數排序就是使用空間換時間的經典演算法。
/**
* 基數排序
* @param arr
* @return
*/
public static int[] radixSort(int[] arr){
int[][] bubble = new int[10][arr.length]; //設定桶的數量，每個桶最多盛放整個陣列
// 尋找陣列中最大的數
int max = arr[0];
for(int i=1; i<arr.length; i++){
if(arr[i] > max){
max = arr[i];
}
}
int maxLength = (max + "").length();
// 根據數值中最大資料的位數判定需要多少次迴圈
for (int i = 0; i < maxLength; i++) {
int[] bubbleLength = new int[10]; // 桶的放的資料的量
// 將資料根據個位、十位、百位依次放入桶中
for (int j = 0; j < arr.length; j++) {
int size = arr[j] / (int)Math.pow(10, i) % 10;
bubble[size][bubbleLength[size]] = arr[j];
bubbleLength[size] ++;
}
//依次將資料取出，並放入到原來的陣列中
int index = 0;
for(int j=0; j<bubble.length; j++){
if(bubbleLength[j] > 0){
for(int k=0; k<bubbleLength[j]; k++){
arr[index++] = bubble[j][k];
}
}
}
}
return arr;
}
