原标题:八大排序算法 Java 实现
概述
常见的八大排序算法,它们之间的关系如下:
直接插入排序
希尔排序
简单选择排序
堆排序
冒泡排序
快速排序
归并排序
基数排序直接插入排序 基本思想
经常碰到这样一类排序问题:把新的数据插入到已经排好的数据列中。
将第一个数和第二个数排序,然后构成一个有序序列将第三个数插入进去,构成一个新的有序序列。对第四个数、第五个数……直到最后一个数,重复第二步。
算法描述
首先设定插入次数,即循环次数,for(int i=1;i
设定插入数和得到已经排好序列的最后一个数的位数。insertNum和j=i-1。
从最后一个数开始向前循环,如果插入数小于当前数,就将当前数向后移动一位。
将当前数放置到空着的位置,即j+1。
代码实现
publicvoidinsertSort(int[]a){
intlength=a.length;//数组长度,将这个提取出来是为了提高速度。
intinsertNum;//要插入的数
for(inti=1;i
insertNum=a[i];//要插入的数
intj=i-1;//已经排序好的序列元素个数
while(j>=0&&a[j]>insertNum){//序列从后到前循环,将大于insertNum的数向后移动一格
a[j+1]=a[j];//元素移动一格
j--;
}
a[j+1]=insertNum;//将需要插入的数放在要插入的位置。
}
}希尔排序 基本思想
对于直接插入排序问题,数据量巨大时。
将数的个数设为n,取奇数k=n/2,将下标差值为k的书分为一组,构成有序序列。
再取k=k/2 ,将下标差值为k的书分为一组,构成有序序列。
重复第二步,直到k=1执行简单插入排序。算法描述
首先确定分的组数。
然后对组中元素进行插入排序。
然后将length/2,重复1,2步,直到length=0为止。代码实现
publicvoidsheelSort(int[]a){
intd=a.length;
while(d!=0){
d=d/2;
for(intx=0;x
for(inti=x+d;i
intj=i-d;//j为有序序列最后一位的位数
inttemp=a[i];//要插入的元素
for(;j>=0&&temp
a[j+d]=a[j];//向后移动d位
}
a[j+d]=temp;
}
}
}
}简单选择排序 基本思想
常用于取序列中最大最小的几个数时。
(如果每次比较都交换,那么就是交换排序;如果每次比较完一个循环再交换,就是简单选择排序。)
遍历整个序列,将最小的数放在最前面。
遍历剩下的序列,将最小的数放在最前面。
重复第二步,直到只剩下一个数。算法描述
首先确定循环次数,并且记住当前数字和当前位置。
将当前位置后面所有的数与当前数字进行对比,小数赋值给key,并记住小数的位置。
比对完成后,将最小的值与第一个数的值交换。
重复2、3步。代码实现
publicvoidselectSort(int[]a){
intlength=a.length;
for(inti=0;i
intkey=a[i];
intposition=i;
for(intj=i+1;j
if(a[j]
key=a[j];
position=j;
}
}
a[position]=a[i];//交换位置
a[i]=key;
}
}堆排序 基本思想
对简单选择排序的优化。
将序列构建成大顶堆。
将根节点与最后一个节点交换,然后断开最后一个节点。
重复第一、二步,直到所有节点断开。代码实现
publicvoidheapSort(int[]a){
System.out.println("开始排序");
intarrayLength=a.length;
//循环建堆
for(inti=0;i
//建堆
buildMaxHeap(a,arrayLength-1-i);
//交换堆顶和最后一个元素
swap(a,0,arrayLength-1-i);
System.out.println(Arrays.toString(a));
}
}
privatevoidswap(int[]data,inti,intj){
// TODO Auto-generated method stub
inttmp=data[i];
data[i]=data[j];
data[j]=tmp;
}
//对data数组从0到lastIndex建大顶堆
privatevoidbuildMaxHeap(int[]data,intlastIndex){
// TODO Auto-generated method stub
//从lastIndex处节点(最后一个节点)的父节点开始
for(inti=(lastIndex-1)/2;i>=0;i--){
//k保存正在判断的节点
intk=i;
//如果当前k节点的子节点存在
while(k*2+1<=lastIndex){
//k节点的左子节点的索引
intbiggerIndex=2*k+1;
//如果biggerIndex小于lastIndex,即biggerIndex+1代表的k节点的右子节点存在
if(biggerIndex
//若果右子节点的值较大
if(data[biggerIndex]
//biggerIndex总是记录较大子节点的索引
biggerIndex++;
}
}
//如果k节点的值小于其较大的子节点的值
if(data[k]
//交换他们
swap(data,k,biggerIndex);
//将biggerIndex赋予k,开始while循环的下一次循环,重新保证k节点的值大于其左右子节点的值
k=biggerIndex;
}else{
break;
}
}
}
}冒泡排序 基本思想
一般不用
将序列中所有元素两两比较,将最大的放在最后面。
将剩余序列中所有元素两两比较,将最大的放在最后面。
重复第二步,直到只剩下一个数。算法描述
设置循环次数。
设置开始比较的位数,和结束的位数。
两两比较,将最小的放到前面去。
重复2、3步,直到循环次数完毕代码实现
publicvoidbubbleSort(int[]a){
intlength=a.length;
inttemp;
for(inti=0;i
for(intj=0;j
if(a[j]>a[j+1]){
temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
}快速排序 基本思想
要求时间最快时。
选择第一个数为p,小于p的数放在左边,大于p的数放在右边。
递归的将p左边和右边的数都按照第一步进行,直到不能递归。代码实现
publicstaticvoidquickSort(int[]numbers,intstart,intend){
if(start
intbase=numbers[start];// 选定的基准值(第一个数值作为基准值)
inttemp;// 记录临时中间值
inti=start,j=end;
do{
while((numbers[i]
i++;
while((numbers[j]>base)&&(j>start))
j--;
if(i<=j){
temp=numbers[i];
numbers[i]=numbers[j];
numbers[j]=temp;
i++;
j--;
}
}while(i<=j);
if(start
quickSort(numbers,start,j);
if(end>i)
quickSort(numbers,i,end);
}
}归并排序 基本思想
速度仅次于快排,内存少的时候使用,可以进行并行计算的时候使用。
选择相邻两个数组成一个有序序列。
选择相邻的两个有序序列组成一个有序序列。
重复第二步,直到全部组成一个有序序列。代码实现
publicstaticvoidmergeSort(int[]numbers,intleft,intright){
intt=1;// 每组元素个数
intsize=right-left+1;
while(t
ints=t;// 本次循环每组元素个数
t=2*s;
inti=left;
while(i+(t-1)
merge(numbers,i,i+(s-1),i+(t-1));
i+=t;
}
if(i+(s-1)
merge(numbers,i,i+(s-1),right);
}
}
privatestaticvoidmerge(int[]data,intp,intq,intr){
int[]B=newint[data.length];
ints=p;
intt=q+1;
intk=p;
while(s<=q&&t<=r){
if(data[s]<=data[t]){
B[k]=data[s];
s++;
}else{
B[k]=data[t];
t++;
}
k++;
}
if(s==q+1)
B[k++]=data[t++];
else
B[k++]=data[s++];
for(inti=p;i<=r;i++)
data[i]=B[i];
}基数排序 基本思想
用于大量数,很长的数进行排序时。
将所有的数的个位数取出,按照个位数进行排序,构成一个序列。
将新构成的所有的数的十位数取出,按照十位数进行排序,构成一个序列。代码实现
publicvoidsort(int[]array){
//首先确定排序的趟数;
intmax=array[0];
for(inti=1;i
if(array[i]>max){
max=array[i];
}
}
inttime=0;
//判断位数;
while(max>0){
max/=10;
time++;
}
//建立10个队列;
Listqueue=newArrayList();
for(inti=0;i<10;i++){
ArrayListqueue1=newArrayList();
queue.add(queue1);
}
//进行time次分配和收集;
for(inti=0;i
//分配数组元素;
for(intj=0;j
//得到数字的第time+1位数;
intx=array[j]%(int)Math.pow(10,i+1)/(int)Math.pow(10,i);
ArrayListqueue2=queue.get(x);
queue2.add(array[j]);
queue.set(x,queue2);
}
intcount=0;//元素计数器;
//收集队列元素;
for(intk=0;k<10;k++){
while(queue.get(k).size()>0){
ArrayListqueue3=queue.get(k);
array[count]=queue3.get(0);
queue3.remove(0);
count++;
}
}
}
}
责任编辑: