Java综合整理堆排序 快速排序 归并排序

Java综合整理堆排序 快速排序 归并排序

目录堆排序快速排序递归非递归归并排序递归非递归

堆排序

时间复杂度：0（N*log(N)）

空间复杂度：0（1）

稳定性：不稳定

private static void heapSort(int[] arr) {

//建堆

crearHeap(arr);

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

int heapSize=arr.length-i;

swap(arr,heapSize-1,0);

heapSize--;

shiftDown(arr,heapSize,0);

}

System.out.println(Arrays.toString(arr));

}

private static void crearHeap(int[] arr) {

// 从后往前遍历(右边非叶子节点开始), 依次进行向下调整

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

shiftDown(arr,arr.length,i);

}

}

//向下调整，形成大堆

private static void shiftDown(int[] arr, int size, int i) {

int parent = i;

int child = parent*2+1;

while (child

if (child +1< size && arr[child +1]> arr[child]){

child=child+1;

}

if (arr[child]>arr[parent]){

swap(arr,child,parent);

}else {

break;

}

parent=child;

child=parent*2+1;

}NYrAoCWEvp

}

//交换

private static void swap(int[] arr, int child, int parent) {

int tmp =arr[child];NYrAoCWEvp

arr[child] =arr[parent];

arr[parent]=tmp;

}

快速排序

时间复杂度:O(N^ logN) 最坏的时候O(N^2) 和基准值密切相关

空间复杂度:0(logN) 最坏的时候O(N)

稳定性:不稳定

递归

private static void quick(int[] arr) {

quickSortHelper(arr,0,arr.length-1);

System.out.println(Arrays.toString(arr));

}

private static void quickSortHelper(int[] arr, int left, int right) {

if (left>=right){

//区间只有一个元素，或者零个元素

return;

}

int index = partition(arr,left,right);

quickSortHelper(arr,left,index-1);

quickSortHelper(arr,index+1,right);

}

private static int partition(int[] arr, int left, int right) {

int i=left;

int j=right;

int baseValue=arr[right];

while (i

while (i

i++;

}

while (i=baseValue){

j--;

}

if (i

swap(arr,i,j);

}

}

swap(arr,i,right);

return i;

}

private static void swap(int[] arr, int i, int j) {

int tmp =arr[i];

arr[i]=arr[j];

arr[j]=tmp;

}

非递归

public static void quickSortByLoop(int[] arr) {

Stack stack =new Stack<>();

stack.push(0);

stack.push(arr.length-1);

while (!stack.isEmpty()){

int right = stack.pop();

int left = stack.pop();

if (left>=right){

continue;

}

int index = partition(arr,left,right);

//右子树

stack.push(index+1);

stack.push(right);

//左子树

stack.push(left);

stack.push(index-1);

}

System.out.println(Arrays.toString(arr));

}

private static int partition(int[] arr, int left, int right) {

int baseValue =arr[right];

int i =left;

int j =right;

while (i

while (i

i++;

}

while (i=baseValue){

j--;

}

if (i

swap(arr,i,j);

}

}

swap(arr,i,right);

return i;

}

private static void swap(int[] arr, int i, int j) {

int tmp = arr[i];

arr[i] = arr[j];

arr[j] = tmp;

}

归并排序

时间复杂度:O(NlogN)

空间复杂度:O(N） 如果是链表，可以为O(1)

稳定性:稳定

递归

public static void mergeSort(int[] arr){

mergeSortHelper(arr,0,arr.length);

System.out.println(Arrays.toString(arr));

}

private static void mergeSortHelper(int[] arr, int left, int right) {

if (right-left<=1){

return;

}

int mid = (right+left)/2;

mergeSortHelper(arr,left,mid);

mergeSortHelper(arr,mid,right);

merge(arr,left,mid,right);

}

private static void merge(int[] arr, int left, int mid, int right) {

int cur1 =left;

int cur2 =mid;

//两个数组合并后的结果

int[] output=new int[right-left];

int outputIndex=0;

while (cur1

if (arr[cur1]<=arr[cur2]) {

output[outputIndex++] = arr[cur1++];

}else {

output[outputIndex++] = arr[cur2++];

}

}

while (cur1

output[outputIndex++] = arr[cur1++];

}

while (cur2

output[outputIndex++] = arr[cur2++];

}

for (int i = 0; i < right-left ; i++) {

arr[left+i] = output[i];

}

}

非递归

public static void mergeSortByLoop(int[] arr){

// gap 当前每个组中的元素个数.

for (int gap =1;gap

for (int i = 0; i

//相当于把两个长度为 gap 的相邻组进行了合并

int left =i;

int mid =i+gap;

int right=i+2*gap;

if (mid > arr.length){

mid =arr.length;

}

if (right>arr.length){

right=arr.length;

}

merge(arr,left,mid,right);

}

}

System.out.println(Arrays.toString(arr));

}

if (child +1< size && arr[child +1]> arr[child]){

child=child+1;

}

if (arr[child]>arr[parent]){

swap(arr,child,parent);

}else {

break;

}

parent=child;

child=parent*2+1;

}NYrAoCWEvp

}

