文章目录
前言
建议大家还是看看目录,自测一下
提示:以下是本篇文章正文内容,下面代码只是核心代码的实现,使用时做些小改动就可以
内容
1、归并排序
public int[] sort(int[] a,int low,int high){
int mid=(low+high)/2;
if(low<hig){
sort(a,low,mid);
sort(a,mid+1,high);
merge(a,low,mid,high);
}
return a;
}
public void merge(int[] a,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(a[i]<a[j]){
temp[k++]=a[i++];
}else{
temp[k++]=a[j++];
}
}
while(i<=mid){
temp[k++]=a[i++];
}
while(j<=mid){
temp[k++]=a[j++];
}
for(int x=9;x<temp.length;x++){
a[x+low]=temp[x];
}
}
2、堆排序
public static void heapSort(int[] arr){
int i;
int len=arr.length;
for(i=len/2-1;i>-0;i--){
adjustment(arr,i,len);
}
for(i=len-1;i>=0;i--){
int temp=arr[0];
arr[0]=arr[i];
arr[i]=temp;
adjustment(arr,0,i);
}
}
public static void adjustment(int[] arr,int pos;int len){
int child=2*pos+1;
if(child+1<len&&arr[child]>arr[child+1]){
child++;
}
if(child<len&&arr[pos]>arr[child){
int temp=arr[pos];
arr[pos]=arr[child];
arr[child]=temp;
adjustment(arr,child,len);
}
}
3、基数排序
//TODO 此处代码摘自菜鸟教程
/**
* 基数排序
* 考虑负数的情况还可以参考: https://code.i-harness.com/zh-CN/q/e98fa9
*/
public class RadixSort implements IArraySort {
@Override
public int[] sort(int[] sourceArray) throws Exception {
// 对 arr 进行拷贝,不改变参数内容
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
int maxDigit = getMaxDigit(arr);
return radixSort(arr, maxDigit);
}
/**
* 获取最高位数
*/
private int getMaxDigit(int[] arr) {
int maxValue = getMaxValue(arr);
return getNumLenght(maxValue);
}
private int getMaxValue(int[] arr) {
int maxValue = arr[0];
for (int value : arr) {
if (maxValue < value) {
maxValue = value;
}
}
return maxValue;
}
protected int getNumLenght(long num) {
if (num == 0) {
return 1;
}
int lenght = 0;
for (long temp = num; temp != 0; temp /= 10) {
lenght++;
}
return lenght;
}
private int[] radixSort(int[] arr, int maxDigit) {
int mod = 10;
int dev = 1;
for (int i = 0; i < maxDigit; i++, dev *= 10, mod *= 10) {
// 考虑负数的情况,这里扩展一倍队列数,其中 [0-9]对应负数,[10-19]对应正数 (bucket + 10)
int[][] counter = new int[mod * 2][0];
for (int j = 0; j < arr.length; j++) {
int bucket = ((arr[j] % mod) / dev) + mod;
counter[bucket] = arrayAppend(counter[bucket], arr[j]);
}
int pos = 0;
for (int[] bucket : counter) {
for (int value : bucket) {
arr[pos++] = value;
}
}
}
return arr;
}
/**
* 自动扩容,并保存数据
*
* @param arr
* @param value
*/
private int[] arrayAppend(int[] arr, int value) {
arr = Arrays.copyOf(arr, arr.length + 1);
arr[arr.length - 1] = value;
return arr;
}
}
4、冒泡排序
/**
* 3 冒泡排序
**/
public static int[] bubbleSort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
return arr;
}
5、快速排序
/**
* 5.1 快速排序
**/
public static void quicksort(int arr[], int left, int right) {
int pivot;
if (left < right) {
//以pivot为枢轴,较之小的元素在左,较之大的元素在右
pivot = partition(arr, left, right);
//对左边的元素调用快速排序
quicksort(arr, left, pivot - 1);
//对右边数组调用快速排序
quicksort(arr, pivot + 1, right);
}
}
//快速排序算法的切割链表
public static int partition(int arr[], int left, int right) {
int pivotkey = arr[left];
//枢轴选中后永远不变,最终在中间,前边小后变大
while (left < right) {
while (left < right && arr[right] >= pivotkey) {
--right;
}
arr[left] = arr[right];
//此时arr[left]为空,不过它的值保存着pivot中
while (left < right && arr[left] <= pivotkey) {
++left;
}
arr[right] = arr[left];
}
arr[left] = pivotkey;
return left;
}
/**
* 5.2 快速排序
* @param array
*/
public static void quickSort(int[] array) {
int len;
if (array == null || (len = array.length) == 0 || len == 1) {
return;
}
sort(array, 0, len - 1);
}
/**
* 快排核心算法,递归实现
*
* @param array
* @param left
* @param right
*/
public static void sort(int[] array, int left, int right) {
if (left > right) {
return;
}
// base中存放基准数
int base = array[left];
int i = left, j = right;
while (i != j) {
// 顺序很重要,先从右边开始往左找,直到找到比base值小的数
while (array[j] >= base && i < j) {
j--;
}
// 再从左往右边找,直到找到比base值大的数
while (array[i] <= base && i < j) {
i++;
}
// 上面的循环结束表示找到了位置或者(i>=j)了,交换两个数在数组中的位置
if (i < j) {
int tmp = array[i];
array[i] = array[j];
array[j] = tmp;
}
}
// 将基准数放到中间的位置(基准数归位)
array[left] = array[i];
array[i] = base;
// 递归,继续向基准的左右两边执行和上面同样的操作
// i的索引处为上面已确定好的基准值的位置,无需再处理
sort(array, left, i - 1);
sort(array, i + 1, right);
}
6、希尔排序
public static void sort(int[] arr) {
for (int gap = arr.length / 2; gap > 0; gap /= 2) {
for (int i = gap; i < arr.length; i++) {
int tmp = arr[i];
int j;
for (j = i-gap; j >= 0 && arr[j]>value < 0; j = gap) {
arr[j+ gap] = arr[j];
}
arr[j+gap] = tmp;
}
}
}
7、插入排序
/**
* 7 插入排序
**/
public static int[] insertSort(int[] arr) {
for (int i = 1; i < arr.length; i++) {
int j = i;
while (j > 0) {
if (arr[j] < arr[j - 1]) {
int temp;
temp = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = temp;
j--;
} else {
break;
}
}
}
return arr;
}
8、选择排序
/**
* 选择排序
**/
public static int[] selectSort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
// 做第i趟排序
int k = i;
for (int j = k + 1; j < arr.length; j++) {
// 选最小的记录
if (arr[j] < arr[k]) {
//记下目前找到的最小值所在的位置
k = j;
}
}
//在内层循环结束,也就是找到本轮循环的最小的数以后,再进行交换
if (i != k) {
//交换a[i]和a[k]
int temp = arr[i];
arr[i] = arr[k];
arr[k] = temp;
}
}
return arr;
}