2 认识O(NlogN) 的排序

Diligent programmer

已于 2024-02-27 21:59:52 修改

阅读量938

点赞数 20

分类专栏：数据结构与算法文章标签：数据结构算法 java 排序算法

于 2024-02-20 21:49:44 首次发布

本文链接：https://blog.csdn.net/Fly_beautifully/article/details/135603155

版权

数据结构与算法专栏收录该内容

3 篇文章 0 订阅

订阅专栏

5.3 堆结构的heapInsert与heapify操作

1 归并排序

整体就是一个简单递归，左边排好序、右边排好序、让其整体有序，让其整体有序的过程里用了外排序方法。

将原始数组Arr[0:n-1]中的元素分成两个大小大致相同的子数组：Arr[0:n/2]和Arr[n/2+1:n-1]，分别对这两个子数组单独排序，然后将已排序的两个数组归并成一个含有n个元素的有序数组。（不断地进行二分，直至待排序数组中只剩下一个元素为止，然后不断合并两个排好序的数组段）

代码实现如下：

public static void mergeSort(int[] arr) {
   if (arr == null || arr.length < 2) {
      return;
   }
   mergeSort(arr, 0, arr.length - 1);
}

public static void process(int[] arr, int l, int r) { // 递归过程
   if (l == r) {
      return;
   }
   int mid = l + ((r - l) >> 1);
   process(arr, l, mid);
   process(arr, mid + 1, r);
   merge(arr, l, mid, r);
}

public static void merge(int[] arr, int l, int m, int r) {
   int[] help = new int[r - l + 1];
   int i = 0;
   int p1 = l;
   int p2 = m + 1;
   while (p1 <= m && p2 <= r) {
      help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
   }
   while (p1 <= m) {
      help[i++] = arr[p1++];
   }  // 其实下面这两个while 只会中一个
   while (p2 <= r) {
      help[i++] = arr[p2++];
   }
   for (i = 0; i < help.length; i++) {
      arr[l + i] = help[i];  // 拷贝回原数组
   }
}

利用master公式来求解时间复杂度

T(N) = a*T(N/b) + O( $N^{d}$ )

a = 2
b = 2
d = 1

1） $log_{b}a$ < d =>时间复杂度为O( $N^{d}$ )

2） $log_{b}a$ > d =>时间复杂度为O( $N^{log_{b}a}$ )

3） $log_{b}a$ = d =>时间复杂度为O( $N^{d}*logN$ )

所以归并排序的时间复杂度 = O(NlogN)

额外空间复杂度O(N)

归并排序的实质

简单选择、冒泡、插入排，时间复杂度都是O( $N^{2}$ ) ，因为它们都浪费了大量的比较行为，每一

轮的比较都是独立的，每一次遍历只能搞定一个数。

而归并排序就没有浪费比较行为，每一次merge 归并，其实都将有序信息传递下去了。

2 归并排序的扩展

2.1 小和问题

在一个数组中，每一个数左边比当前数小的数累加起来，叫做这个数组的小和。求一个数组的小

和。

例子: [1,3,4,2,5]

1左边比1小的数，没有;
3左边比3小的数，1;
4左边比4小的数，1、3;
2左边比2小的数，1;
5左边比5小的数，1、3、4、2;

所以小和为1+1+3+1+1+3+4+2=16

思路：遍历数组，每个数右边有多少个数比它大，那就产生对应个数的该数的小和

在merge 过程中，求有多少个数比这个数大的过程，是分批的，不重不漏的，依次找到

public static int smallSum(int[] arr) {
   if (arr == null || arr.length < 2) {
      return 0;
   }
   return mergeSort(arr, 0, arr.length - 1);
}

// arr[L..R]既要排好序，也要求小和
public static int process(int[] arr, int l, int r) {
   if (l == r) {
      return 0;
   }
   int mid = l + ((r - l) >> 1);
   return process(arr, l, mid)         //左侧排好序并且求小和的数量
         + process(arr, mid + 1, r)    //右侧排好序，求小和的数量
         + merge(arr, l, mid, r);      //左侧排好右侧排好，merge的时候小和的数量
}

public static int merge(int[] arr, int l, int m, int r) {
   int[] help = new int[r - l + 1];
   int i = 0;
   int p1 = l;
   int p2 = m + 1;
   int res = 0;
   while (p1 <= m && p2 <= r) {
      res += arr[p1] < arr[p2] ? (r - p2 + 1) * arr[p1] : 0;
      help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
   }
   while (p1 <= m) {
      help[i++] = arr[p1++];
   }
   while (p2 <= r) {
      help[i++] = arr[p2++];
   }
   for (i = 0; i < help.length; i++) {
      arr[l + i] = help[i];
   }
   return res;
}

归并过程中，两边相等的情况下，一定先拷贝右边，当左边的数严格小于右边的数，才计算

小和。如果先拷贝左边，就不能很快的知道右边多少个数比它大。

