JAVA實現三種排序演算法+二分查詢演算法
阿新 • • 發佈：2019-02-12
氣泡排序
氣泡排序（Bubble Sort），是一種電腦科學領域的較簡單的排序演算法。
其核心思想是：
對於一組需要排序的數字，依次將個位置上的數字與逐一與其之後的數字進行比較，如果他們的順序錯誤就把他們交換過來。 這個演算法的名字由來是因為越大的元素會經由交換慢慢“浮”到數列的頂端，故名。
package com.wip.sorting;
import java.util.Arrays;
public class BubbleSort {
/**
* 氣泡排序
* @param arr 需要排序的陣列元素
* @param 選擇排序
選擇排序（Selection sort）是一種簡單直觀的排序演算法。它的工作原理是每一次從待排序的資料元素中選出最小（或最大）的一個元素，存放在序列的起始位置，直到全部待排序的資料元素排完。 選擇排序是不穩定的排序方法（比如序列[5， 5， 3]第一次就將第一個[5]與[3]交換，導致第一個5挪動到第二個5後面）。
package com.wip.sorting;
import java.util.Arrays;
public class SelectSort {
/**
* 選擇排序
* @param arr 排序的陣列
* @param asc 是否升序
*/
public static void sort(int[] arr, boolean asc) {
for (int i = 0; i < arr.length; i++) {
int index = i;
for (int j = i + 1; j < arr.length; j++) {
if (asc) {
if (arr[index] > arr[j]) { // 升序，選擇無序區最小的元素
index = j;
}
} else {
if (arr[index] < arr[j]) {// 降序，選擇無序區最大的元素
index = j;
}
}
}
if (index != i) {
swap(arr,index,i);
}
}
}
/**
* 交換陣列中的兩個元素的位置
* @param arr // 陣列
* @param i // 變數i
* @param j // 變數j
*/
private static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
public static void main(String[] args) {
int[] arr = {1,3,23,8,10,34,13,56};
System.out.println("排序陣列：" + Arrays.toString(arr));
sort(arr, true);
System.out.println("升序排列：" + Arrays.toString(arr));
sort(arr, false);
System.out.println("降序排列：" + Arrays.toString(arr));
}
}
// 輸出結果
排序陣列：[1, 3, 23, 8, 10, 34, 13, 56]
升序排列：[1, 3, 8, 10, 13, 23, 34, 56]
降序排列：[56, 34, 23, 13, 10, 8, 3, 1]插入排序
插入排序(Insert Sort)將待排序的陣列分為2部分：有序區，無序區。其核心思想是每次取出無序區中的第一個元素，插入到有序區中。 有序與無序區劃分，就是通過一個變數標記當前陣列中，前多少個元素已經是區域性有序了。
package com.wip.sorting;
import java.util.Arrays;
public class InsertSort {
/**
* 插入排序
* @param arr 排序陣列
* @param asc 是否升序
*/
public static void sort(int[] arr, boolean asc) {
// 有序區最後一個元素位置
int orderedLastIndex = 0;//開始排序時，將有序區結束位置設為0 (開始位置總是0)，對應的無序區範圍就是 1-arr.length
for (int i = orderedLastIndex + 1; i < arr.length; i++) {//迭代無序區中的每一個元素，依次插入有序區中
int temp = arr[i];//記錄無序區中的第一個元素值
int insertIndex = i;//在有序區中插入的索引的位置，剛開始就設定為自己的位置
for (int j = orderedLastIndex; j >= 0; j--) {//從有序區從後往前開始比較
if (asc) {//升序，有序區中比當前無序區中元素大的都右移一個位置
if (arr[j] > temp) {
arr[j+1] = arr[j];
insertIndex --;//有序區每移動一次，將插入位置-1
} else {
break;//有序區當前位置元素<=無序區第一個元素，那麼之前的元素都會<=，不需要繼續比較
}
} else {//降序，有序區中比當前無序區中元素小的都右移一個位置
if (arr[j] < temp) {
arr[j+1] = arr[j];
insertIndex --;
} else {
break;
}
}
}
arr[insertIndex] = temp;
orderedLastIndex ++;
}
}
public static void main(String[] args) {
int[] arr = {1,8,3,2,10,34,67,93,11};
System.out.println("排序陣列：" + Arrays.toString(arr));
sort(arr,true);
System.out.println("升序陣列：" + Arrays.toString(arr));
sort(arr,false);
System.out.println("降序陣列：" + Arrays.toString(arr));
}
}
// 輸出結果
排序陣列：[1, 8, 3, 2, 10, 34, 67, 93, 11]
升序陣列：[1, 2, 3, 8, 10, 11, 34, 67, 93]
降序陣列：[93, 67, 34, 11, 10, 8, 3, 2, 1]高階二分查詢
1.二分查詢以稱折半查詢，優點是比較次數少，查詢速度快，平均效能好。
2.其缺點是要求待查表為有序表。
3.二分查詢的目的是查詢元素索引，有個前提是陣列元素必須為有序。
package com.wip.sorting;
public class BinarySearch {
/**
* 獲取某個數在數組裡出現在位置
* @param arr // 陣列
* @param num // 要找的數
* @return
*/
public static int getIndex(int[] arr, int num) {
int min = 0;
int max = arr.length - 1;
int mid = (min + max) /2;
System.out.println("min: " + min + " mid: " + mid + " max: " + max);
// 查詢的演算法
int index = -1; // 如果算到最後，index人值沒有改變，代表num在arr中不存在
while (true) {
if (arr[mid] == num) {// 找到查詢的數
index = mid;
break;
}
if (arr[mid] > num) {// num 在左邊
max = mid - 1;
mid = (min + max) / 2;
}
if (arr[mid] < num) {// num 在右邊
min = mid + 1;
mid = (min + max) / 2;
}
if (min > max) { // 不符合邏輯
break;// 退出迴圈
}
}
return index;
}
public static void main(String[] args) {
int[] arr = {11,22,33,89,34,66};
int num = 33;
if (getIndex(arr, num) == -1) {
System.out.println(num + " 在陣列中不存在");
} else {
System.out.println(num + "索引位置: " + getIndex(arr, num)); //33索引位置: 2
}
}
}