//交换

private static void swap(int[] arr, int child, int parent) {

int tmp =arr[child];NYrAoCWEvp

arr[child] =arr[parent];

arr[parent]=tmp;

}

快速排序

时间复杂度:O(N^ logN) 最坏的时候O(N^2) 和基准值密切相关

空间复杂度:0(logN) 最坏的时候O(N)

稳定性:不稳定

递归

private static void quick(int[] arr) {

quickSortHelper(arr,0,arr.length-1);

System.out.println(Arrays.toString(arr));

}

private static void quickSortHelper(int[] arr, int left, int right) {

if (left>=right){

//区间只有一个元素，或者零个元素

return;

}

int index = partition(arr,left,right);

quickSortHelper(arr,left,index-1);

quickSortHelper(arr,index+1,right);

}

private static int partition(int[] arr, int left, int right) {

int i=left;

int j=right;

int baseValue=arr[right];

while (i

while (i

i++;

}

while (i=baseValue){

j--;

}

if (i

swap(arr,i,j);

}

}

swap(arr,i,right);

return i;

}

private static void swap(int[] arr, int i, int j) {

int tmp =arr[i];

arr[i]=arr[j];

arr[j]=tmp;

}

非递归

public static void quickSortByLoop(int[] arr) {

Stack stack =new Stack<>();

stack.push(0);

stack.push(arr.length-1);

while (!stack.isEmpty()){

int right = stack.pop();

int left = stack.pop();

if (left>=right){

continue;

}

int index = partition(arr,left,right);

//右子树

stack.push(index+1);

stack.push(right);

//左子树

stack.push(left);

stack.push(index-1);

}

System.out.println(Arrays.toString(arr));

}

private static int partition(int[] arr, int left, int right) {

int baseValue =arr[right];

int i =left;

int j =right;

while (i

while (i

i++;

}

while (i=baseValue){

j--;

}

if (i

swap(arr,i,j);

}

}

swap(arr,i,right);

return i;

}

private static void swap(int[] arr, int i, int j) {

int tmp = arr[i];

arr[i] = arr[j];

arr[j] = tmp;

}

归并排序

时间复杂度:O(NlogN)

空间复杂度:O(N） 如果是链表，可以为O(1)

稳定性:稳定

递归

public static void mergeSort(int[] arr){

mergeSortHelper(arr,0,arr.length);

System.out.println(Arrays.toString(arr));

}

private static void mergeSortHelper(int[] arr, int left, int right) {

if (right-left<=1){

return;

}

int mid = (right+left)/2;

mergeSortHelper(arr,left,mid);

mergeSortHelper(arr,mid,right);

merge(arr,left,mid,right);

}

private static void merge(int[] arr, int left, int mid, int right) {

int cur1 =left;

int cur2 =mid;

//两个数组合并后的结果

int[] output=new int[right-left];

int outputIndex=0;

while (cur1

if (arr[cur1]<=arr[cur2]) {

output[outputIndex++] = arr[cur1++];

}else {

output[outputIndex++] = arr[cur2++];

}

}

while (cur1

output[outputIndex++] = arr[cur1++];

}

while (cur2

output[outputIndex++] = arr[cur2++];

}

for (int i = 0; i < right-left ; i++) {

arr[left+i] = output[i];

}

}

非递归

public static void mergeSortByLoop(int[] arr){

// gap 当前每个组中的元素个数.

for (int gap =1;gap

for (int i = 0; i

//相当于把两个长度为 gap 的相邻组进行了合并

int left =i;

int mid =i+gap;

int right=i+2*gap;

if (mid > arr.length){

mid =arr.length;

}

if (right>arr.length){

right=arr.length;

}

merge(arr,left,mid,right);

}

}

System.out.println(Arrays.toString(arr));

}

while (i

i++;

}

while (i=baseValue){

j--;

}

if (i

swap(arr,i,j);

}

}

