###初学java，整理了八大排序。
import java.util.Arrays;
import java.util.Scanner;
/*
1.直接插入排序
经常碰到这样一类排序问题：把新的数据插入到已经排好的数据列中。
将第一个数和第二个数排序，然后构成一个有序序列
将第三个数插入进去，构成一个新的有序序列。
对第四个数、第五个数……直到最后一个数，重复第二步。
如何写写成代码：
首先设定插入次数，即循环次数，for(int i=1;i<length;i++)，1个数的那次不用插入。
设定插入数和得到已经排好序列的最后一个数的位数。insertNum和j=i-1。
从最后一个数开始向前循环，如果插入数小于当前数，就将当前数向后移动一位。
将当前数放置到空着的位置，即j+1。
*/
public static int[] insertSort(int[] a){
int insertNum;
for (int i = 1; i <a.length ; i++) {
insertNum=a[i];//要插入的数字
int j=i-1;//前面已经有序的末尾数字
while(j>=0&&a[j]>insertNum){//从后往前循环
a[j+1]=a[j];//较大的元素后移
j--;
}
a[j+1]=insertNum;//将要插入的元素插入合适的位置
}
return a;
}
import java.util.Arrays;
import java.util.Scanner;
/*
2.希尔排序
对于直接插入排序问题，数据量巨大时,效率不高。
希尔排序的思想是使数组中任意间隔为h的元素都是有序的，例如4-sort的结果为：
L E E A M H L E P S O L T S X R
L-------M-------P-------T
E-------H-------S-------S
E-------L-------O-------X
A-------E-------L-------R
这四组分别有序，所以是h有序的，此时h=4。
输入 S H E L L S O R T E X A M P L E
13-sort P H E L L S O R T E X A M S L E
4-sort L E E A M H L E P S O L T S X R
1-sort A E E E H L L L M O P R S S T X
*/
public static int[] shellSort(int[] a){
int N=a.length;
int h=1;
int temp;
while(h<N/3){//h的值为小于数组角标的最大值 1,4,33,40,121,364,1093， ....
h=3*h+1;
}
while(h>=1){
//将数组变为h有序
for (int i = 0; i <N; i++) {
//将a[i]插入到a[i-h],a[i-2h],a[i-3h],...之中
for (int j = i; j >=h&&a[j]<a[j-h]; j=j-h) {
temp=a[j];//交换元素
a[j]=a[j-h];
a[j-h]=temp;
}
}
h=h/3;//h从大到小，比如：... 13-sort,4-sort,1-sort;
}
return a;
}
import java.util.Arrays;
import java.util.Scanner;
/*
3.简单选择排序
常用于取序列中最大最小的几个数时。
(如果每次比较都交换，那么就是交换排序；如果每次比较完一个循环再交换，就是简单选择排序。)
遍历整个序列，将最小的数放在最前面。
遍历剩下的序列，将最小的数放在最前面。
重复第二步，直到只剩下一个数。
如何写成代码：
首先确定循环次数，并且记住当前数字和当前位置。
将当前位置后面所有的数与当前数字进行对比，小数赋值给
比对完成后，将最小的值与第一个数的值交换。
重复2、3步。
*/
public static int[] selectSort(int[] a){
for (int i = 0; i <a.length; i++) {//循环次数
int key=a[i];
int position=i;
for (int j = i+1; j <a.length; j++) {//找出最小值
if(a[j]<key){
key=a[j];
position=j;
}
}
a[position]=a[i];//交换元素
a[i]=key;
}
return a;
}
import java.util.Arrays;
import java.util.Scanner;
/*
4.堆排序
对简单选择排序的优化。
将序列构建成大顶堆。
将根节点与最后一个节点交换，然后断开最后一个节点。
重复第一、二步，直到所有节点断开。
*/
public class heap_sort {
private static void exch(int[] array,int i,int j){
int temp=array[i];
array[i]=array[j];
array[j]=temp;
}
private static void sink(int[] arr,int k,int n){//下沉函数
while(k*2<=n){
if(k*2==n){
k--;
}
int j=2*k+1;
if(j<n&&arr[j]<arr[j+1]){//比较k的两个孩子，让j角标对应最大的孩子
j++;
}
if(arr[k]>=arr[j]){//如果k小于k的较大的孩子，将k节点与较大的孩子交换
break;
}else {
exch(arr,k,j);
}
k=j;//k成为k的孩子，并继续向下递归
}
}
public static int[] heapSort(int[] a){
int N=a.length-1;
for(int k=N/2;k>=0;k--){
sink(a,k,N);//堆的构造,堆有序
}
System.out.print(Arrays.toString(a));
while(N>1){
exch(a,0,N--);//将最大的放到最后
sink(a,0,N);//再下沉，使得交换后的元素换到指定位置，使堆成为大顶堆
}
exch(a,0,1);//考虑到最后循环只执行到N=2,所以要最后处理一下0和1的位置
return a;
}
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int[] array=new int[n];
for (int i = 0; i <n; i++) {
array[i]=sc.nextInt();
}
int[] sort=heapSort(array);
System.out.print(Arrays.toString(sort));
}
}
import java.util.Arrays;
import java.util.Scanner;
/*
5.冒泡排序
一般不用。
将序列中所有元素两两比较，将最大的放在最后面。
将剩余序列中所有元素两两比较，将最大的放在最后面。
重复第二步，直到只剩下一个数。
如何写成代码：
设置循环次数。
设置开始比较的位数，和结束的位数。
两两比较，将最小的放到前面去。
重复2、3步，直到循环次数完毕。
*/
public static int[] bubbleSort(int[] a){
int length=a.length;
int temp;
for(int i=0;i<a.length;i++){
for(int j=0;j<a.length-i-1;j++){//循环0~a.length-i-1次，每次将最大的放在最后
if(a[j]>a[j+1]){//交换元素
temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
return a;
}
import java.util.Arrays;
import java.util.Scanner;
/*
6.快速排序
要求时间最快时。
选择第一个数为p，小于p的数放在左边，大于p的数放在右边。
递归的将p左边和右边的数都按照第一步进行，直到不能递归。
*/
public class quick_sort {
private static void exch(int[] array,int i,int j){
int temp=array[i];
array[i]=array[j];
array[j]=temp;
}
public static int partition(int[] a,int lo,int hi){//将数组切分成a[lo..i-1],a[i],a[i+1..hi]
int i=lo,j=hi+1;
int v=a[lo];
while(true){//扫描左右，检查扫描是否结束并交换元素
while(a[++i]<v){
if(i==hi)
break;
}
while(v<a[--j]){
if(j==lo)
break;
}
if(i>=j) break;
exch(a,i,j);
}
exch(a,lo,j);
return j;
}
public static void quickSort(int[] a,int lo,int hi){
if(hi<=lo) return;
int j=partition(a,lo,hi);//切分后返回的角标，
quickSort(a,lo,j-1);//左边排序
quickSort(a,j+1,hi);//右边排序
}
public static void main(String[] args){//主函数用于测试数据
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int[] array=new int[n];
for (int i = 0; i <n; i++) {
array[i]=sc.nextInt();
}
quickSort(array,0,array.length-1);
System.out.print(Arrays.toString(array));
}
}
import java.util.Arrays;
import java.util.Scanner;
/*
7.归并排序
速度仅次于快排，内存少的时候使用，可以进行并行计算的时候使用。
选择相邻两个数组成一个有序序列。
选择相邻的两个有序序列组成一个有序序列。
重复第二步，直到全部组成一个有序序列。
*/
public class merge_sort {
private static void merge(int[] a,int lo,int mid,int hi){
int i=lo,j=mid+1;
int[] aux=new int[a.length];
for (int k = lo; k <=hi ; k++) {//a[]复制到aux[]
aux[k]=a[k];
}
for (int k = lo; k <=hi; k++) {//归并到a[lo..hi]中
if(i>mid) a[k]=aux[j++];
else if(j>hi) a[k]=aux[i++];
else if(aux[j]>aux[i]) a[k]=aux[i++];
else a[k]=aux[j++];
}
}
public static void mergeSort(int[] a,int lo,int hi){//数组递归排序
if(hi<=lo) return;
int mid=lo+(hi-lo)/2;
mergeSort(a,lo,mid);//左半边排序
mergeSort(a,mid+1,hi);//右半边排序
merge(a,lo,mid,hi);//调用归并函数
}
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int[] array=new int[n];
for (int i = 0; i <n; i++) {
array[i]=sc.nextInt();
}
mergeSort(array,0,array.length-1);
System.out.print(Arrays.toString(array));
}
}
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
/*
8.基数排序
用于大量数，很长的数进行排序时。
将所有的数的个位数取出，按照个位数进行排序，构成一个序列。
将新构成的所有的数的十位数取出，按照十位数进行排序，构成一个序列。
*/
public class base_sort {
public static void baseSort(int[] array){
//首先确定排序的趟数;
int max = array[0];
for (int i = 1; i < array.length; i++) {
if (array[i] > max) {
max = array[i];
}
}
int time = 0;
//判断位数;
while (max > 0) {
max /= 10;
time++;
}
//建立10个队列;
List<ArrayList> queue = new ArrayList<>();
for (int i = 0; i < 10; i++) {
ArrayList<Integer> queue1 = new ArrayList<>();
queue.add(queue1);
}
//进行time次分配和收集;
for (int i = 0; i < time; i++) {
//分配数组元素;
for (int j = 0; j < array.length; j++) {
//得到数字的第time+1位数;
int x = array[j] % (int) Math.pow(10, i + 1) / (int) Math.pow(10, i);
ArrayList<Integer> queue2 = queue.get(x);
queue2.add(array[j]);
queue.set(x, queue2);
}
int count = 0;//元素计数器;
//收集队列元素;
for (int k = 0; k < 10; k++) {
while (queue.get(k).size() > 0) {
ArrayList<Integer> queue3 = queue.get(k);
array[count] = queue3.get(0);
queue3.remove(0);
count++;
}
}
}
}
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int[] array=new int[n];
for (int i = 0; i <n; i++) {
array[i]=sc.nextInt();
}
baseSort(array);
System.out.print(Arrays.toString(array));
}
}
算法复杂度
获取学习资源
扫一扫
160
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
