java中对int排序_八种排序-Java实现

冒泡排序

时间复杂度 o(n²)

空间复杂度 o(1)

稳定

for(int i = 0; i < nums.length-1 ; i++){

for(int j = 0; j < nums.length-1-i; j++)

if (nums[j] > nums[j+1]){

int tmp = nums[j];

nums[j] = nums[j+1];

nums[j+1] = tmp;

}

}

注意点：外层代表循环次数，内层每次循环需比对次数

循环次数 若有三个数 循环两次即可

比对次数 若有三个数 比对两次即可

插入排序

时间复杂度 o(n²)

空间复杂度 o(1)

稳定

for(int i = 0; i < n.length; i++){

for (int j = i; j > 0; j--){

if (n[j] > n[j-1]){

break;

}

int tmp = nums[j];

nums[j] = nums[j-1];

nums[j-1] = tmp;

}

}

选择排序

时间复杂度 o(n²)

空间复杂度 o(1)

不稳定

与冒泡相比减小交换次数

for(int i = 0; i < nums.length; i++){

int min_index = i

for (int j = i+1; j < nums.length; j++){

if (nums[j] < nums[min_index])

min_index = j;

}

int tmp = nums[i];

nums[i] = nums[min_index];

nums[min_index] = tmp;

}

希尔排序

时间复杂度 o(n1.3) 最坏o(n²)

空间复杂度 o(1)

稳定 //4个循环 吓人

for (int gap = nums.length / 2; gap > 0; gap /= 2) {

//第一步确定间距

//第二步一个 gap 里面有多少个值 需要gap次

for (int i = 0; i < gap; i++) {

//第三步进行比对

for (int j = i + gap; j < nums.length; j += gap) {

if (nums[j] < nums[j - gap]) {

int tmp = nums[j];

int k = j - gap;

//进行迭代

while (k >= 0 && nums[k] > tmp) {

nums[k + gap] = nums[k];

k -= gap;

}

nums[k + gap] = tmp;

}

}

}

}

归并排序

时间复杂度 o(nlog2n)

空间复杂度 o(n)

稳定 合并链表

递归实现

public class MergeSort {

//两路归并算法，两个排好序的子序列合并为一个子序列

public void merge(int []a,int left,int mid,int right){

int []tmp=new int[a.length];//辅助数组

int p1=left,p2=mid+1,k=left;//p1、p2是检测指针，k是存放指针

while(p1<=mid && p2<=right){

if(a[p1]<=a[p2])

tmp[k++]=a[p1++];

else

tmp[k++]=a[p2++];

}

while(p1<=mid) tmp[k++]=a[p1++];//如果第一个序列未检测完，直接将后面所有元素加到合并的序列中

while(p2<=right) tmp[k++]=a[p2++];//同上

//复制回原素组

for (int i = left; i <=right; i++)

a[i]=tmp[i];

}

public void mergeSort(int [] a,int start,int end){

if(start

int mid=(start+end)/2;//划分子序列

mergeSort(a, start, mid);//对左侧子序列进行递归排序

mergeSort(a, mid+1, end);//对右侧子序列进行递归排序

merge(a, start, mid, end);//合并

}

}

}

堆排序

直接构造堆

时间复杂度 o(nlog2n)

空间复杂度 o(1)

先构建一个大顶堆/(构建小顶堆不能保证顺序)

public static void sort(int[] nums){

//创建堆

for (int i = (nums.length - 1) / 2; i >= 0; i--) {

//从第一个非叶子结点从下至上，从右至左调整结构

//为什么输入这个呢？

adjustHeap(nums, i, nums.length);

}

//调整堆结构+交换堆顶元素与末尾元素

for (int i = nums.length - 1; i > 0; i--) {

//将堆顶元素与末尾元素进行交换

swap(0,i);

//重新对堆进行调整

adjustHeap(nums, 0, i);

}

}

private static void adjustHeap(int[] nums, int parent, int length) {

//将temp作为父节点

int tmp = nums[parent];

for(int k = i*2+1; k

//若右节点存在 取左右节点大的那个

if (k+1 < length && nums[k]

k++;

}

//进行比对

if (nums[k] > tmp){

nums[parent] = nums[k];

parent = k;

} else {

break;

}

}

nums[parent] = tmp;

}

快速排序

时间复杂度 o(nlog2n)

空间复杂度 o(1)

不稳定

分治算法

public static void quickSort(int[] nums, int low, int high){

if (low < high){

int privotLoc = partition(nums, low, high);

quickSort(nums, low, privotLoc - 1);

quickSort(nums, privotLoc + 1, high);//会出-1

}

}

public static int partition(int[] nums, int low, int high){

int privotKey = nums[low];

int begin = low;

while (low < high){

while(low < high && nums[high] >= privotKey)

--high;

while(low < high && nums[low] <= privotKey)

++low;

if (low < high){

swap(nums, low, high);

}

}

swap(nums, begin, low);

return low;

}

private static void swap(int[] nums, int low, int high) {

int tmp = nums[low];

nums[low] = nums[high];

nums[high] = tmp;

}

基数排序

//arr是要排序的数组，max是数组中最大的数有几位

public static void lsd_RadixSort(int[] arr,int max)

{

//count数组用来计数

int[] count = new int[10];

//bucket用来当桶(在下面你就理解了什么是桶了)，放数据，取数据

int[] bucket = new int[arr.length];

//k表示第几位，1代表个位，2代表十位，3代表百位

for(int k=1;k<=max;k++)

{

//把count置空，防止上次循环的数据影响

for(int i=0;i<10;i++)

{

count[i] = 0;

}

//分别统计第k位是0,1,2,3,4,5,6,7,8,9的数量

//以下便称为桶

//即此循环用来统计每个桶中的数据的数量

for(int i=0;i

{

count[getFigure(arr[i],k)]++;

}

//利用count[i]来确定放置数据的位置

for(int i=1;i

{

count[i] = count[i] + count[i-1];

}

//执行完此循环之后的count[i]就是第i个桶右边界的位置

//利用循环把数据装入各个桶中，注意是从后往前装

//这里是重点，一定要仔细理解

for(int i=arr.length-1;i>=0;i--)

{

int j = getFigure(arr[i],k);

bucket[count[j]-1] = arr[i];

count[j]--;

}

//将桶中的数据取出来，赋值给arr

for(int i=0,j=0;i

{

arr[i] = bucket[j];

}

}

}

//此函数返回整型数i的第k位是什么

public static int getFigure(int i,int k)

{

int[] a = {1,10,100};

return (i/a[k-1])%10;

}