swap(arr,i,right);

return i;

}

private static void swap(int[] arr, int i, int j) {

int tmp =arr[i];

arr[i]=arr[j];

arr[j]=tmp;

}

非递归

public static void quickSortByLoop(int[] arr) {

Stack stack =new Stack<>();

stack.push(0);

stack.push(arr.length-1);

while (!stack.isEmpty()){

int right = stack.pop();

int left = stack.pop();

if (left>=right){

continue;

}

int index = partition(arr,left,right);

//右子树

stack.push(index+1);

stack.push(right);

//左子树

stack.push(left);

stack.push(index-1);

}

System.out.println(Arrays.toString(arr));

}

private static int partition(int[] arr, int left, int right) {

int baseValue =arr[right];

int i =left;

int j =right;

while (i

while (i

i++;

}

while (i=baseValue){

j--;

}

if (i

swap(arr,i,j);

}

}

swap(arr,i,right);

return i;

}

private static void swap(int[] arr, int i, int j) {

int tmp = arr[i];

arr[i] = arr[j];

arr[j] = tmp;

}

归并排序

时间复杂度:O(NlogN)

空间复杂度:O(N） 如果是链表，可以为O(1)

稳定性:稳定

递归

public static void mergeSort(int[] arr){

mergeSortHelper(arr,0,arr.length);

System.out.println(Arrays.toString(arr));

}

private static void mergeSortHelper(int[] arr, int left, int right) {

if (right-left<=1){

return;

}

int mid = (right+left)/2;

mergeSortHelper(arr,left,mid);

mergeSortHelper(arr,mid,right);

merge(arr,left,mid,right);

}

private static void merge(int[] arr, int left, int mid, int right) {

int cur1 =left;

int cur2 =mid;

//两个数组合并后的结果

int[] output=new int[right-left];

int outputIndex=0;

while (cur1

if (arr[cur1]<=arr[cur2]) {

output[outputIndex++] = arr[cur1++];

}else {

output[outputIndex++] = arr[cur2++];

}

}

while (cur1

output[outputIndex++] = arr[cur1++];

}

while (cur2

output[outputIndex++] = arr[cur2++];

}

for (int i = 0; i < right-left ; i++) {

arr[left+i] = output[i];

}

}

非递归

public static void mergeSortByLoop(int[] arr){

// gap 当前每个组中的元素个数.

for (int gap =1;gap

for (int i = 0; i

//相当于把两个长度为 gap 的相邻组进行了合并

int left =i;

int mid =i+gap;

int right=i+2*gap;

if (mid > arr.length){

mid =arr.length;

}

if (right>arr.length){

right=arr.length;

}

merge(arr,left,mid,right);

}

}

System.out.println(Arrays.toString(arr));

}

i++;

}

while (i=baseValue){

j--;

}

if (i

swap(arr,i,j);

}

}

swap(arr,i,right);

return i;

}

private static void swap(int[] arr, int i, int j) {

int tmp =arr[i];

arr[i]=arr[j];

arr[j]=tmp;

}

非递归

public static void quickSortByLoop(int[] arr) {

Stack stack =new Stack<>();

stack.push(0);

stack.push(arr.length-1);

while (!stack.isEmpty()){

int right = stack.pop();

int left = stack.pop();

if (left>=right){

continue;

}

int index = partition(arr,left,right);

//右子树

stack.push(index+1);

stack.push(right);

//左子树

stack.push(left);

stack.push(index-1);

}

System.out.println(Arrays.toString(arr));

}

private static int partition(int[] arr, int left, int right) {

int baseValue =arr[right];

int i =left;

int j =right;

while (i

while (i

i++;

}

while (i=baseValue){

j--;

}

if (i

swap(arr,i,j);

}

}

swap(arr,i,right);

return i;

}

private static void swap(int[] arr, int i, int j) {

int tmp = arr[i];

arr[i] = arr[j];

arr[j] = tmp;

}

归并排序

时间复杂度:O(NlogN)

