本文详细介绍了几种常见的排序算法，包括直接插入排序、希尔排序、冒泡排序、快速排序、直接选择排序、堆排序、归并排序和基数排序。每种算法都有其适用场景，例如快速排序平均速度最快，而归并排序需要最多辅助空间。文章提供了每种排序算法的基本思路和Java实现示例。
目录
1.概述
分类：
1）插入排序（直接插入排序、希尔排序）
2）交换排序（冒泡排序、快速排序）
3）选择排序（直接选择排序、推排序）
4）归并排序
5）分配排序（基数排序）
所需辅助空间最多：归并排序
所需辅助空间最少：推排序
平均速度最快：快速排序
不稳定：快速排序，希尔排序，堆排序
在选择排序算法时，应参考
1.数据的规模
2.数据的类型
3.数据已有的顺序
一、插入排序
包括直接插入排序，希尔排序。
1、直接插入排序
1、实现思路
1）数组的第0个位置没有放数据。
2）从数组的第二个数据开始处理：如果该数据比它前面的数据要小，说明该数据要往前面移动。
a 首先将该数据备份到数组的第0个位置。
b 然后将该数据前面那个数据后移。
c 然后往前搜索，找插入位置。
d 找到插入位置后将第0位置的数据插入对应位置。
2、代码
package cn.ecjtu.Test;
import java.util.Arrays;
public class TestInsertionSort {
public static void straightInsertionSort(double[] sorted) {
for(int i=2;i<sorted.length;i++) {
if(sorted[i]<sorted[i-1]) {
sorted[0] = sorted[i];//先保存一下后面的那个数
sorted[i] = sorted[i-1];//前面的那个数后移
int insertPos = 0;
for(int j=i-2;j>=0;j--) {
if(sorted[j]>sorted[0]) {
sorted[j+1] = sorted[j];
}else {
insertPos = j+1;
break;
}
}
sorted[insertPos] = sorted[0];
}
}
}
public static void main(String[] args) {
double[] array= {0,6,8,4,9,1,10,25,7};
System.out.println("before: " + Arrays.toString(array));
straightInsertionSort(array);
System.out.println("after: " + Arrays.toString(array));
}
}
运行结果：
before: [0.0, 6.0, 8.0, 4.0, 9.0, 1.0, 10.0, 25.0, 7.0]
after: [7.0, 1.0, 4.0, 6.0, 7.0, 8.0, 9.0, 10.0, 25.0]
2、希尔排序
1、实现思路
先将整个待排记录序列分割成若干个子序列，分别进行直接插入排序，待整个序列中的记录基本有序时，再对全体记录进行一次直接插入排序。
2、代码
package cn.ecjtu.Test;
import java.util.Arrays;
public class TestInsertionSort {
public static void shellInertionSort(double[] sorted,int inc) {
for(int i=inc+1;i<sorted.length;i++) {
if(sorted[i]<sorted[i-inc]) {
sorted[0] = sorted[i];//先保存一下后面的那个数
int insertPos = i;
for(int j=i-inc;j>=0;j-=inc) {
if(sorted[j]>sorted[0]) {
sorted[j+inc] = sorted[j];
if(j-inc<=0) {
insertPos = j;
}
}else {
insertPos = j+inc;
break;
}
}
sorted[insertPos] = sorted[0];
}
}
}
public static void shellInertionSort(double[] sorted) {
int[] incs = {7,5,3,1};
int inc = 0;
for(int i=0;i<incs.length;i++) {
inc = incs[i];
shellInertionSort(sorted,inc);
}
}
public static void main(String[] args) {
double[] array= {0,6,8,4,9,1,10,25,7};
System.out.println("before: " + Arrays.toString(array));
shellInertionSort(array);
System.out.println("after: " + Arrays.toString(array));
}
}
运行结果：
before: [0.0, 6.0, 8.0, 4.0, 9.0, 1.0, 10.0, 25.0, 7.0]
after: [8.0, 1.0, 4.0, 6.0, 7.0, 8.0, 9.0, 10.0, 25.0]
二、交换排序
包括冒泡排序，快速排序。
1、冒泡排序
1、实现思路
该算法是专门针对已部分排序的数据进行排序的一种排序算法。如果在你的数据清单中只有一两个数据是乱序的话，用这种算法就是最快的排序算法。如果你的数据清单中的数据是随机排列的，那么这种方法就成了最慢的算法了。因此在使用这种算法之前一定要慎重。这种算法的核心思想是扫描数据清单，寻找出现乱序的两个相邻的项目。当找到这两个项目后，交换项目的位置然后继续扫描。重复上面的操作直到所有的项目都按顺序排好。
2、代码
package cn.ecjtu.Test;
import java.util.Arrays;
public class bubbleSort {
public static void bubbleSort(int[] a) {
int temp = 0;
for(int i=0;i<a.length-1;i++) {
for(int j=0;j<a.length-1-i;j++) {
if(a[j]>a[j+1]) {
temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}
}
}
public static void main(String[] args) {
int[] array = {49,38,65,97,76,13,27};
System.out.println("before: " + Arrays.toString(array));
bubbleSort(array);
System.out.println("after: " + Arrays.toString(array));
}
}
运行结果：
before: [49, 38, 65, 97, 76, 13, 27]
after: [13, 27, 38, 49, 65, 76, 97]
2、快速排序
1、实现思路
通过一趟排序，将待排序记录分割成独立的两个部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。具体做法是：使用两个指针low,high，初值分别设置为序列的头,和序列的尾，设置pivotkey为第一个记录，首先从high开始向前搜索第一个小于pivotkey的记录和pivotkey所在位置进行交换，然后从low开始向后搜索第一个大于pivotkey的记录和此时pivotkey所在位置进行交换，重复知道low=high了为止。
2、代码
package cn.ecjtu.Test;
import java.util.Arrays;
public class quickSort {
public static int getMiddle(int[] list,int low,int high) {
int tmp = list[low];//数组的第一个作为中轴
while(low<high) {
while(low<high && list[high]>=tmp) {
high--;
}
list[low] = list[high];//比中轴小的记录移到低端
while(low<high && list[low]<=tmp) {
low++;
}
list[high] = list[low];//比中轴大的记录移到高端
}
list[low] = tmp;//中轴记录到尾
return low;//返回中轴的位置
}
public static void _quickSort(int[] list,int low,int high) {
if(low<high) {
int middle = getMiddle(list,low,high);//将list数组进行一分为二
_quickSort(list,low,middle-1);//对低字表进行递归排序
_quickSort(list,middle+1,high);//对高字表进行递归排序
}
}
public static void quickSort(int[] a) {
if(a.length>0) {//查看数组是否为空
_quickSort(a,0,a.length-1);
}
}
public static void main(String[] args) {
int[] array = {49,38,65,97,76,56,46,78,95,12,1,3};
System.out.println("before: " + Arrays.toString(array));
quickSort(array);
System.out.println("after: " + Arrays.toString(array));
}
}
运行结果：
before: [49, 38, 65, 97, 76, 56, 46, 78, 95, 12, 1, 3]
after: [1, 3, 12, 38, 46, 49, 56, 65, 76, 78, 95, 97]三、选择排序
分为直接选择排序、堆排序。
1、直接选择排序
1、实现思路
第i次选取i到array.Length-1中间最小的值放在i位置。
2、代码
package cn.ecjtu.Test;
import java.util.Arrays;
public class selectSort {
public static void selectSort(int[] a) {
int position = 0;
for(int i=0;i<a.length;i++) {
int j = i+1;
position = i;
int temp = a[i];
for(;j<a.length;j++) {
if(a[j]<temp) {
temp = a[j];
position = j;
}
}
a[position] = a[i];
a[i] = temp;
}
}
public static void main(String[] args) {
int[] array = {45,2,36,4,9,7,5,64,8};
System.out.println("before: " + Arrays.toString(array));
selectSort(array);
System.out.println("after: " + Arrays.toString(array));
}
}
运行结果：
before: [45, 2, 36, 4, 9, 7, 5, 64, 8]
after: [2, 4, 5, 7, 8, 9, 36, 45, 64]2、堆排序
1、实现思路
首先，数组里面用层次遍历的顺序放一棵完全二叉树。从最后一个非终端
结点往前面调整，直到到达根结点，这个时候除根节，点以外的所有非终端节点都已经满足堆得条件了，于是需要调整根节，点使得整个树满足堆得条件，于是从根节点开始，沿着它的儿子们往下面走(最大堆沿着最大的儿子走，最小堆沿着最小的儿子走)
主程序里面，首先从最后一个非终端节点开始调整到根也调整完，形成一个heap，然后将heap的根放到后面去(即：每次的树大小会变化，但是root都是在1的位置，以方便计算儿子们的index,所以如果需要升序排列，则要逐步大顶堆。因为根节点被一个个放在后面去了。降序排列则要建立小顶堆)
2、代码
package cn.ecjtu.Test;
import java.util.Arrays;
public class HeapSort {
public HeapSort(int[] a) {
heapSort(a);
}
public void heapSort(int[] a) {
System.out.println("开始排序");
//开始建堆
for(int i=0;i<a.length-1;i++) {
//建堆
buildMaxHeap(a,a.length-1-i);
//交换堆顶和最后一个元素
swap(a,0,a.length-1-i);
System.out.println(Arrays.toString(a));
}
}
public void swap(int[] data,int i,int j) {
int tmp = data[i];
data[i] = data[j];
data[j] = tmp;
}
//对data数组从0到lastIndex建大顶堆
private void buildMaxHeap(int[] data,int lastIndex) {
//从lastIndex处节点（最后一个节点）的父节点开始
for(int i=(lastIndex-1)/2;i>=0;i--) {
//k保存正在判断的节点
int k = i;
//如果k节点的子节点存在
while(k*2+1<=lastIndex) {
//k节点的左子节点的索引
int biggerIndex = 2*k+1;
//如果biggerIndex小于lastIndex，即biggerIndex+1代表k节点的右子节点存在
if(biggerIndex<lastIndex) {
//如果右子节点的值比较大
if(data[biggerIndex]<data[biggerIndex+1]) {
//biggerIndex总是记录较大子节点的索引
biggerIndex++;
}
}
//如果k节点的值小于其较大子节点的值
if(data[k]<data[biggerIndex]) {
//交换他们
swap(data,k,biggerIndex);
//将biggerIndex赋予k，开始while循环的下一次循环，重新保证k节点的值大于其左右子节点的值
k = biggerIndex;
}else {
break;
}
}
}
}
public static void main(String[] args) {
int[] array = {64,5,4,62,98,51,53,25,35};
System.out.println("before: " + Arrays.toString(array));
new HeapSort(array);
System.out.println("after: " + Arrays.toString(array));
}
}运行结果：
before: [64, 5, 4, 62, 98, 51, 53, 25, 35]
开始排序
[35, 64, 53, 62, 5, 51, 4, 25, 98]
[25, 62, 53, 35, 5, 51, 4, 64, 98]
[4, 35, 53, 25, 5, 51, 62, 64, 98]
[4, 35, 51, 25, 5, 53, 62, 64, 98]
[5, 35, 4, 25, 51, 53, 62, 64, 98]
[5, 25, 4, 35, 51, 53, 62, 64, 98]
[4, 5, 25, 35, 51, 53, 62, 64, 98]
[4, 5, 25, 35, 51, 53, 62, 64, 98]
after: [4, 5, 25, 35, 51, 53, 62, 64, 98]四、归并排序
1、实现思路
将两个或两个以上的有序表组合成一个新的有序表。归并排序要使用一个辅助数组，大小跟原数组相同，递归做法。每次将目标序列分解成两个序列，分别排序两个子序列之后，再将两个排序好的子序列merge到一起。
2、代码
package cn.ecjtu.Test;
import java.util.Arrays;
public class MergeSort {
private double[] bridge;//辅助数组
public void sort(double[] obj) {
if(obj==null) {
throw new NullPointerException("The param can not be null!");
}
bridge = new double[obj.length];//初始化中间数组
mergeSort(obj,0,obj.length-1);//归并递归
bridge = null;
}
private void mergeSort(double[] obj,int left,int right) {
if(left<right) {
int center = (left+right)/2;
mergeSort(obj,left,center);
mergeSort(obj,center+1,right);
merge(obj,left,center,right);
}
}
private void merge(double[] obj,int left,int center,int right) {
int mid = center+1;
int third = left;
int tmp = left;
while(left<=center && mid<=right) {
//从两个数组中取出小的放入中间数组
if(obj[left]-obj[mid]<=10e-6) {
bridge[third++] = obj[left++];
}else {
bridge[third++] = obj[mid++];
}
}
//剩余部分依次置入中间数组
while(mid<=right) {
bridge[third++] = obj[mid++];
}
while(left<=center) {
bridge[third++] = obj[left++];
}
//将中间数组的内容拷贝回原数组
copy(obj,tmp,right);
}
private void copy(double[] obj,int left,int right) {
while(left<=right) {
obj[left] = bridge[left];
left++;
}
}
public static void main(String[] args) {
double[] array = {45,9,7,46,12,34,97,46};
System.out.println("before: " + Arrays.toString(array));
MergeSort sorter = new MergeSort();
sorter.sort(array);
System.out.println("after: " + Arrays.toString(array));
}
}
运行结果：
before: [45.0, 9.0, 7.0, 46.0, 12.0, 34.0, 97.0, 46.0]
after: [7.0, 9.0, 12.0, 34.0, 45.0, 46.0, 46.0, 97.0]
五、基数排序
1、实现思路
使用10个辅助队列，假设最大数的数字位数为×，则一共做x次，从个位数开始往前，以第位数字的大小为依据。将数据放进辅助队列，搞定之后回收。下次再以高一位开始的数字位为依据。
2、代码
package cn.ecjtu.Test;
import java.util.Arrays;
import java.util.Vector;
/**
* 以Vector作为辅助队列，基数排序的java代码
*/
public class RadixSort {
private int keyNum = -1;
private Vector<Vector<Double>> util;
public void distribute(double[] sorted,int nth) {
if(nth<=keyNum && nth>0) {
util = new Vector<Vector<Double>>();
for(int i=0;i<10;i++) {
Vector<Double> temp = new Vector<Double>();
util.add(temp);
}
for(int j=0;j<sorted.length;j++) {
int index = getNthDigit(sorted[j],nth);
util.get(index).add(sorted[j]);
}
}
}
public int getNthDigit(double num,int nth) {
String nn = Integer.toString((int)num);
int len = nn.length();
if(len>=nth) {
return Character.getNumericValue(nn.charAt(len-nth));
}else {
return 0;
}
}
public void collect(double[] sorted) {
int k=0;
for(int i=0;i<10;i++) {
int len = util.get(i).size();
if(len>0) {
for(int j=0;j<len;j++) {
sorted[k++] = util.get(i).get(j);
}
}
}
util = null;
}
public int getKeyNum(double[] sorted) {
double max = Double.MIN_VALUE;
for(int i=0;i<sorted.length;i++) {
if(sorted[i]>max) {
max = sorted[i];
}
}
return Integer.toString((int)max).length();
}
public void radixSort(double[] sorted) {
if(keyNum==-1) {
keyNum = getKeyNum(sorted);
}
for(int i=1;i<=keyNum;i++) {
distribute(sorted, i);
collect(sorted);
}
}
public static void main(String[] args) {
double[] sorted = {12,45,64,97,54,68,13,2,87,4,9};
System.out.println("before: " + Arrays.toString(sorted));
RadixSort sorter = new RadixSort();
sorter.radixSort(sorted);
System.out.println("after: " + Arrays.toString(sorted));
}
}
运行结果：
before: [12.0, 45.0, 64.0, 97.0, 54.0, 68.0, 13.0, 2.0, 87.0, 4.0, 9.0]
after: [2.0, 4.0, 9.0, 12.0, 13.0, 45.0, 54.0, 64.0, 68.0, 87.0, 97.0]
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
