查詢方法：
1.順序查詢。
按陣列的順序從前往後一直比較，直到找到目標值返回。
優點：對陣列的結構沒有特定的要求，演算法簡單。
缺點：當陣列個數n較大時，效率低下。
時間複雜度：最大時間複雜度是o(n)，最小時間複雜度是o(1),平均時間複雜度是o(n/2).
/**
* 順序查詢演算法
* * @param array
* 陣列
* @param target
* 目標
* @return 找到，返回下標值；找不到返回0x80000000
*/public int sequentialsearch(int array, int target)
if (array.length <= 0)
for (int index = 0; index < array.length - 1; index++)
} return integer.min_value;
}
2.二分查詢：
從陣列的中間開始查詢，若找到目標值則返回；若目標值比中間數小則遞迴查詢前半部分；若目標值比中間數大則遞迴查詢後半部分。
優點：比較次數較少，效率比較高
缺點：只適用於不經常變動有序陣列
時間複雜度：o（log（n））
/**
* 二分查詢演算法
* @param array 有序陣列
* @param target 目標數值
* @return 找到，返回下標值；找不到返回0x80000000
*/public int binarysearch(int array, int target)
if (array.length <= 0)
int low = 0;
int high = array.length - 1;
while (low <= high)
if (target > array[middle]) else
} return integer.min_value;
}
排序方法：
1.插入排序：
將乙個資料插入到已經排好序的有序資料中，在有序序列中選出合適的位置插入，從而得到乙個新的、個數加一的有序資料。
優點：是穩定的排序方法。
缺點：演算法適用於少量資料的排序
時間複雜度為o(n^2)。
public int insertsort(int array)
if (array.length <= 0)
for (int i = 0; i < array.length - 1; i++)
array[index] = temp;
}} return array;
} private int halffindindex(int array, int target, int end) else
} if (target > array[middle])
return middle;
}
2.氣泡排序
每次將相鄰的兩個數進行比較，如果想公升序，則大數往後，反之亦然。
優點：演算法簡單,穩定演算法
缺點：效率低下的排序方法，在資料規模很小時，可以採用；
時間複雜度:無序o(n^2)，有序o(1)
public int bubblesort(int array)
if (array.length <= 0)
int flag = array.length - 1;
while (flag > 0)
}} return array;
}
3.歸併排序
採用分治的思想，通過分割和合併，達到目的
優點：演算法簡單,穩定演算法
平均時間複雜度：o(nlog2n)
空間複雜度：o(n) (用於儲存有序子串行合併後有序序列)
/**
* 歸併排序
* * @param unsortarray
* @return
* @throws nullpointerexception
* @throws illegalargumentexception
*/public int mergersort(int unsortarray) throws nullpointerexception,
illegalargumentexception
if (unsortarray.length <= 0)
int last = unsortarray.length - 1;
int temp = new int[unsortarray.length];
return merger(unsortarray, 0, last, temp);
} /**
* 遞迴實現歸併排序
* * @param unsortarray
* 無序陣列
* @param first
* 開始下標
* @param last
* 最後有效下標
*/private int merger(int unsortarray, int first, int last, int temp)
if (first < last)
return unsortarray;
} /**
* 將兩個有序序列合併成乙個有序序列
* * @param array
* 乙個無序序列
* @param first
* 開始的座標
* @param last
* 最後的座標
* @param temp
* 暫存陣列
*/private void mergerarray(int array, int first, int mid, int last,
int temp) else
} while (start <= mid)
while (latterindex <= last)
for (int i = 0; i < tempindex; i++)
}
4.快速排序
1．先從數列中取出乙個數作為基準數。
2．分割槽過程，將比這個數大的數全放到它的右邊，小於或等於它的數全放到它的左邊。
3．再對左右區間重複第二步，直到各區間只有乙個數。
是不穩定的演算法
快速排序時間複雜度下界為o(nlgn)，最壞情況為o(n^2)。在實際應用中，快速排序的平均時間複雜度為o(nlgn)
只要對快速排序做簡單的操作，就能使時間複雜度總是o(nlgn):
1.對排序資料進行打亂；
2.隨機挑選基準數.
額外空間o(log(n))
public int quicksort(int unsortarray, int left, int right)
throws nullpointerexception, illegalargumentexception
if (unsortarray.length <= 0)
if (left < right)
if (start < end)
while (start < end && x > unsortarray[start])
if (start < end)
}unsortarray[start] = x;
quicksort(unsortarray, left, start - 1); // 遞迴呼叫
quicksort(unsortarray, start + 1, right);
} return unsortarray;
}
各種排序演算法和查詢演算法
自己實現了一遍氣泡排序 選擇排序 插入排序，留個念想 氣泡排序 簡單來說就是從陣列末端冒泡到陣列當前位置 void bubblesort unsigned char data,unsigned short length 選擇排序 當前位置之後的所有數跟當前位置的數比較，得到最小的數到當前位置 voi...
各種排序和查詢複雜度
排序方法 平均情況 最好情況 最壞情況 輔助空間 穩定性 氣泡排序 o n 2 o n o n 2 o 1 穩定 選擇排序 o n 2 o n 2 o n 2 o 1 不穩定 插入排序 o n 2 o n o n 2 o 1 穩定 希爾排序o n log n o n 2 o n 1.3 o n 2 ...
各種排序和查詢複雜度
排序方法 平均情況 最好情況 最壞情況 輔助空間 穩定性 氣泡排序 o n 2 o n o n 2 o 1 穩定 選擇排序 o n 2 o n 2 o n 2 o 1 不穩定 插入排序 o n 2 o n o n 2 o 1 穩定 希爾排序o n log n o n 2 o n 1.3 o n 2 ...