常用排序算法
分類結構圖
複雜度
分類
交換冒泡排序
import java.util.Arrays;
public class BubbleExchangeSort{
public static void main(String[] args){
int[] arr=new int[]{5,7,1,3,5,1,0,6};
sort(arr);
System.out.println(Arrays.toString(arr));
}
private static void sort(int[] arr){
for(int i=0;i<arr.length-1;i++){
for(int j=i+1;j<arr.length;j++){
if(arr[j]<arr[i]){
int temp=arr[j];
arr[j]=arr[i];
arr[i]=temp;
}
}
}
}
}
交換快速排序
徒手寫代碼
- 第一次寫出錯地方：improt java.utils.arrays—>improt java.util.Arrays
sort(arr,0,arr.length);—->sort(arr,0,arr.length-1);
import java.util.Arrays; public class QuickChangeSort{ //切分算法 private static int partition(int[] arr,int lo,int hi){ int key=arr[lo]; while(lo<hi){ while(arr[hi]>=key&&lo<hi) hi--; arr[lo]=arr[hi]; while(arr[lo]<=key&&lo<hi) lo++; arr[hi]=arr[lo]; } arr[hi]=key; return hi; } //排序算法 private static void sort(int[] arr,int lo,int hi){ //終止條件以及異常處理 if(arr==null||lo>=hi)return; int index=partition(arr,lo,hi); sort(arr,lo,index-1); sort(arr,index+1,hi); } //test public static void main(String[] args){ int[] arr=new int[]{5,4,8,6,7,9}; sort(arr,0,arr.length-1); System.out.println(Arrays.toString(arr)); } }
插入直接排序
思路：
- 第一步：從第二個元素開始一次加一，依次和前面所有元素比較。
- 第二步：若該元素小於比較的元素，前面的元素後移；接着比較前面的元素，接着後移。不滿足“小於”的條件，將該元素插入到空下的位置。
- 重複一二步驟。
實現
import java.util.Arrays; public class DircetInsertSort{ public static void main(String[] args){ int[] arr=new int[]{5,3,1,4,2,6,9}; sort(arr); System.out.println(Arrays.toString(arr)); } //直接插入排序 private static void sort(int[] arr){ //標記待比較的值 int temp=0; for(int i=1;i<arr.length;i++){ temp=arr[i]; int j; for(j=i-1;j>=0;j--){ //注意這個比較條件，和待比較數據比較 if(temp<arr[j]){ //是所有大於待比較數據都要後移 arr[j+1]=arr[j]; }else break; } arr[j+1]=temp; } } }
插入希爾排序排序
import java.util.Arrays;
public class ShellInsertSort{
public static void main(String[] agrs){
int[] arr=new int[]{4,5,2,7,6,27,2,8,2,5};
sort(arr);
System.out.println(Arrays.toString(arr));
}
/* 0. 獲取數組長度：int a=數組長度;
1.a的一半爲增量值。
2. 以該增量爲基數，對比數據，將小的數據交換到前面。遍歷所有數據。
3. 重複1、2步驟。終止條件：增量值小於1。
*/
private static void sort(int[] arr){
//獲取初試增量值
int incrementNum=arr.length/2;
while(incrementNum>0){
for(int i=0;i<arr.length;i++){
for(int j=i+incrementNum;j<arr.length;j+=incrementNum){
if(arr[j]<arr[i]){
int temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}
}
incrementNum/=2;
}
}
}
選擇簡單排序
思路：每輪比較出最小的值的索引，然後和待比較值交換位置。接着比較下一個，一直進行即可。
import java.util.Arrays; public class SimpleChooseSort{ //簡單選擇算法 private static void sort(int[] arr){ int minIndex=0; for(int i=0;i<arr.length-1;i++){ minIndex=i; for(int j=i+1;j<arr.length;j++){ // 這裏是和arr[min]比較，不是和arr[i]比較 if(arr[j]<arr[minIndex]){ minIndex=j; } } if(minIndex!=i){ int temp=arr[i]; arr[i]=arr[minIndex]; arr[minIndex]=temp; } } } public static void main(String[] args){ int[] arr=new int[]{5,7,1,3,5,1,0,6}; sort(arr); System.out.println(Arrays.toString(arr)); } }
選擇堆排序
/*
* 堆選擇排序
*/
public static void heapChooseSort(int[] array) {
buildHeap(array);// 構建堆
int n = array.length;
int i = 0;
for (i = n - 1; i >= 1; i--) {
swap(array, 0, i);
heapify(array, 0, i);
}
}
public static void buildHeap(int[] array) {
int n = array.length;// 數組中元素的個數
for (int i = n / 2 - 1; i >= 0; i--)
heapify(array, i, n);
}
public static void heapify(int[] A, int idx, int max) {
int left = 2 * idx + 1;// 左孩子的下標（如果存在的話）
int right = 2 * idx + 2;// 左孩子的下標（如果存在的話）
int largest = 0;// 尋找3個節點中最大值節點的下標
if (left < max && A[left] > A[idx])
largest = left;
else
largest = idx;
if (right < max && A[right] > A[largest])
largest = right;
if (largest != idx) {
swap(A, largest, idx);
heapify(A, largest, max);
}
}
public static void swap(int[] array, int i, int j) {
int temp = 0;
temp = array[i];
array[i] = array[j];
array[j] = temp;
}
歸併排序
import java.util.Arrays;
public class MergeSort{
/*
* 思路：以mid爲分界線，左右兩邊依次比較，取小的放到臨時數組中。直到所有全部處理完。再把臨時數據放到arr[lo,hi]中。
* 1. 在滿足lo<hi的前提下，取左開始指針lp=lo，右指針rp=mid+1;
* 2. 左右指針的值對比，取小的放到臨時數組中，所對應指針加一，臨時數組指針加一。
* 3.
*/
private static void merge(int[] arr,int lo,int mid,int hi){
//臨時數組
int[] tempArr=new int[hi-lo+1];
//臨時數組下標
int index=0;
//左右指針
int lp=lo,rp=mid+1;
while(lp<=mid&&rp<=hi){
if(arr[lp]<arr[rp]){
tempArr[index++]=arr[lp++];
}else{
tempArr[index++]=arr[rp++];
}
}
while(lp<=mid)
tempArr[index++]=arr[lp++];
while(rp<=hi)
tempArr[index++]=arr[rp++];
//歸併
for(int i=0;i<tempArr.length;i++){
arr[lo++]=tempArr[i];
}
}
private static void sort(int[] arr,int lo,int hi){
if(arr==null||lo>=hi)return;
int mid=(lo+hi)/2;
sort(arr,lo,mid);
sort(arr,mid+1,hi);
merge(arr,lo,mid,hi);
}
public static void main(String[] agrs){
int[] arr=new int[]{4,5,2,7,6,27,2,8,2,5};
sort(arr,0,arr.length-1);
System.out.println(Arrays.toString(arr));
}
}
基數排序
/*
* 基數排序法
*/
public static void radixSort(int[] number, int d) {
int k = 0;
int n = 1;
int m = 1;
int[][] temp = new int[number.length][number.length];
int[] order = new int[number.length];
while (m <= d) {
for (int i = 0; i < number.length; i++) {
int lsd = ((number[i] / n) % 10);
temp[lsd][order[lsd]] = number[i];
order[lsd]++;
}
for (int i = 0; i < d; i++) {
if (order[i] != 0)
for (int j = 0; j < order[i]; j++) {
number[k] = temp[i][j];
k++;
}
order[i] = 0;
}
n *= 10;
k = 0;
m++;
}
}
