十大排序算法java
1.冒泡排序（BubbleSort）
冒泡排序算法的原理如下：
-
比较相邻的元素。如果第一个比第二个大，就交换他们两个。
-
对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
-
针对所有的元素重复以上的步骤，除了最后一个。
-
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较
package sortArithmetic;
import java.util.Arrays;
public class BubbleSort {
public static void main(String[] args){
int[] arr=new int[15];
for(int i=0;iarr[j+1]){
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
}
}
2.选择排序(SelectionSort)
选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。
package sortArithmetic;
import java.util.Arrays;
public class SelectSort {
public static void main(String[] args){
int[] arr=new int[15];
for(int i=0;iarr[j]){
min=arr[j];
index=j;
}
}
if(index!=i){
int temp=arr[index];
arr[index]=arr[i];
arr[i]=temp;
}
}
}
}
3.插入排序(InsertSort)
插入排序，一般也被称为直接插入排序。对于少量元素的排序，它是一个有效的算法 。插入排序是一种最简单的排序方法，它的基本思想是将一个记录插入到已经排好序的有序表中，从而一个新的、记录数增1的有序表。在其实现过程使用双层循环，外层循环对除了第一个元素之外的所有元素，内层循环对当前元素前面有序表进行待插入位置查找，并进行移动 。
package sortArithmetic;
import java.util.Arrays;
public class InsertSort {
public static void main(String[] args){
int[] arr=new int[15];
for(int i=0;iarr[i]){
int insertVal=arr[i];
int insertIndex=i-1;
while(insertIndex>=0&&insertVal 4.希尔排序(ShellSort)
希尔排序(Shell's Sort)是插入排序的一种又称“缩小增量排序”（Diminishing Increment Sort），是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因D.L.Shell于1959年提出而得名。
希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。
package sortAlgorithm;
import java.util.Arrays;
public class ShellSort {
public static void main(String[] args){
int[] arr=new int[20];
for(int i=0;i0;gap/=2){
for(int i=gap;iarr[i]){
int insertVal=arr[i];
int insertIndex=i-gap;
while(insertIndex>=0&&arr[insertIndex]>insertVal){
arr[i]=arr[i-gap];
insertIndex-=gap;
}
arr[insertIndex+gap]=insertVal;
}
}
}
}
} 5.快速排序(QuickSort)
基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
package sortAlgorithm;
import java.util.Arrays;
public class QuickSort {
public static void main(String[] args){
int[] arr={10,7,2,4,7,62,3,4,2,1,8,9,19};
quickSort(arr,0,arr.length-1);
System.out.println(Arrays.toString(arr));
}
public static void quickSort(int[] arr,int left,int right){
if(left>=right)return;
int i=left;
int j=right;
int base=arr[i];
while(i=base)j--;
while(i=j)break;
int temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
arr[left]=arr[i];
arr[i]=base;
quickSort(arr,left,i-1);
quickSort(arr,i+1,right);
}
} 6.堆排序（HeapSort）
堆排序的基本思想是：将待排序序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了
package sortAlgorithm;
import java.util.Arrays;
import java.util.Random;
public class HeapSort {
public static void main(String[] args){
Random random=new Random();
int[] arr=new int[20];
for(int i=0;i=0;i--){
adjustHeap(arr,i,arr.length);
}
for(int i=arr.length-1;i>0;i--){
int temp=arr[i];
arr[i]=arr[0];
arr[0]=temp;
adjustHeap(arr,0,i);
}
}
private static void adjustHeap(int[] arr, int parent, int length) {
int temp = arr[parent];
int lChild = 2*parent+1;
while(lChildarr[lChild]) lChild++;
if(temp>=arr[lChild]) break;
arr[parent]=arr[lChild];
parent=lChild;
lChild=2*parent+1;
}
arr[parent]=temp;
}
} 7.桶排序(BucketSort)
桶排序（Bucket sort）或所谓的箱排序，是一个排序算法，工作的原理是将数组分到有限数量的桶里。每个桶再个别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排序），最后依次把各个桶中的记录列出来记得到有序序列。桶排序是鸽巢排序的一种归纳结果。当要被排序的数组内的数值是均匀分配的时候，桶排序使用线性时间（O(n)）。但桶排序并不是比较排序，他不受到O(n log n)下限的影响。
package sortAlgorithm;
import java.util.*;
public class BucketSort {
public static void main(String[] args){
Random random=new Random();
int[] arr=new int[20];
for(int i=0;i> bucketArr=new ArrayList<>();
for(int i=0;i());
}
for(int i=0;i 8.归并排序(MergeSort)
归并排序（Merge Sort）是建立在归并操作上的一种有效，稳定的排序算法，该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
package sortAlgorithm;
import java.util.Arrays;
import java.util.Random;
public class MergeSort {
public static void main(String[] args){
Random random=new Random();
int[] arr=new int[10];
for(int i=0;i9.计数排序(CountingSort)
计数排序的基本思想是对于给定的输入序列中的每一个元素x，确定该序列中值小于x的元素的个数（此处并非比较各元素的大小，而是通过对元素值的计数和计数值的累加来确定）。一旦有了这个信息，就可以将x直接存放到最终的输出序列的正确位置上。例如，如果输入序列中只有17个元素的值小于x的值，则x可以直接存放在输出序列的第18个位置上。当然，如果有多个元素具有相同的值时，我们不能将这些元素放在输出序列的同一个位置上，因此，上述方案还要作适当的修改。
package sortAlgorithm;
import java.util.Arrays;
import java.util.Random;
public class CountingSort {
public static void main(String[] args){
Random random=new Random();
int[] arr=new int[10];
for(int i=0;i10.基数排序(RadixSort)
它是这样实现的：将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。
package sortAlgorithm;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Random;
public class RadixSort {
public static void main(String[] args){
Random random=new Random();
int[] arr=new int[10];
for(int i=0;i> temp=new ArrayList<>();
int max=Integer.MIN_VALUE;
for(int i=0;i());
}
for(int exp=1;exp<=radix;exp++){
//进桶
for(int i=0;i