Java相關的基本算法

執行效率從快到慢：快速、希爾、插入、選擇、冒泡排序

1.數組逆序

實現思想：第一個遞增，最後一個遞減

//數組元素逆序
public static void receive(int[] arr){
	for (int start = 0, end = arr.length-1; start < end; start++,end--) {
		int temp = arr[start];
		arr[start] = arr[end];
		arr[end] = temp;
	}
}

2.選擇排序

實現思想：從左往右比較找到最小值，從左往右依次排放。

// 選擇排序
public static void select_sort(int[] arr) {
   for (int i = 0; i < arr.length - 1; i++) {
   	//選擇排序的優化
   	int k = i;
   	for (int j = k + 1; j < arr.length - 1; j++) {
   		// 找到最小值的下標
   		if (arr[j] < arr[k]) {
   			k = j;
   		}
   	}
   	if (k != i) {
   		int temp = arr[i];
   		arr[i] = arr[k];
   		arr[k] = temp;
   	}
   }
}

深入瞭解：https://www.cnblogs.com/shen-hua/p/5424059.html

3.冒泡排序

實現思想：從頭開始，依次相鄰比較，把最大的放到最後邊

//冒泡排序
public static void bubbleSort(int[] arr) {
	//功能
	//外層循環用來控制數組循環的圈數
	for (int i = 0; i < arr.length-1; i++) {
		//j < arr.length-1 爲了避免角標越界
		//j < 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;
			}
		}
	}
}

4.普通查找

實現思想：遍歷數組，查找相同的元素

//普通查找
public static int getArrayIndex(int[] arr, int number) {
	//把數組中的元素依次與指定的數值 進行比較
	for (int i = 0; i < arr.length; i++) {
		if (arr[i] == number) {
			//找到了
			return i;
		}
	}
	return -1;
}

5.二分法查找

實現思想：已知是排好序的數組，用中間元素和要查找的元素比較，大的話取左邊

//二分查找法(折半查找法)
public static int halfSearch(int[] arr, int number) {
	//定義3個變量，用來記錄min, min, mid的位置
	int min = 0;
	int max = arr.length-1;
	int mid = 0;
		while (min <= max) {
           mid = (min+max)/2;
		//沒找了， 更新範圍，繼續比較
		//更新範圍
		if (arr[mid] > number) {
			//在左邊
			max = mid-1;
		} else if(arr[i] < number){
			//在右邊
			min = mid+1;
		}
		else{
              return mid ;
          }
	 
	return -1;
}

https://www.cnblogs.com/kangyi/p/4262169.html

6.快排

實現思想：小的放前邊，找一個index，放最小的索引，循環一輪得到一個最小值

public static void quickSort(int[] arr) {
	if (null == arr) {
		System.out.println("傳入的數組爲空！！！");
	}
	for (int i =0;i < arr.length;i++) {
		int index = i;
		for (int j = i;j < arr.length;j++) {
			if (arr[index] > arr[j]) {
				index = j;
			}
		}
		if (index != i) {
			int temp = arr[index];
			arr[index] = arr[i];
			arr[i] = temp;
		}
	}
}

7.快速排序

實現思想：挖坑填數+分治法
思想：先取一個基數，下標從右向左找比基數小的，從左向右找比基數大的，找到和基數互換位置，然後進行下一輪操作，然後遞歸調用快排算法。

public static void quick_sort(int[] arr, int l, int r) {
	if (l < r) {
		// 確定數組下標的範圍
		int i = l, j = r;
		// 先確定基準數
		int flag = arr[l];
		while (i < j) {
			// 下標j從右往左遞減，找比基數小的數
			while (i < j && flag < arr[j])
				j--;
			if (i < j) {
				// 找到填補基數坑
				arr[i] = arr[j];
				i++;
			}
			// 下標i從左往右遞增，找比基數大的數
			while (i < j && flag > arr[i])
				i++;
			if (i < j) {
				// 找到填補新坑
				arr[j] = arr[i];
				j--;
			}

		}
		// 將原來的基準值放入中間數
		arr[j] = flag;

		// 遞歸調用
		// 中間數的左邊遞歸調用
		quick_sort(arr, l, i - 1);
		// 中間數的右邊遞歸調用
		quick_sort(arr, i + 1, r);

	}
}

8.遞歸算法

優點：
1.代碼簡潔
2.在樹的遍歷算法中，遞歸的實現比循環多
缺點：
1.由於是函數調用自身，時間和空間消耗比較大
2.遞歸中很多計算都是重複的，效率比較低
遞歸的優化：
使用動態規劃：將可能出現的結果全部計算並保存，直到得到所需要的結果

int Fib(unsigned n)
{
    if(n==1)return 1;
    if(n==0)return 0;
    return Fib(n-1)+Fib(n-2);
}

int Fib(unsigned n)
{
    int* f=new int[n+1];
    f[1]=1;f[0]=0;
    for(int i=0;i<=n;i++);
        f[i]=f[i-1]+f[i-2];  
    int r=f[n];
    return r;
}