这是和我们经典merge 不同的地方，经典merge我们只管合并就行，就没有这个顾虑。

2.2 逆序对问题

在一个数组中，左边的数如果比右边的数大，则这两个数构成一个逆序对，请打印所有逆序对。

例子：[3,2,4,5,0]

对于3来说，有（3,2），（3,0）
对于2来说，有（2,0）
对于4来说，有（4,0）
对于5来说，有（5,0）

就是在merge 归并的过程中，求右边有多少个数比左边的小。

这种由mergeSort 改写的题，每年必出。

3 荷兰国旗问题

3.1 问题一

给定一个数组arr，和一个数num，请把小于等于num的数放在数组的左边，大于num的数放在数

组的右边。要求额外空间复杂度O(1)，时间复杂度O(N)

这里并不要求num两边有序

[i] <= num，[i] 和 <= 区域的下一个数交换，<= 区域右扩，i++
[i] > num, i ++

3.2 问题二（严格分三块）

给定一个数组arr，和一个数num，请把小于num的数放在数组的左边，等于num的数放在数组的

中间，大于num的数放在数组的右边。要求额外空间复杂度O(1)，时间复杂度 O(N)

[i] < num，[i] 和 < 区域下一个交换，< 区域右扩，i++
[i] = num, i ++
[i] > num，[i] 和 > 区域的前一个交换，> 区域左扩，i 不变

代码实现如下：

public static int[] partition(int[] arr, int l, int r, int p) {
   int less = l - 1;
   int more = r + 1;
   while (l < more) {
      if (arr[l] < p) {
         swap(arr, ++less, l++);
      } else if (arr[l] > p) {
         swap(arr, --more, l);
      } else {
         l++;
      }
   }
   return new int[] { less + 1, more - 1 };
}

// for test
public static void swap(int[] arr, int i, int j) {
   int tmp = arr[i];
   arr[i] = arr[j];
   arr[j] = tmp;
}

4 快速排序

4.1 快排1.0版本

用数组的最后一个数做划分值num，让前面的一截划分成荷兰国旗问题1
用num 和> 区域的第一个数做交换
然后让左侧和右侧重复这个行为

4.2 快排2.0版本

本质是利用荷兰国旗问题，问题二

用数组的最后一个数做划分值num，让前面的一截划分成荷兰国旗问题2
用num 和大于区域的第一个数交换
然后让小于num 和大于 num 的区域重复递归

一次搞定一批数，比1.0 版本快一些。但是这两个版本最坏情况下时间复杂度都是O( $N^{2}$ )

分析

1）划分值越靠近两侧，复杂度越高；划分值越靠近中间，复杂度越低

2）可以轻而易举的举出最差的例子，所以不改进的快速排序时间复杂度为O(N^2)

4.3 快排3.0版本

1）在数组范围中，等概率随机选一个数作为划分值，然后把数组通过荷兰国旗问题分成三个部

分：

左侧<划分值、中间==划分值、右侧>划分值

2）对左侧范围和右侧范围，递归执行

3）时间复杂度为O(N*logN)

划分值打到中点，如果打偏，越往两边，就会逐渐 O ( $N^{2}$ )

3.0 版本随机从数组中选出一个数，与数组最后一个数做交换后作为划分值，这样就成了一个概率事件。

概率累加后，求最终的长期期望 → 得到快排3.0 的时间复杂度就是 O(NlogN)

代码实现如下：

public static void quickSort(int[] arr) {
   if (arr == null || arr.length < 2) {
      return;
   }
   quickSort(arr, 0, arr.length - 1);
}

public static void quickSort(int[] arr, int l, int r) {
   if (l < r) {
      swap(arr, l + (int) (Math.random() * (r - l + 1)), r);
      int[] p = partition(arr, l, r);//=区域的左右边界
      quickSort(arr, l, p[0] - 1); // < 区域
      quickSort(arr, p[1] + 1, r); // > 区域
   }
}
//默认以arr[r]做划分，arr[r]->p   <p  ==p  >p
//返回等于区域（左边界，右边界），所以返回一个长度为2的数组res,res[0] res[1]
public static int[] partition(int[] arr, int l, int r) {
   int less = l - 1;// <区有=右边界
   int more = r; // >区左边界
   while (l < more) {  // L表示当前数的位置
      if (arr[l] < arr[r]) { // 当前数 < 划分值
         swap(arr, ++less, l++);
      } else if (arr[l] > arr[r]) { // 当前数 > 划分值
         swap(arr, --more, l);
      } else { // 当前数 = 划分值
         l++;
      }
   }
   swap(arr, more, r);
   return new int[] { less + 1, more };
}

public static void swap(int[] arr, int i, int j) {
   int tmp = arr[i];
   arr[i] = arr[j];
   arr[j] = tmp;
}

快排的空间复杂度

快速排序的空间复杂度是O( log N )。

