1、选择排序
最容易想到的排序算法，首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
public void selectionSort(int[] array){
if(array.length==0) return ;
for (int i = 0; i < array.length; i++) {
int minIndex=i;
for (int j = i+1; j <array.length ; j++) {
if(array[minIndex]>array[j])
minIndex=j;
}
int temp=array[i];
array[i]=array[minIndex];
array[minIndex]=temp;
}
}
最佳情况：T(n) = O(n2) 最差情况：T(n) = O(n2) 平均情况：T(n) = O(n2)
2、冒泡排序
比较相邻的元素。如果第一个比第二个大，就交换它们两个；对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；针对所有的元素重复以上的步骤，除了最后一个；重复以上步骤直到排序完成。
public void bubbleSort(int [] array){
if(array.length==0) return;
for (int i = 1; i < array.length; i++) {
for (int j = 0; j <array.length -i; j++) {
if(array[j]>array[j+1]){
int temp=array[j];
array[j]=array[j+1];
array[j+1]=temp;
}
}
}
}
最佳情况：T(n) = O(n) 最差情况：T(n) = O(n2) 平均情况：T(n) = O(n2)
3、插入排序
1.从第一个元素开始，该元素可以认为已经被排序；
2.取出下一个元素，在已经排序的元素序列中从后向前扫描；
3.如果该元素（已排序）大于新元素，将该元素移到下一位置；
4.重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
5.将新元素插入到该位置后；重复步骤，直到排序完成。
public void insertionSort(int [] array){
if(array.length==0) return;
int current;
for (int i = 0; i < array.length-1; i++) {
current=array[i+1];
int preIndex=i;
while(preIndex>=0&¤t<array[preIndex]){
array[preIndex+1]=array[preIndex];
preIndex--;
}
array[preIndex+1]=current;
}
}
最佳情况：T(n) = O(n) 最坏情况：T(n) = O(n2) 平均情况：T(n) = O(n2)
4、希尔排序
希尔排序是简单插入排序经过改进之后的一个更高效的版本。
希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。
初始增量gap=length/2，缩小增量继续以gap = gap/2的方式，这种增量选择我们可以用一个序列来表示，{n/2,(n/2)/2…1}，称为增量序列。
图解
来源：图解排序算法(二)之希尔排序
public void 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;
}
gap/=2;
}
}
最佳情况：T(n) = O(nlog2 n) 最坏情况：T(n) = O(nlog2 n) 平均情况：T(n) =O(nlog2n)
5、归并排序
该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。
算法描述：
1.把长度为n的输入序列分成两个长度为n/2的子序列；
2.对这两个子序列分别采用归并排序；
3.将两个排序好的子序列合并成一个最终的排序序列。
public int[] mergeSort(int[] array) {
if (array.length < 2) return array;//当前小于数组元素个数小于2
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));
}
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++];
else
result[index] = left[i++];
}
return result;
}
6、快速排序
找个一个基准，通过一趟排序将待排记录分隔成独立的两部分，其中一部分元素的值比基准小，另一部分元素的值比基准大，然后分别对这两部分元素继续进行排序，以达到整个序列有序。
一般基准为数组中的第一个数，但那样最坏情况会有可能造成每次这个数都是最小的，这时算法复杂度过高。所以要采用随机的一个数作为基准，即(start + Math.random() * (end - start + 1))。
public void QSort(int a[],int start,int end){
if (start<end){
int k=partition(a,start,end);
QSort(a,start,k-1);
QSort(a,k+1,end);
}
}
private int partition(int a[],int start,int end){
int pivot = (int) (start + Math.random() * (end - start + 1)); //降低算法时间复杂度
if(pivot!=start)
swap(a, pivot, start);
int smallIndex=start,maxIndex=end+1;
while(true){
while(a[start]>a[++smallIndex]&&smallIndex<end) ;
while(a[start]<a[--maxIndex]);
if (smallIndex >= maxIndex)
break;
swap(a,smallIndex,maxIndex);
}
swap(a,start,maxIndex);
return maxIndex;
}
private static void swap(int []a,int i,int j){
int temp=a[i];
a[i]=a[j];
a[j]=temp;
}
最佳情况：T(n) = O(nlogn) 最差情况：T(n) = O(n2) 平均情况：T(n) = O(nlogn)
7、计数排序
计数排序使用一个额外的数组C，其中第i个元素是待排序数组A中值等于i的元素的个数。然后根据数组C来将A中的元素排到正确的位置。它只能对整数进行排序。
1.找到数组中的最大和最小的元素，确定额外数组的大小。
2.遍历需要排序的数组，将数组中元素作为额外数组的下标，每次加一。
3.遍历额外数组，从0下标开始，如果当前元素不为零，则添加会需要排序的数组中。
为了降低额外数组大小，用bias = 0 - min来描述相对位置。
public void CountingSort(int [] array){
if (array.length == 0) return;
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];
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++;
} else
i++;
}
}
最佳情况：T(n) = O(n+k) 最差情况：T(n) = O(n+k) 平均情况：T(n) = O(n+k)
8、基数排序
基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。对每一位进行排序，从最低位开始排序，复杂度为O(kn),为数组长度，k为数组中的数的最大的位数；
1.取得数组中的最大数，并取得位数；
2.arr为原始数组，从最低位开始取每个位组成radix数组；
3.对radix进行计数排序;
public void RadixSort(int[] array) {
if (array == null || array.length < 2)
return;
// 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;
ArrayList<ArrayList<Integer>> bucketList = new ArrayList<ArrayList<Integer>>();
for (int i = 0; i < 10; i++)
bucketList.add(new ArrayList<Integer>());
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(); //提取集合中的所有数，并清空
}
}
}
9、桶排序
桶排序就是把最大值和最小值之间的数进行瓜分，例如分成 10 个区间，10个区间对应10个桶，我们把各元素放到对应区间的桶中去，再对每个桶中的数进行排序。
private ArrayList<Integer> BucketSort(ArrayList<Integer> 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;//桶的个数
ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketCount);
ArrayList<Integer> resultArr = new ArrayList<>();
for (int i = 0; i < bucketCount; i++) {
bucketArr.add(new ArrayList<>());
}
for (int i = 0; i < array.size(); i++) {
int index = (array.get(i)-min) / bucketSize;//计算桶下标
bucketArr.get(index).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));
}
}else {
if (bucketCount == 1)
bucketSize--;
ArrayList<Integer> temp = BucketSort(bucketArr.get(i),bucketSize);
for (int j = 0; j < temp.size(); j++) {
resultArr.add(temp.get(j));
}
}
}
return resultArr;
}
最佳情况：T(n) = O(n+k) 最差情况：T(n) = O(n+k) 平均情况：T(n) = O(n2)
10、堆排序
堆排序就是把堆顶的元素与最后一个元素交换，交换之后破坏了堆的特性，我们再把堆中剩余的元素再次构成一个大顶堆，然后再把堆顶元素与最后第二个元素交换….如此往复下去，等到剩余的元素只有一个的时候，此时的数组就是有序的了
此时从最后一个非叶子结点开始，也就是8/2-1=3 结点开始对堆进行调整。
建好堆后将堆顶的元素放到最后，然后从第一位开始对剩下的元素进行调整。
依次类推，直到所有元素都排好。
private static int len; //用于记录未排序的长度
public int[] HeapSort(int[] array) {
len = array.length;
if (len < 1) return array;
//1.构建一个最大堆
buildMaxHeap(array);
//2.循环将堆首位（最大值）与末位交换，然后在重新调整最大堆
while (len > 0) {
swap(array, 0, len - 1);
len--;
adjustHeap(array, 0);
}
}
public static void buildMaxHeap(int[] array) {
//从最后一个非叶子节点开始向上构造最大堆
for (int i = len/2 - 1; i >= 0; i--) { //根据完全二叉树性质len/2为最后一个非叶子节点
adjustHeap(array, i);
}
}
public static void adjustHeap(int[] array, int i) {
int maxIndex = i; //i*2+1为左子树，i*2+2为右子树
//如果有左子树，且左子树大于父节点，则将最大指针指向左子树
if (i * 2 + 1< len && array[i * 2 + 1] > array[maxIndex])
maxIndex = i * 2 + 1;
//如果有右子树，且右子树大于父节点，则将最大指针指向右子树
if (i * 2 + 2 < len && array[i * 2 + 2] > array[maxIndex])
maxIndex = i * 2 + 2;
//如果父节点不是最大值，则将父节点与最大值交换，并且递归调整与父节点交换的位置。
if (maxIndex != i) {
swap(array, maxIndex, i);
adjustHeap(array, maxIndex); //交换后需要向下调整
}
}
最佳情况：T(n) = O(nlogn) 最差情况：T(n) = O(nlogn) 平均情况：T(n) = O(nlogn)
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
