排序算法简介
- 交换排序:冒泡排序、快速排序
- 插入排序:直接插入排序、希尔排序
- 选择排序:简单选择排序、堆排序
- 归并排序
- 基数排序
对比
代码实现
冒泡排序
//冒泡排序
public static void sort(int[] arr){
if(arr==null||arr.length<=0){
return;
}
for(int i=0;i<arr.length-1;i++){//控制比较轮数
for(int j=0;j<arr.length-1-i;j++){//控制比较索引
if(arr[j]>arr[j+1]){
int temp=-1;
temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
}
快速排序
//基于荷兰国旗的快速排序
public static void quickSort(int[] arr,int start,int end){
if(arr==null||arr.length<=0){
return;
}
if(start>=end){
return;
}
int left=start;
int less=start-1;
int more=end+1;
int index= (int) (Math.random()*(end-start+1)+start);
int temp=arr[index];
while (left<more){
if(arr[left]<temp){
swap(arr,left++,++less);
}else if(arr[left]>temp){
swap(arr,left,--more);
}else {
left++;
}
}
quickSort(arr,start,less);
quickSort(arr,more,end);
}
//交换数组中两个元素
private static void swap(int[] arr, int left, int right) {
int temp;
temp=arr[left];
arr[left]=arr[right];
arr[right]=temp;
}
直接插入排序
//插入排序
public static void sort(int[] arr){
//判断输入参数合法性
if(arr==null||arr.length<=0){
return;
}
//从第二个元素开始逐个插入
for(int i=1;i<arr.length;i++){
//当比前面元素小
if(arr[i]<arr[i-1]){
//保存当前哨兵值
int temp=arr[i];
//将比哨兵大的值向后移一位
int j;
for(j=i-1;j>=0&&arr[j]>temp;j--){
arr[j+1]=arr[j];
}
//将哨兵放置
arr[j+1]=temp;
}
}
}
希尔排序
//希尔排序
public static void shellSort(int[] arr){
if(arr==null||arr.length<=0){
return;
}
int k = 1;
// 遍历所有的步长
for (int d = arr.length / 2; d > 0; d /= 2) {
// 遍历所有有元素
for (int i = d; i < arr.length; i++) {
// 遍历本组中所有的元素
for (int j = i - d; j >= 0; j -= d) {
// 如果当前元素大于加上步长后的那个元素
if (arr[j] > arr[j + d]) {
int temp = arr[j];
arr[j] = arr[j + d];
arr[j + d] = temp;
}
}
}
System.out.println("第" + k + "次排序结果:" + Arrays.toString(arr));
k++;
}
}
简单选择排序
//选择排序
public static void sort(int[] arr){
if(arr==null||arr.length<=0){
return;
}
for(int i=0;i<arr.length-1;i++){//控制哨兵位置
for(int j=i+1;j<arr.length;j++){//控制比较索引
if(arr[j]<arr[i]){
int temp=-1;
temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}
}
}
堆排序
//堆排序
public static void heapsort(int[] arr){
if(arr==null||arr.length<=0){
return;
}
int size=arr.length;
heapiFy(arr,size);
while(size>0){
swap(arr,0,--size);
heapiFy(arr,size);
}
}
//调整大根堆
public static void heapiFy(int[] arr,int size){
if(arr==null||arr.length<=0){
return;
}
int i=size/2-1;
while(i>=0){
if(2*i+1<size&&arr[i]<arr[2*i+1]){
swap(arr,i,2*i+1);
}
if(2*i+2<size&&arr[i]<arr[2*i+2]){
swap(arr,i,2*i+2);
}
i--;
}
}
//交换数组两个位置的元素
private static void swap(int[] arr, int left, int right) {
int temp;
temp=arr[left];
arr[left]=arr[right];
arr[right]=temp;
}
归并排序
//归并排序
public static void mergwSort(int[] arr,int low,int high){
if(arr==null||arr.length<=0){
return;
}
//结束条件
if(low<high){
int mid=(low+high)/2;
//递归调用左边
mergwSort(arr,low,mid);
//递归调用右边
mergwSort(arr,mid+1,high);
//左右归并
merge(arr,low,mid,high);
}
}
//数组归并操作
private static void merge(int[] arr, int low, int mid, int high) {
if(arr==null||arr.length<=0){
return;
}
//归并数组
int[] temp=new int[high-low+1];
int i=low;
int j=mid+1;
int index=0;
while (i<=mid&&j<=high){
if(arr[i]<arr[j]){
temp[index]=arr[i];
i++;
index++;
}
if(arr[j]<arr[i]){
temp[index]=arr[j];
j++;
index++;
}
}
//处理剩余
while (i<=mid){
temp[index]=arr[i];
i++;
index++;
}
while (j<=high){
temp[index]=arr[j];
j++;
index++;
}
//为数组赋值
for(int k=0;k<temp.length;k++){
arr[k+low]=temp[k];
}
}
基数排序
//基数排序
private static void radixSort(int[] arr) {
if(arr==null||arr.length<=0){
return;
}
//取出最大值
int max=0;
for(int i=0;i<arr.length;i++){
if(arr[i]>max){
max=arr[i];
}
}
//获取循环次数
int len=(max+"").length();
//循环按各位数字排序
int n=1;//辅助变量计算数字
int[][] temp=new int[10][arr.length];//保存数字的数组
int[] counts=new int[10];//保存各数组存储数据个数
for(int j=0;j<len;j++){
//按各位数字存储
for(int k=0;k<arr.length;k++){
int pos=arr[k]/n%10;
temp[pos][counts[pos]]=arr[k];
counts[pos]++;
}
//将分组结果赋值给原数组,继续下一轮
int loa=0;
for(int p=0;p<10;p++){
for(int m=0;m<counts[p];m++){
arr[loa]=temp[p][m];
loa++;
}
counts[p]=0;//恢复0,以免影响下一轮
}
n*=10;
}
}