空间复杂度:O(N） 如果是链表，可以为O(1)

稳定性:稳定

递归

public static void mergeSort(int[] arr){

mergeSortHelper(arr,0,arr.length);

System.out.println(Arrays.toString(arr));

}

private static void mergeSortHelper(int[] arr, int left, int right) {

if (right-left<=1){

return;

}

int mid = (right+left)/2;

mergeSortHelper(arr,left,mid);

mergeSortHelper(arr,mid,right);

merge(arr,left,mid,right);

}

private static void merge(int[] arr, int left, int mid, int right) {

int cur1 =left;

int cur2 =mid;

//两个数组合并后的结果

int[] output=new int[right-left];

int outputIndex=0;

while (cur1

if (arr[cur1]<=arr[cur2]) {

output[outputIndex++] = arr[cur1++];

}else {

output[outputIndex++] = arr[cur2++];

}

}

while (cur1

output[outputIndex++] = arr[cur1++];

}

while (cur2

output[outputIndex++] = arr[cur2++];

}

for (int i = 0; i < right-left ; i++) {

arr[left+i] = output[i];

}

}

非递归

public static void mergeSortByLoop(int[] arr){

// gap 当前每个组中的元素个数.

for (int gap =1;gap

for (int i = 0; i

//相当于把两个长度为 gap 的相邻组进行了合并

int left =i;

int mid =i+gap;

int right=i+2*gap;

if (mid > arr.length){

mid =arr.length;

}

if (right>arr.length){

right=arr.length;

}

merge(arr,left,mid,right);

}

}

System.out.println(Arrays.toString(arr));

}

swap(arr,i,j);

}

}

swap(arr,i,right);

return i;

}

private static void swap(int[] arr, int i, int j) {

int tmp =arr[i];

arr[i]=arr[j];

arr[j]=tmp;

}

非递归

public static void quickSortByLoop(int[] arr) {

Stack stack =new Stack<>();

stack.push(0);

stack.push(arr.length-1);

while (!stack.isEmpty()){

int right = stack.pop();

int left = stack.pop();

if (left>=right){

continue;

}

int index = partition(arr,left,right);

//右子树

stack.push(index+1);

stack.push(right);

//左子树

stack.push(left);

stack.push(index-1);

}

System.out.println(Arrays.toString(arr));

}

private static int partition(int[] arr, int left, int right) {

int baseValue =arr[right];

int i =left;

int j =right;

while (i

while (i

i++;

}

while (i=baseValue){

j--;

}

if (i

swap(arr,i,j);

}

}

swap(arr,i,right);

return i;

}

private static void swap(int[] arr, int i, int j) {

int tmp = arr[i];

arr[i] = arr[j];

arr[j] = tmp;

}

归并排序

时间复杂度:O(NlogN)

空间复杂度:O(N） 如果是链表，可以为O(1)

稳定性:稳定

递归

public static void mergeSort(int[] arr){

mergeSortHelper(arr,0,arr.length);

System.out.println(Arrays.toString(arr));

}

private static void mergeSortHelper(int[] arr, int left, int right) {

if (right-left<=1){

return;

}

int mid = (right+left)/2;

mergeSortHelper(arr,left,mid);

mergeSortHelper(arr,mid,right);

merge(arr,left,mid,right);

}

private static void merge(int[] arr, int left, int mid, int right) {

int cur1 =left;

int cur2 =mid;

//两个数组合并后的结果

int[] output=new int[right-left];

int outputIndex=0;

while (cur1

if (arr[cur1]<=arr[cur2]) {

output[outputIndex++] = arr[cur1++];

}else {

output[outputIndex++] = arr[cur2++];

}

}

while (cur1

output[outputIndex++] = arr[cur1++];

}

while (cur2

output[outputIndex++] = arr[cur2++];

}

for (int i = 0; i < right-left ; i++) {

arr[left+i] = output[i];

}

}

非递归

public static void mergeSortByLoop(int[] arr){

// gap 当前每个组中的元素个数.

for (int gap =1;gap

for (int i = 0; i

//相当于把两个长度为 gap 的相邻组进行了合并

int left =i;

int mid =i+gap;

int right=i+2*gap;

if (mid > arr.length){

mid =arr.length;

}

if (right>arr.length){

right=arr.length;

}

merge(arr,left,mid,right);

}

}

System.out.println(Arrays.toString(arr));

}

while (i

i++;

}

while (i=baseValue){

j--;

}

if (i

swap(arr,i,j);

}

}

