冒泡排序
public int[] bubble(int[] ary) {
for (int i = 0; i < ary.length; i++) {
for (int j = i + 1; j < ary.length; j++) {
if (ary[i] > ary[j]) {
int temp = ary[j];
ary[j] = ary[i];
ary[i] = temp;
}
}
}
return ary;
}
插入排序
public static int[] insert(int[] ary) {
for (int i = 1; i < ary.length; i++) {
int key = ary[i], j;
for (j = i - 1; j >= 0 && ary[j] > key; j--) {
ary[j + 1] = ary[j];
}
ary[j + 1] = key;
}
return ary;
}
快速排序
![这里写图片描述](https://img-blog.csdn.net/20170904225444040?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvd2lsbGlhbXh3dzE=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
package common.algorithm.sort;
import java.util.Arrays;
/**
* 该方法的基本思想是:<br/>
* 1.先从数列中取出一个数作为基准数。<br/>
* 2.分区过程,将比这个数大的数全放到它的右边,小于或等于它的数全放到它的左边。<br/>
* 3.再对左右区间重复第二步,直到各区间只有一个数。<br/>
* 复杂度O(N*logN)
* @author vv
* @since 2017/9/4.
*/
public class QuickSort {
/**
* 通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小
* 然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。
* @param ary
*/
public int[] sort(int[] ary) {
quickSort(ary, 0, ary.length - 1);
return ary;
}
private void quickSort(int[] ary, int low, int high) {
if (low < high) {
int middle = partition(ary, low, high);
quickSort(ary, low, middle - 1);
quickSort(ary, middle + 1, high);
}
}
/**
* 以list的第一个为中轴pivot = ary[low];比pivot小的放在左边,比其大的放在右边,最后返回pivot
*
* @param ary
* @param low ary的最低位
* @param high ary的最高位
* @return
*/
private int partition(int[] ary, int low, int high) {
int pivot = ary[low];
while (low < high) {
while (low < high && ary[high] >= pivot) {
high--;
}
ary[low] = ary[high];
while (low < high && ary[low] <= pivot) {
low++;
}
ary[high] = ary[low];
}
ary[low] = pivot;
return low;
}
public static void main(String[] args) {
QuickSort sorter = new QuickSort();
System.out.println(Arrays.toString(sorter.sort(new int[] { 2, 5, 2, 1, 7, 3 })));
}
}
归并排序
package common.algorithm.sort;
import java.util.Arrays;
/**
* 归并排序是分治法(Divide and Conquer)的一个非常典型的应用<br/>
* 将已有序的子序列合并,得到完全有序的序列<br/>
* 两个有序序列段分别为 R[low, mid] 和 R[mid+1, high]<br/>
* 每次从两个段中取出第一个(最小的)比较,将较小者放入temp中。最后将各段中余下的部分直接复制到temp中。
*
* <pre>
* {5, 4, 3, 2, 2, 4, 1}
* {4,5} {2,3} {2,2} {4,1}
* {2,3,4,5} {1,2,2,4}
* {1,2,2,2,3,4,4,5}
* </pre>
*
* @author vv
* @since 2016/9/20.
*/
public class MergeSort {
/**
* 对数组的begin到end 进行排序
*
* @param array 需要排序的数组
* @param begin 起始位置
* @param end 终止位置
*/
public void sort(int[] array, int begin, int end) {
if (begin < end) {
int middle = (begin + end) / 2;
sort(array, begin, middle);
sort(array, middle + 1, end);
merge(array, begin, middle, end);
}
}
/**
* 对这两组进行合并,从每组中选择最小值进行对比,小的放到temp中
*
* @param array 需要排序的原始数组
* @param low low--middle 为第一组
* @param middle 分界点
* @param high middle+1--high 为第二组
*/
private void merge(int[] array, int low, int middle, int high) {
int i = low;
int j = middle + 1;
int k = 0;
int[] temp = new int[high - low + 1];
while (i <= middle && j <= high) {
if (array[i] <= array[j]) {
temp[k] = array[i];
i++;
} else {
temp[k] = array[j];
j++;
}
k++;
}
while (i <= middle) {
temp[k] = array[i];
i++;
k++;
}
while (j <= high) {
temp[k] = array[j];
j++;
k++;
}
for (k = 0, i = low; i <= high; i++, k++) {
array[i] = temp[k];
}
}
public static void main(String[] args) {
int[] ary = { 5, 4, 3, 2, 2, 4, 1 };
MergeSort sort = new MergeSort();
sort.sort(ary, 0, ary.length - 1);
System.out.println(Arrays.toString(ary));
}
}
堆排序
package common.algorithm.sort;
import java.util.Arrays;
/**
* 归并排序是分治法(Divide and Conquer)的一个非常典型的应用<br/>
* 将已有序的子序列合并,得到完全有序的序列<br/>
* 两个有序序列段分别为 R[low, mid] 和 R[mid+1, high]<br/>
* 每次从两个段中取出第一个(最小的)比较,将较小者放入temp中。最后将各段中余下的部分直接复制到temp中。
*
* <pre>
* {5, 4, 3, 2, 2, 4, 1}
* {4,5} {2,3} {2,2} {4,1}
* {2,3,4,5} {1,2,2,4}
* {1,2,2,2,3,4,4,5}
* </pre>
*
* @author vv
* @since 2016/9/20.
*/
public class MergeSort {
/**
* 对数组的begin到end 进行排序
*
* @param array 需要排序的数组
* @param begin 起始位置
* @param end 终止位置
*/
public void sort(int[] array, int begin, int end) {
if (begin < end) {
int middle = (begin + end) / 2;
sort(array, begin, middle);
sort(array, middle + 1, end);
merge(array, begin, middle, end);
}
}
/**
* 对这两组进行合并,从每组中选择最小值进行对比,小的放到temp中
*
* @param array 需要排序的原始数组
* @param low low--middle 为第一组
* @param middle 分界点
* @param high middle+1--high 为第二组
*/
private void merge(int[] array, int low, int middle, int high) {
int i = low;
int j = middle + 1;
int k = 0;
int[] temp = new int[high - low + 1];
while (i <= middle && j <= high) {
if (array[i] <= array[j]) {
temp[k] = array[i];
i++;
} else {
temp[k] = array[j];
j++;
}
k++;
}
while (i <= middle) {
temp[k] = array[i];
i++;
k++;
}
while (j <= high) {
temp[k] = array[j];
j++;
k++;
}
for (k = 0, i = low; i <= high; i++, k++) {
array[i] = temp[k];
}
}
public static void main(String[] args) {
int[] ary = { 5, 4, 3, 2, 2, 4, 1 };
MergeSort sort = new MergeSort();
sort.sort(ary, 0, ary.length - 1);
System.out.println(Arrays.toString(ary));
}
}