这是因为快速排序是一种原地排序算法，它不需要额外的空间来存储数据。快速排序通过交换数组

中的元素来进行排序，而不是创建新的数组。快速排序的空间复杂度主要来自于递归调用栈所占

用的空间。在最坏情况下，即每次划分都只能将序列分成一个元素和 n-1 个元素两部分，此时递

归树的深度为 n，空间复杂度为 O(n)。但是在平均情况下，每次划分能够将序列分成大小相等的

两部分，此时递归树的深度为 O(log n)，空间复杂度也就是 O(log n)。

5 堆

堆结构就是用数组实现的完全二叉树结构

数组上从下标0 开始的连续一段对应完全二叉树的关系

i 的左子树→ 2 * i + 1 （超出就越界）
i 的右子树 → 2 * i + 2
i 的根节点 → (i - 1) / 2

5.1 大根堆

完全二叉树中如果每棵子树的最大值都在顶部就是大根堆

5.2 小根堆

完全二叉树中如果每棵子树的最小值都在顶部就是小根堆

5.3 堆结构的heapInsert与heapify操作

堆结构最重要的两个操作

heapInsert

和父位置的数比大小，大于就和父位置上的数做交换，等于或小于就停在原地，这样就能保证始终

是个大根堆。

heapInsert函数代码实现如下：

//某个数现在处在index位置，往上继续移动
public static void heapInsert(int[] arr, int index) {
	while (arr[index] > arr[(index - 1) / 2]) {
		swap(arr, index, (index - 1) /2);
		index = (index - 1)/2 ;
	}
}

heapify（堆化）

heapify函数代码实现如下：

//某个数在index位置，能否往下移动
public static void heapify(int[] arr, int index, int size) {
    int left = index * 2 + 1; //左子树的下标
    while (left < size) {//下方还有子树的时候

       //两个子树中，谁的值大，把下标给largest
       int largest = left + 1 < size && arr[left + 1] > arr[left] ? left + 1 : left;

       //父和较大的子树之间，谁的值大，把下标给largest
       largest = arr[largest] > arr[index] ? largest : index;
       if (largest == index) {
          break;
       }
       swap(arr, largest, index);
       index = largest;
       left = index * 2 + 1;
    }
}

5.4 堆结构的增大和减少

比如用户让我往现有堆里，加一个数字，O(logN) 的调整代价。

5.5 优先级队列结构，就是堆结构

堆顶就是优先级最大的。

6 堆排序

1）先让整个数组都变成大根堆结构，建立堆的过程

从上到下的方法，时间复杂度为O(N*logN)
从下到上的方法，时间复杂度为O(N)

2）把堆的最大值和堆末尾的值交换，然后减少堆的大小之后，再去调整堆，一直周而复始，时间

复杂度为O(N*logN)

3）堆的大小减小成0之后，排序完成

堆排序代码实现如下：

 public static void heapSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
//        //从上到下的方法，时间复杂度为O(N*logN)
//        for (int i = 0; i < arr.length; i++) {//O(N)
//            heapInsert(arr, i);//O(logN)
//        }

        //从下到上的方法，时间复杂度为O(N)
        for(int i=arr.length-1;i>0;i--){//O(N)
            heapify(arr,i, arr.length);//O(1)
        }

        int heapSize = arr.length;
        swap(arr, 0, --heapSize);
        while (heapSize > 0) {//O(N)
            heapify(arr, 0, heapSize);//O(logN)
            swap(arr, 0, --heapSize);//O(1)
        }
}

补充：堆结构比堆排序重要

7 堆排序扩展题目

已知一个几乎有序的数组，几乎有序是指，如果把数组排好顺序的话，每个元素移动的距离可以

不超过k，并且k相对于数组来说比较小。请选择一个合适的排序算法针对这个数据进行排序。

java代码实现如下：

public void sortedArrDistanceLessK(int[] arr, int k) {
    
   // 默认小根堆
   PriorityQueue<Integer> heap = new PriorityQueue<>();
   int index = 0;
   for (; index < Math.min(arr.length, k); index++) {
      heap.add(arr[index]);
   }
   int i = 0;
   for (; index < arr.length; i++, index++) {
      heap.add(arr[index]);
      arr[i] = heap.poll();
   }
   while (!heap.isEmpty()) {
      arr[i++] = heap.poll();
   }
}

Diligent programmer

关注

20
点赞
踩
18

收藏

觉得还不错? 一键收藏
打赏
0
评论
2 认识O(NlogN) 的排序

简单选择、冒泡、插入排，时间复杂度都是O(N^{2}) ，之所以它们差，因为它们都浪费了大量的比较行为，每一轮的比较都是独立的，几乎过了N 次，才知道了某一个数应该放在初位置。而归并排序就没有浪费比较行为，每一次merge 归并，其实都将有序信息传递下去了。时间复杂度O(N*logN)，额外空间复杂度O(N)
复制链接

扫一扫