swap(arr,i,right);

return i;

}

private static void swap(int[] arr, int i, int j) {

int tmp = arr[i];

arr[i] = arr[j];

arr[j] = tmp;

}

归并排序

时间复杂度:O(NlogN)

空间复杂度:O(N） 如果是链表，可以为O(1)

稳定性:稳定

递归

public static void mergeSort(int[] arr){

mergeSortHelper(arr,0,arr.length);

System.out.println(Arrays.toString(arr));

}

private static void mergeSortHelper(int[] arr, int left, int right) {

if (right-left<=1){

return;

}

int mid = (right+left)/2;

mergeSortHelper(arr,left,mid);

mergeSortHelper(arr,mid,right);

merge(arr,left,mid,right);

}

private static void merge(int[] arr, int left, int mid, int right) {

int cur1 =left;

int cur2 =mid;

//两个数组合并后的结果

int[] output=new int[right-left];

int outputIndex=0;

while (cur1

if (arr[cur1]<=arr[cur2]) {

output[outputIndex++] = arr[cur1++];

}else {

output[outputIndex++] = arr[cur2++];

}

}

while (cur1

output[outputIndex++] = arr[cur1++];

}

while (cur2

output[outputIndex++] = arr[cur2++];

}

for (int i = 0; i < right-left ; i++) {

arr[left+i] = output[i];

}

}

非递归

public static void mergeSortByLoop(int[] arr){

// gap 当前每个组中的元素个数.

for (int gap =1;gap

for (int i = 0; i

//相当于把两个长度为 gap 的相邻组进行了合并

int left =i;

int mid =i+gap;

int right=i+2*gap;

if (mid > arr.length){

mid =arr.length;

}

if (right>arr.length){

right=arr.length;

}

merge(arr,left,mid,right);

}

}

System.out.println(Arrays.toString(arr));

}

i++;

}

while (i=baseValue){

j--;

}

if (i

swap(arr,i,j);

}

}

swap(arr,i,right);

return i;

}

private static void swap(int[] arr, int i, int j) {

int tmp = arr[i];

arr[i] = arr[j];

arr[j] = tmp;

}

归并排序

时间复杂度:O(NlogN)

空间复杂度:O(N） 如果是链表，可以为O(1)

稳定性:稳定

递归

public static void mergeSort(int[] arr){

mergeSortHelper(arr,0,arr.length);

System.out.println(Arrays.toString(arr));

}

private static void mergeSortHelper(int[] arr, int left, int right) {

if (right-left<=1){

return;

}

int mid = (right+left)/2;

mergeSortHelper(arr,left,mid);

mergeSortHelper(arr,mid,right);

merge(arr,left,mid,right);

}

private static void merge(int[] arr, int left, int mid, int right) {

int cur1 =left;

int cur2 =mid;

//两个数组合并后的结果

int[] output=new int[right-left];

int outputIndex=0;

while (cur1

if (arr[cur1]<=arr[cur2]) {

output[outputIndex++] = arr[cur1++];

}else {

output[outputIndex++] = arr[cur2++];

}

}

while (cur1

output[outputIndex++] = arr[cur1++];

}

while (cur2

output[outputIndex++] = arr[cur2++];

}

for (int i = 0; i < right-left ; i++) {

arr[left+i] = output[i];

}

}

非递归

public static void mergeSortByLoop(int[] arr){

// gap 当前每个组中的元素个数.

for (int gap =1;gap

for (int i = 0; i

//相当于把两个长度为 gap 的相邻组进行了合并

int left =i;

int mid =i+gap;

int right=i+2*gap;

if (mid > arr.length){

mid =arr.length;

}

if (right>arr.length){

right=arr.length;

}

merge(arr,left,mid,right);

}

}

System.out.println(Arrays.toString(arr));

}

swap(arr,i,j);

}

}

swap(arr,i,right);

return i;

}

private static void swap(int[] arr, int i, int j) {

int tmp = arr[i];

arr[i] = arr[j];

arr[j] = tmp;

}

归并排序

时间复杂度:O(NlogN)

