七种基于比较排序算法记忆口诀:冒择入希速归堆(冒失选择入口的希望是快速回归马王堆)
冒泡排序:
public class BubbleSort {
public static void sort(long[] arr) {
long tmp = 0;
for(int i = 0; i < arr.length - 1; i++) {
for(int j = arr.length - 1; j > i; j--) {
if(arr[j] < arr[j - 1]) {
//进行交换
tmp = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = tmp;
} //从右边开始,每次循环最小值向左沉下去
}
}
}
}
选择排序:
public class SelectionSort {
public static void sort(long[] arr) {
int k = 0;
long tmp = 0;
for(int i = 0; i < arr.length - 1; i++) {
k = i;
for(int j = i; j < arr.length; j++) {
if(arr[j] < arr[k]) {
k = j; //k始终指向最小的元素
}
}
tmp = arr[i];
arr[i] = arr[k];
arr[k] = tmp;
} //右边未排序比左边已排序的最大值要大
}
}
插入排序:
public class InsertSort {
public static void sort(long[] arr) {
long tmp = 0;
for(int i = 1; i < arr.length; i++) {
tmp = arr[i];
int j = i;
while(j > 0 && arr[j-1] >= tmp) {
arr[j] = arr[j - 1];
j--;
}
arr[j] = tmp;
} //拿未排序的第一个数值跟已排序的从右往左比较,找到比其小的位置插入
}
}
希尔排序(插入排序改进版):
public class ShellSort {
/**
* 排序方法
*/
public static void sort(long[] arr) {
//初始化一个间隔
int h = 1;
//计算最大间隔
while(h < arr.length / 3) {
h = h * 3 + 1;
}
while(h > 0) {
//进行插入排序
long tmp = 0;
for(int i = h; i < arr.length; i++) {
tmp = arr[i];
int j = i;
while(j > h - 1 && arr[j - h] >= tmp) {
arr[j] = arr[j - h];
j -= h;
}
arr[j] = tmp;
}
//减小间隔
h = (h - 1) / 3;
}
}
}
快速排序(冒泡排序改进版):
public class QuickSort {
/**
* 划分数组
*/
public static int partition(long arr[],int left, int right,long point) {
int leftPtr = left - 1;
int rightPtr = right;
while(true) {
//循环,将比关键字小的留在左端
while(leftPtr < rightPtr && arr[++leftPtr] < point);
//循环,将比关键字大的留在右端
while(rightPtr > leftPtr && arr[--rightPtr] > point);
if(leftPtr >= rightPtr) {
break;
} else {
long tmp = arr[leftPtr];
arr[leftPtr] = arr[rightPtr];
arr[rightPtr] = tmp;
}
}
//将关键字和当前leftPtr所指的这一个进行交换
long tmp = arr[leftPtr];
arr[leftPtr] = arr[right];
arr[right] = tmp;
return leftPtr;
}
public static void sort(long[] arr, int left, int right) {
if(right - left <= 0) {
return;
} else {
//设置关键字
long point = arr[right];
//获得切入点,同时对数组进行划分
int partition = partition(arr, left, right, point);
//对左边的子数组进行快速排序
sort(arr,left,partition - 1);
//对右边的子数组进行快速排序
sort(arr,partition + 1, right);
}
}
}
归并排序:
- public class MergeSort {
- /**
- * 归并排序
- * 简介:将两个(或两个以上)有序表合并成一个新的有序表 即把待排序序列分为若干个子序列,每个子序列是有序的。然后再把有序子序列合并为整体有序序列
- * 时间复杂度为O(nlogn)
- * 稳定排序方式
- * @param nums 待排序数组
- * @return 输出有序数组
- */
- public static int[] sort(int[] nums, int low, int high) {
- int mid = (low + high) / 2;
- if (low < high) {
- // 左边
- sort(nums, low, mid);
- // 右边
- sort(nums, mid + 1, high);
- // 左右归并
- merge(nums, low, mid, high);
- }
- return nums;
- }
- public static void merge(int[] nums, int low, int mid, int high) {
- int[] temp = new int[high - low + 1];
- int i = low;// 左指针
- int j = mid + 1;// 右指针
- int k = 0;
- // 把较小的数先移到新数组中
- while (i <= mid && j <= high) {
- if (nums[i] < nums[j]) {
- temp[k++] = nums[i++];
- } else {
- temp[k++] = nums[j++];
- }
- }
- // 把左边剩余的数移入数组
- while (i <= mid) {
- temp[k++] = nums[i++];
- }
- // 把右边边剩余的数移入数组
- while (j <= high) {
- temp[k++] = nums[j++];
- }
- // 把新数组中的数覆盖nums数组
- for (int k2 = 0; k2 < temp.length; k2++) {
- nums[k2 + low] = temp[k2];
- }
- }
- }
堆排序:
public class Heap
{
public void heap_sort(int[] arrays,int e){
if(e>0){
init_sort(arrays,e);//初始化堆,找出最大的放在堆顶
// snp(arrays);
arrays[0]=arrays[e]+arrays[0];
arrays[e]=arrays[0]-arrays[e];
arrays[0]=arrays[0]-arrays[e];
// snp(arrays);
heap_sort(arrays, e-1);
}else{
snp(arrays);
}
}
public void snp(int[] arrays){
for(int i=0;i<arrays.length;i++){
System.out.print(arrays[i]+" ");
}
System.out.println();
}
public void init_sort(int[] arrays,int e){
int m=(e+1)/2;
for(int i=0;i<m;i++){
boolean flag=build_heap(arrays,e,i);
//如果孩子之间有交换,就要重新开始
if(flag){
i=-1;
}
}
}
//返回一个标记,如果有根与孩子交换就要重新从顶根开始查找不满足最大堆树结构
public boolean build_heap(int arrays[],int e,int i){
int l_child=2*i+1;//左孩子
int r_child=2*i+2;//右孩子
if(r_child>e){ //判断是否有右孩子,没有的话直接比较,小于交换
if(arrays[i]<arrays[l_child]){
arrays[i]=arrays[i]+arrays[l_child];
arrays[l_child]=arrays[i]-arrays[l_child];
arrays[i]=arrays[i]-arrays[l_child];
return true;
}else{
return false;
}
}
//在根与两个孩子之间找出最大的那个值进行交换
if(arrays[i]<arrays[l_child]){
if(arrays[l_child]>arrays[r_child]){
//交换根与左孩子的值
arrays[i]=arrays[i]+arrays[l_child];
arrays[l_child]=arrays[i]-arrays[l_child];
arrays[i]=arrays[i]-arrays[l_child];
return true;
}else{
//交换根与右孩子的值
arrays[i]=arrays[i]+arrays[r_child];
arrays[r_child]=arrays[i]-arrays[r_child];
arrays[i]=arrays[i]-arrays[r_child];
return true;
}
}else if(arrays[i]<arrays[r_child]){
//交换根与右孩子的值
arrays[i]=arrays[i]+arrays[r_child];
arrays[r_child]=arrays[i]-arrays[r_child];
arrays[i]=arrays[i]-arrays[r_child];
return true;
}
return false;
}
}
基于非比较排序算法:计数排序,桶排序,基数排序
计数排序:时间复杂度O(n)
public
class
CountSort {
static
int
[] countSort(
int
[] a,
int
range
/*数组元素的范围*/
){
int
count[] =
new
int
[range];
for
(
int
i =
0
; i < a.length; i++) {
count[a[i]]++;
}
for
(
int
i =
1
; i < count.length; i++) {
count[i] += count[i-
1
];
}
int
sortArr[] =
new
int
[a.length];
for
(
int
i =
0
; i < sortArr.length; i++) {
count[a[i]]--;
sortArr[count[a[i]]] = a[i];
}
return
sortArr;
}
}