vue3源码中的最长递增子序列

最新推荐文章于 2024-04-04 22:27:23 发布

yusirxiaer

最新推荐文章于 2024-04-04 22:27:23 发布

阅读量639

点赞数 1

分类专栏： Vue3.X 文章标签：贪心算法算法动态规划最长递增子序列

本文链接：https://blog.csdn.net/yusirxiaer/article/details/122017465

版权

Vue3.X 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

求解最长递增子序列是一道经典的算法题,

多数解法是使用动态规划的思想，算法的时间复杂度是O( $n^2$ );

而Vue.js内部使用的是维基百科提供的一套“贪心+二分查找”的算法;

贪心算法的时间复杂度是O(n)，二分查找的时间复杂度是O(logn)，总时间复杂度是O(nlogn)

主要思路：

对数组遍历，依次求解长度为i时的最长递增子序列

当i元素大于i-1的元素时，添加i元素并更新最长子序列

否则往前查找直到找到一个比i小的元素，然后插在该元素后面并更新对应的最长递增子序列

主要目的:

让递增序列的差尽可能的小，从而可以获得更长的递增子序列，是一种贪心算法的思想

源码

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Document</title>
  </head>
  <body>
    <script>
      function getSequence(arr) {
        const p = arr.slice();
        const result = [0]; // 存储长度为I的递增子序列的索引
        let i, j, u, v, c;
        const len = arr.length;
        debugger;
        for (i = 0; i < len; i++) {
          const arrI = arr[i];
          if (arrI !== 0) {
            j = result[result.length - 1];
            // result存的最后一个值小于当前值
            if (arr[j] < arrI) {
              // 存储在result更新前的最后一个索引的值
              p[i] = j;
              result.push(i);
              continue;
            }
            u = 0;
            v = result.length - 1;
            // 二分搜索，查找比arrI小的节点，更新result的值
            while (u < v) {
              c = (u + v) >> 1;
              if (arr[result[c]] < arrI) {
                u = c + 1;
              } else {
                v = c;
              }
            }
            if (arrI < arr[result[u]]) {
              if (u > 0) {
                p[i] = result[u - 1];
              }
              result[u] = i;
            }
          }
        }
        u = result.length;
        v = result[u - 1];
        // 回溯数组p，找到最终的索引
        while (u-- > 0) {
          result[u] = v;
          v = p[v];
        }
        return result;
      }

      const arr = [2, 1, 5, 3, 6, 4, 8, 9, 7];
      const resultIndex = getSequence(arr);
      console.log("最长递增子序列的索引是：", resultIndex);
      let result = [];
      resultIndex.forEach((item, index) => {
        result.push(arr[item]);
      });
      console.log("最长递增子序列：", result);
    </script>
  </body>
</html>

yusirxiaer

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
0
评论
vue3源码中的最长递增子序列

求解最长递增子序列是一道经典的算法题,多数解法是使用动态规划的思想，算法的时间复杂度是O();而Vue.js内部使用的是维基百科提供的一套“贪心+二分查找”的算法;贪心算法的时间复杂度是O(n)，二分查找的时间复杂度是O(logn)，总时间复杂度是O(nlogn)主要思路：对数组遍历，依次求解长度为i时的最长递增子序列当i元素大于i-1的元素时，添加i元素并更新最长子序列否则往前查找直到找到一个比i小的元素，然后插在该元素后面并更新对应的最长递增子序列主要目的:让递增序.
复制链接

扫一扫