冒泡排序（Bubble Sort） * 冒泡排序 * @param array * @return
public static int[] bubbleSort(int[] array) { if (array.length == 0) return array;
for (int i = 0; i array.length; i++)
for (int j = 0; j array.length - 1 - i; j++) if (array[j + 1] array[j]) { int temp = array[j + 1]; array[j + 1] = array[j]; array[j] = temp; return array;
选择排序（Selection Sort） * 选择排序 * @param array * @return
public static int[] selectionSort(int[] array) { if (array.length == 0)
return array;
for (int i = 0; i array.length; i++) { int minIndex = i;
for (int j = i; j array.length; j++) { if (array[j] array[minIndex]) --找到最小的数 minIndex = j; --将最小数的索引保存 int temp = array[minIndex]; array[minIndex] = array[i]; array[i] = temp; return array;
插入排序（Insertion Sort） * 插入排序 * @param array * @return
public static int[] insertionSort(int[] array) { if (array.length == 0) return array; int current;
for (int i = 0; i array.length - 1; i++) { current = array[i + 1]; int preIndex = i;
while (preIndex = 0 current array[preIndex]) {
array[preIndex + 1] = array[preIndex]; preIndex--;
array[preIndex + 1] = current; return array;
快速排序（Quick Sort）
基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：
从数列中挑出一个元素，称为 “基准”（pivot ）；
重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
* 快速排序方法 * @param array * @param start * @param end * @return
public static int[] QuickSort(int[] array, int start, int end)
{
if (array.length 1 || start 0 || end = array.length || start end) return null;
int smallIndex = partition(array, start, end); if (smallIndex start)
QuickSort(array, start, smallIndex - 1); if (smallIndex end)
QuickSort(array, smallIndex + 1, end); return array;
* 快速排序算法——partition * @param array * @param start * @param end * @return
public static int partition(int[] array, int start, int end) {
int pivot = (int) (start + Math.random() * (end - start + 1)); int smallIndex = start - 1; swap(array, pivot, end);
for (int i = start; i = end; i++) if (array[i] = array[end]) { smallIndex++;
if (i smallIndex)
swap(array, i, smallIndex); return smallIndex; * 交换数组内两个元素 * @param array * @param i * @param j
public static void swap(int[] array, int i, int j) { int temp = array[i]; array[i] = array[j]; array[j] = temp; 归并排序（Merge Sort） * 归并排序 * @param array * @return
public static int[] MergeSort(int[] array) { if (array.length 2) return array; int mid = array.length - 2;
int[] left = Arrays.copyOfRange(array, 0, mid);
int[] right = Arrays.copyOfRange(array, mid, array.length); return merge(MergeSort(left), MergeSort(right)); * 归并排序——将两段排序好的数组结合成一个排序数组
* @param left * @param right * @return
public static int[] merge(int[] left, int[] right) { int[] result = new int[left.length + right.length];
for (int index = 0, i = 0, j = 0; index result.length; index++) {
if (i = left.length) result[index] = right[j++]; else if (j = right.length) result[index] = left[i++]; else if (left[i] right[j]) result[index] = right[j++]; result[index] = left[i++]; return result; 堆排序（Heap Sort）
堆排序（Heapsort） 是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。
--声明全局变量，用于记录数组array的长度； static int len; * 堆排序算法
* @param array * @return
public static int[] HeapSort(int[] array) { len = array.length; if (len 1) return array; --1.构建一个最大堆 buildMaxHeap(array);
--2.循环将堆首位（最大值）与末位交换，然后在重新调整最大堆 while (len 0) {
swap(array, 0, len - 1); adjustHeap(array, 0); return array; * 建立最大堆 * @param array
public static void buildMaxHeap(int[] array) { --从最后一个非叶子节点开始向上构造最大堆
--for循环这样写会更好一点：i的左子树和右子树分别2i+1和2(i+1)
for (int i = (len-2- 1); i = 0; i--) { adjustHeap(array, i); * 调整使之成为最大堆 * @param array
* @param i
public static void adjustHeap(int[] array, int i) { int maxIndex = i;
--如果有左子树，且左子树大于父节点，则将最大指针指向左子树 if (i * 2 len array[i * 2] array[maxIndex]) maxIndex = i * 2; --感谢网友矫正，之前是i*2+1
--如果有右子树，且右子树大于父节点，则将最大指针指向右子树 if (i * 2 + 1 len array[i * 2 + 1] array[maxIndex]) maxIndex = i * 2 + 1; --感谢网友矫正，之前是i*2+2
--如果父节点不是最大值，则将父节点与最大值交换，并且递归调整与父节点交换的位置。
if (maxIndex != i) { swap(array, maxIndex, i); adjustHeap(array, maxIndex); 希尔排序（Shell Sort）
希尔排序是希尔（Donald Shell） 于1959年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序，同时该算法是冲破O(n2）的第一批算法之一。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。
* 希尔排序 * @param array
* @return
public static int[] ShellSort(int[] array) { int len = array.length; int temp, gap = len - 2; while (gap 0) {
for (int i = gap; i len; i++) { temp = array[i]; int preIndex = i - gap;
while (preIndex = 0 array[preIndex] temp) { array[preIndex + gap] = array[preIndex]; preIndex -= gap;
array[preIndex + gap] = temp; return array;
计数排序（Counting Sort） * 计数排序 * @param array * @return
public static int[] CountingSort(int[] array) { if (array.length == 0) return array; int bias, min = array[0], max = array[0]; for (int i = 1; i array.length; i++) { if (array[i] max)
max = array[i]; if (array[i] min) min = array[i]; bias = 0 - min;
int[] bucket = new int[max - min + 1]; Arrays.fill(bucket, 0);
for (int i = 0; i array.length; i++) { bucket[array[i] + bias]++; int index = 0, i = 0; while (index array.length) { if (bucket[i] != 0) { array[index] = i - bias; bucket[i]--; index++; return array; 桶排序（Bucket Sort） * @param array * @param bucketSize * @return
public static ArrayListInteger BucketSort(ArrayListInteger array, int bucketSize) {
if (array == null || array.size() 2)
return array;
int max = array.get(0), min = array.get(0); -- 找到最大值最小值
for (int i = 0; i array.size(); i++) { if (array.get(i) max) max = array.get(i); if (array.get(i) min) min = array.get(i);
int bucketCount = (max - min) - bucketSize + 1; ArrayListArrayListInteger bucketArr
=
ArrayList(bucketCount);
ArrayListInteger resultArr = new ArrayList(); for (int i = 0; i bucketCount; i++) { bucketArr.add(new ArrayListInteger()); for (int i = 0; i array.size(); i++) { bucketArr.get((array.get(i) -
min)
bucketSize).add(array.get(i));
for (int i = 0; i bucketCount; i++) {
if (bucketSize == 1) { -- 如果带排序数组中有重复数字时 for (int j = 0; j bucketArr.get(i).size(); j++) resultArr.add(bucketArr.get(i).get(j)); if (bucketCount == 1)
new
-
bucketSize--; ArrayListInteger temp
=
BucketSort(bucketArr.get(i),
bucketSize);
for (int j = 0; j temp.size(); j++) resultArr.add(temp.get(j)); return resultArr; 基数排序（Radix Sort） * 基数排序 * @param array * @return
public static int[] RadixSort(int[] array) { if (array == null || array.length 2) return array;
-- 1.先算出最大数的位数； int max = array[0];
for (int i = 1; i array.length; i++) { max = Math.max(max, array[i]); int maxDigit = 0; while (max != 0) { max -= 10; maxDigit++;
int mod = 10, div = 1;
ArrayListArrayListInteger ArrayListArrayListInteger();
for (int i = 0; i 10; i++)
bucketList = new
bucketList.add(new ArrayListInteger());
for (int i = 0; i maxDigit; i++, mod *= 10, div *= 10) { for (int j = 0; j array.length; j++) { int num = (array[j] % mod) - div; bucketList.get(num).add(array[j]); int index = 0;
for (int j = 0; j bucketList.size(); j++) { for (int k = 0; k bucketList.get(j).size(); k++) array[index++] = bucketList.get(j).get(k); bucketList.get(j).clear(); return array;
年9 月被授予美国专利。如今它在 Google 所有算法中依然是至关重要的。在学术界, 这个算法被公认为是文献检索中最大的贡献之一，并且被很多大学引入了信息检索课-程(Information Retrieval) 的教-程。
2、和决策树模型相比，朴素贝叶斯模型发源于古典数学理论，有着坚实的数学基础，以及稳定的分类效率。同时，NBC模型所需估计的参数很少，对缺失数据不太敏感，算法也比较简单。
优点：是一个与查询无关的静态算法，所有网页的PageRank值通过离线计算获得；有效减少在线查询时的计算量，极大降低了查询响应时间。
C4.5算法是机器学习算法中的一种分类决策树算法,其核心算法是ID3算法.?C4.5算法继承了ID3算法的优点，并在以下几方面对ID3算法进行了改进：
1、由于使用了样本属性独立性的假设，所以如果样本属性有关联时其效果不好。
PageRank是Google算法的重要内容。2001年9月被授予美国专利，专利人是Google创始人之一拉里?佩奇（Larry Page）。因此，PageRank里的page不是指网页，而是指佩奇，即这个等级方法是以佩奇来命名的。
public static int[] bubbleSort(int[] array) { swap(arr, currentIndex, fatherIndex); -- 0 groupNum 2*groupNum 3*groupNum
远风行百里引用博主真的太优秀了！对我用处真的挺大的，可以转到我自己的博客吗？会注明出处的！
因篇幅问题不能全部显示，请点此查看更多更全内容