本文对当前主流排序算法原理和具体java实现,主要包括冒泡排序,插入排序,选择排序,希尔排序,堆排序,快速排序,归并排序进行讲解。算法功能基本测试通过,读者若有更好的算法实现请留评论里面,感激不尽。
一、冒泡排序(BubbleSortDemo),冒泡排序基本原理:打个简单的比方就如同我们烧开水时的气泡,大的气泡一个一个的往上冒,即冒泡排序的每一轮排序都选出最大的数拍在最后或者最前。冒泡排序的时间复杂度为O(n2)。
//parm score为输入排序数组,return排序后数组
public static int[] BubbleSortDemo(int [] score) {
for (int i = 0; i < score.length -1; i++){for(int j = 0 ;j < score.length - i - 1; j++){
if(score[j] >score[j + 1]){
int temp = score[j];
score[j] = score[j + 1];
score[j + 1] = temp;
}
}
}
return score;
}
二、选择排序(selectionSort),选择排序的基本原理:用白话讲就是首先从一组数中选出一个最小的数或者最大的数,然后将这个最小的数或者最大的数与此轮排序第一个数进行交换。选择排序的时间复杂度为O(n*n)。
public static int[] selectionSort(int[] score){
for(int i = 0; i < score.length-1; ++i){
int k = i;
for(int j = i; j < score.length; ++j){
if(score[k] > score[j]){
k = j;
}
}
if(k != i){
int temp = score[i];
score[i] = score[k];
score[k] = temp;
}
}
return score;
}
三、插入排序 (insertSort),插入排序的基本原理:用白话讲就是像我们打扑克牌,把从1到K的牌排好序,我们一般采用的方法时取出俩张牌排好大小,然后取第三张牌,插入这俩种中合适的位置,然后在取第四张牌插入,前三张已经排好序的位置,直到所有的牌都排好为止。用比较正式的话来讲就是把n个待排序的元素看成一个有序表和一个无序表,开始有序表只包含一个元素,无序表中包含n-1个元素,排序过程中每次从无序表中取出第一个元素,把它的排序码依次与有序表元素的排序码进行比较,将它插入到有序表中的适当位置,使之成为新的有序表。
public static int[] insertSort(int score[])
{
for(int i=1;i<score.length;i++)
{
int insertVal = score[i];
// insertValue准备和前一个数比较
int index=i-1;
while(index>=0&&insertVal<score[index])
{
// 将把arr[index]向后移动
score[index+1]=score[index];
// 让index向前移动一位
index--;
}
// 将insertValue插入到适当位置
score[index+1]=insertVal;
}
return score;
}
四、希尔排序(shellSort),在研究希尔排序之前一定要好好熟悉插入排序,有助于理解。希尔排序的基本原理:用白话来说,希尔排序实际上就是插入排序的一种改进算法,首先对数据进行分组,然后对分组的数据插入排序,最后对所有数据插入排序。本例中分割间隔长度为 DataLength = DataLength / 2; 对半分。最好的时间复杂度为与分割增量有很大的关系。
public static int [] ShellSort(int[] score) {
int i, j, k; // 循环计数变量
int Temp; // 暂存变量
boolean Change; // 数据是否改变
int DataLength; // 分割集合的间隔长度
int Pointer; // 进行处理的位置
int Index=score.length;
DataLength = (int) Index / 2; // 初始集合间隔长度
while (DataLength != 0) // 数列仍可进行分割
{
// 对各个集合进行处理
for (j = DataLength; j < Index; j++) {
Change = false;
Temp = score[j]; // 暂存Data[j]的值,待交换值时用
Pointer = j - DataLength; // 计算进行处理的位置
// 进行集合内数值的比较与交换值
while (Temp < score[Pointer] && Pointer >= 0 && Pointer <= Index) {
score[Pointer + DataLength] = score[Pointer];
// 计算下一个欲进行处理的位置
Pointer = Pointer - DataLength;
Change = true;
if (Pointer < 0 || Pointer > Index)
break;
}
// 与最后的数值交换
score[Pointer + DataLength] = Temp;
}
DataLength = DataLength / 2; // 计算下次分割的间隔长度
}
return score;
}
五、快速排序(Quik Sort),快速排序基本原理:快速排序实际上就是采用递归分组方法,选出一个排序数中的数作为参考节点,小于参考节点的数放在左边,大于节点的数放在右边。采用递归一直到整个左右排序都执行完。
public static void swap1(int a[], int i, int j) { // 通过临时变量,交换数据
int tmp = a[i];
a[i] = a[j];
a[j] = tmp;
} // 第一次交换分析
public static void quicksort(int a[], int low, int high) { // 假设传入low=0; high=a.length-1;
if (low < high) { // 条件判断
int pivot, p_pos, i; // 声明变量
p_pos = low; // p_pos指向low,即位索引为0位置 ;
pivot = a[p_pos]; // 将0位置上的数值赋给pivot;
for (i = low + 1; i <= high; i++) { // 循环次数, i=1;
if (a[i]<pivot) { // 1位置的数与0位置数作比较: a[1]>a[0]
p_pos++; // 2位与1位比较,3位与2位比较......
swap(a, p_pos, i); // 传参并调用swap
}
}
swap1(a, low, p_pos); // 将p_pos设为high再次调用swap
quicksort(a, low, p_pos - 1); // 递归调用,排序左半区
quicksort(a, p_pos + 1, high); // 递归调用,排序右半区
}
}
六、堆排序(Heap Sort),堆排序基本原理:堆排序采用二叉树的基本原理进行排序,java中可用数组表示二叉树。堆排序过程主要有俩部,第一部就是构建堆;第二部就是讲堆根节点与尾节点交换。
public static int[] heapSort(int[] data){
int arrayLength=data.length;
//循环建堆
for(int i=0;i<arrayLength-1;i++){
//建堆
buildMaxHeap(data,arrayLength-1-i);
//交换堆顶和最后一个元素
swap(data,0,arrayLength-1-i);
}
return data;
}
private static void swap(int[] data, int i, int j) {
// TODO Auto-generated method stub
int tmp=data[i];
data[i]=data[j];
data[j]=tmp;
}
//对data数组从0到lastIndex建大顶堆
private static void buildMaxHeap(int[] data, int lastIndex) {
// TODO Auto-generated method stub
//从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;
}
}
}
}
七、归并排序(Merge Sort),归并排序基本原来:归并排序采用递归算法,分治策略等方法排序。基本流程为分割,在子分割,子合并,大合并。整个流程就是分割和合并,采用递归算法实现。
public static void mergeSort(int[] data) {
sort(data, 0, data.length - 1);
}
public static void sort(int[] data, int left, int right) {
if (left >= right)
return;
// 找出中间索引
int center = (left + right) / 2;
// 对左边数组进行递归
sort(data, left, center);
// 对右边数组进行递归
sort(data, center + 1, right);
// 合并
merge(data, left, center, right);
}
public static void merge(int[] data, int left, int center, int right) {
// 临时数组
int[] tmpArr = new int[data.length];
// 右数组第一个元素索引
int mid = center + 1;
// third 记录临时数组的索引
int third = left;
// 缓存左数组第一个元素的索引
int tmp = left;
while (left <= center && mid <= right) {
// 从两个数组中取出最小的放入临时数组
if (data[left] <= data[mid]) {
tmpArr[third++] = data[left++];
} else {
tmpArr[third++] = data[mid++];
}
}
// 剩余部分依次放入临时数组(实际上两个while只会执行其中一个)
while (mid <= right) {
tmpArr[third++] = data[mid++];
}
while (left <= center) {
tmpArr[third++] = data[left++];
}
// 将临时数组中的内容拷贝回原数组中
// (原left-right范围的内容被复制回原数组)
while (tmp <= right) {
data[tmp] = tmpArr[tmp++];
}
}
八、基数排序,基数排序的基本原理:基数排序就是从对数字的个位,十位,百位等待,进行装桶。具体过程先将个位装桶,然后组合,在讲十位装桶,然后组合,以此类推,知道组合完了,排序也就完了。
//基于计数排序的基数排序算法
private static void radixSort(int[] array,int radix, int distance) {
//array为待排序数组
//radix,代表基数
//代表排序元素的位数
int length = array.length;
int[] temp = new int[length];//用于暂存元素
int[] count = new int[radix];//用于计数排序
int divide = 1;
for (int i = 0; i < distance; i++) {
System.arraycopy(array, 0,temp, 0, length);
Arrays.fill(count, 0);
for (int j = 0; j < length; j++) {
int tempKey = (temp[j]/divide)%radix;
count[tempKey]++;
}
for (int j = 1; j < radix; j++) {
count [j] = count[j] + count[j-1];
}
//个人觉的运用计数排序实现计数排序的重点在下面这个方法
for (int j = length - 1; j >= 0; j--) {
int tempKey = (temp[j]/divide)%radix;
count[tempKey]--;
array[count[tempKey]] = temp[j];
}
divide = divide * radix;
}
}