空间复杂度:O(N） 如果是链表，可以为O(1)

稳定性:稳定

递归

public static void mergeSort(int[] arr){

mergeSortHelper(arr,0,arr.length);

System.out.println(Arrays.toString(arr));

}

private static void mergeSortHelper(int[] arr, int left, int right) {

if (right-left<=1){

return;

}

int mid = (right+left)/2;

mergeSortHelper(arr,left,mid);

mergeSortHelper(arr,mid,right);

merge(arr,left,mid,right);

}

private static void merge(int[] arr, int left, int mid, int right) {

int cur1 =left;

int cur2 =mid;

//两个数组合并后的结果

int[] output=new int[right-left];

int outputIndex=0;

while (cur1

if (arr[cur1]<=arr[cur2]) {

output[outputIndex++] = arr[cur1++];

}else {

output[outputIndex++] = arr[cur2++];

}

}

while (cur1

output[outputIndex++] = arr[cur1++];

}

while (cur2

output[outputIndex++] = arr[cur2++];

}

for (int i = 0; i < right-left ; i++) {

arr[left+i] = output[i];

}

}

非递归

public static void mergeSortByLoop(int[] arr){

// gap 当前每个组中的元素个数.

for (int gap =1;gap

for (int i = 0; i

//相当于把两个长度为 gap 的相邻组进行了合并

int left =i;

int mid =i+gap;

int right=i+2*gap;

if (mid > arr.length){

mid =arr.length;

}

if (right>arr.length){

right=arr.length;

}

merge(arr,left,mid,right);

}

}

System.out.println(Arrays.toString(arr));

}

if (arr[cur1]<=arr[cur2]) {

output[outputIndex++] = arr[cur1++];

}else {

output[outputIndex++] = arr[cur2++];

}

}

while (cur1

output[outputIndex++] = arr[cur1++];

}

while (cur2

output[outputIndex++] = arr[cur2++];

}

for (int i = 0; i < right-left ; i++) {

arr[left+i] = output[i];

}

}

非递归

public static void mergeSortByLoop(int[] arr){

// gap 当前每个组中的元素个数.

for (int gap =1;gap

for (int i = 0; i

//相当于把两个长度为 gap 的相邻组进行了合并

int left =i;

int mid =i+gap;

int right=i+2*gap;

if (mid > arr.length){

mid =arr.length;

}

if (right>arr.length){

right=arr.length;

}

merge(arr,left,mid,right);

}

}

System.out.println(Arrays.toString(arr));

}

output[outputIndex++] = arr[cur1++];

}

while (cur2

output[outputIndex++] = arr[cur2++];

}

for (int i = 0; i < right-left ; i++) {

arr[left+i] = output[i];

}

}

非递归

public static void mergeSortByLoop(int[] arr){

// gap 当前每个组中的元素个数.

for (int gap =1;gap

for (int i = 0; i

//相当于把两个长度为 gap 的相邻组进行了合并

int left =i;

int mid =i+gap;

int right=i+2*gap;

if (mid > arr.length){

mid =arr.length;

}

if (right>arr.length){

right=arr.length;

}

merge(arr,left,mid,right);

}

}

System.out.println(Arrays.toString(arr));

}

output[outputIndex++] = arr[cur2++];

}

for (int i = 0; i < right-left ; i++) {

arr[left+i] = output[i];

}

}

非递归

public static void mergeSortByLoop(int[] arr){

// gap 当前每个组中的元素个数.

for (int gap =1;gap

for (int i = 0; i

//相当于把两个长度为 gap 的相邻组进行了合并

int left =i;

int mid =i+gap;

int right=i+2*gap;

if (mid > arr.length){

mid =arr.length;

}

if (right>arr.length){

right=arr.length;

}

merge(arr,left,mid,right);

}

}

System.out.println(Arrays.toString(arr));

}

for (int i = 0; i

//相当于把两个长度为 gap 的相邻组进行了合并

int left =i;

int mid =i+gap;

int right=i+2*gap;

if (mid > arr.length){

mid =arr.length;

}

if (right>arr.length){

right=arr.length;

}

merge(arr,left,mid,right);

}

}

System.out.println(Arrays.toString(arr));

}

//相当于把两个长度为 gap 的相邻组进行了合并

int left =i;

int mid =i+gap;

int right=i+2*gap;

if (mid > arr.length){

mid =arr.length;

}

if (right>arr.length){

right=arr.length;

}

merge(arr,left,mid,right);

}

}

System.out.println(Arrays.toString(arr));

}

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。