二叉树 经典例题

已于 2024-01-10 22:08:13 修改
阅读量481 收藏 10
点赞数 7
分类专栏： 算法与数据结构 文章标签： 算法 数据结构
于 2023-12-31 16:27:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Algo_x/article/details/135279616
版权

94 中序遍历

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void inorder(TreeNode* root, vector<int>& res) {
        if (!root) return;
        inorder(root->left, res);
        res.push_back(root->val);
        inorder(root->right, res);
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        inorder(root, res);
        return res;
    }
};

104 二叉树的最大深度

左右树的最大深度 + 1

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int maxDepth(TreeNode* root) {
        if (root == nullptr) return 0;
        return max(maxDepth(root->left), maxDepth(root->right)) + 1;
    }
};

111 最小深度

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int minDepth(TreeNode* root) {
        if (root == nullptr) return 0;
        queue<TreeNode*> q;
        q.push(root);
        int depth = 1;

        while (!q.empty()) {
            int sz = q.size();
            for (int i = 0; i < sz; ++i) {
                auto cur = q.front();
                q.pop();
                if (cur->left == nullptr && cur->right == nullptr) return depth;
                if (cur->left != nullptr) q.push(cur->left);
                if (cur->right != nullptr) q.push(cur->right);
            }
            depth++;
        }
        return depth;

    }
};

226 翻转二叉树

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        dfs(root);
        return root;
    }

    void dfs(TreeNode* root) {
        if (!root) return;
        TreeNode* tmp = root->left;
        root->left = root->right;
        root->right = tmp;
        dfs(root->left);
        dfs(root->right);
    }
};

101 对称二叉树

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool check(TreeNode* p1, TreeNode* p2) {
        if (!p1 && !p2) {
            return true;
        }
        if (!p1 || !p2) {
            return false;
        }

        return (p1->val == p2->val) && (check(p1->left, p2->right)) && (check(p1->right, p2->left));
    }
    bool isSymmetric(TreeNode* root) {
        return check(root, root);
    }
};

222 完全二叉树节点数量（从左到右，从上到下依次排满）

复杂度 O(N)

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int count = 0; // 统计节点数
    void inorder(TreeNode* root) {
        if(!root) return;
        inorder(root->left);
        count += 1;
        inorder(root->right);

    }
    int countNodes(TreeNode* root) {
        inorder(root);
        return count;
    }
};

k

2k 2k+1

h层，则最底层最右边元素是2^{h-1}最左边是2^{h}-1

二分

257 二叉树的所有路径

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */

class Solution {
public:
    vector<string> binaryTreePaths(TreeNode* root) {
        // 创建一个存储路径的结果集
        vector<string> result;
        // 开始深度优先搜索
        dfs(root, "", result);
        return result;
    }

    void dfs(TreeNode* node, string path, vector<string>& result) {
        // 如果节点为空，返回
        if (node == nullptr) {
            return;
        }

        // *将当前节点值添加到路径中
        path += to_string(node->val);

        // 如果是叶子节点，将路径添加到结果集中
        if (node->left == nullptr && node->right == nullptr) {
            result.push_back(path);
            return;
        }

        // 如果不是叶子节点，继续深度优先搜索
        path += "->";
        dfs(node->left, path, result);
        dfs(node->right, path, result);
    }
};

404 左叶子之和

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int ans = 0;

    int sumOfLeftLeaves(TreeNode* root) {
        dfs(root);
        return ans;
    }

    void dfs(TreeNode* r) {
        if (r == nullptr) return;
        // 是左节点且是叶子节点
        if (r->left != nullptr && r->left->left == nullptr && r->left->right == nullptr) {
            ans += r->left->val;
        }
        dfs(r->left);
        dfs(r->right);
    }
};

100 相同的树

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool isSameTree(TreeNode* p, TreeNode* q) {
        return dfs(p, q);
    }

    bool dfs(TreeNode* r1, TreeNode* r2) {
        if (r1 == nullptr || r2 == nullptr) return r1 == r2;
        if (r1->val != r2->val) return false;
        return dfs(r1->left, r2->left) && dfs(r1->right, r2->right);
    }
};

513 树最左下角的值

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int findBottomLeftValue(TreeNode* root) {
        // 更新每一层的第一个节点即可
        queue<TreeNode*> q;
        q.push(root);   
        int res = root->val;

        while (!q.empty()) {
            int cs = q.size();
            for (int i = 0; i < cs; ++i) {
                auto node = q.front();
                q.pop();
                if (i == 0) res = node->val;
                if (node->left) q.push(node->left);
                if (node->right) q.push(node->right);
            }
        }
        return res;
    }
};

543 二叉树的直径

class Solution {
    int ans;
    int depth(TreeNode* rt){
        if (rt == NULL) {
            return 0; // 访问到空节点了，返回0
        }
        int L = depth(rt->left); // 左儿子为根的子树的深度（即节点数）
        int R = depth(rt->right); // 右儿子为根的子树的深度
        ans = max(ans, L + R + 1); // 计算d_node即L+R+1 并更新ans
        return max(L, R) + 1; // 返回该节点为根的子树的深度
    }
public:
    int diameterOfBinaryTree(TreeNode* root) {
        ans = 1;
        depth(root);
        return ans - 1;
    }
};

102 二叉树的层序遍历

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;

        if (!root) {
            return res;
        }

        queue<TreeNode*> q;
        q.push(root);

        while(!q.empty()) {
            res.push_back(vector<int>());
            int currSize = q.size();

            for (int i = 1; i <= currSize; ++i) {
                auto node = q.front();
                q.pop();
                // 注意
                res.back().push_back(node->val);
                if (node->left) q.push(node->left);
                if (node->right) q.push(node->right);
            }

        }
        return res;

    }
};

110 平衡二叉树

任意节点左右子树高度差<=1

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int height(TreeNode* root) {
        if (root == NULL) {
            return 0;
        }else {
            return max(height(root->left), height(root->right)) + 1;
        }
    }
    bool isBalanced(TreeNode* root) {
        if (root == NULL) {
            return true;
        } else {
            return abs(height(root->left) - height(root->right)) <= 1 && isBalanced(root->left) && isBalanced(root->right);
        }
    }
};
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool isBalanced(TreeNode* root) {
        dfs(root);
        return res;
    }

    bool res = true;
    int dfs(TreeNode* node) {
        if (node == nullptr) return 0;
        int l = dfs(node->left), r = dfs(node->right);
        if (abs(r - l) > 1) res = false;
        return std::max(l, r) + 1;
    }
};

230 二叉搜索树中第 k 小的元素

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int kthSmallest(TreeNode* root, int k) {
        stack<TreeNode*> stack;
        while (root != nullptr || stack.size() > 0) {
            // 先找小的
            while (root != nullptr) {
                stack.push(root);
                root = root->left;
            }

            root = stack.top();
            stack.pop();
            if (--k == 0) break;
            root = root->right;
        }
        return root->val;
    }
};

建树

后序最后一个节点是根节点-->确定左子树和右子树

106 中序 + 后序遍历构建二叉树

# Definition for a binary tree node.


class Solution:
    def buildTree(self, inorder, postorder):
        # 使用哈希表存储中序遍历数组的值和对应的索引
        map = {val: idx for idx, val in enumerate(inorder)}
        # 开始递归构建树
        return self.dfs(0, len(inorder) - 1, 0, len(postorder) - 1, inorder, postorder, map)

    def dfs(self, in_left, in_right, post_left, post_right, inorder, postorder, map):
        # 如果中序遍历的左边界大于右边界，返回空节点
        if in_left > in_right:
            return None

        # 创建根节点，值为后序遍历的最后一个元素
        node = TreeNode(postorder[post_right])
        # 获取根节点在中序遍历中的索引
        in_index = map[postorder[post_right]]
        # 计算左子树节点个数
        left_cnt = in_index - in_left
        # 递归构建左右子树
        node.left = self.dfs(in_left, in_index - 1, post_left, post_left + left_cnt - 1, inorder, postorder, map)
        node.right = self.dfs(in_index + 1, in_right, post_left + left_cnt, post_right - 1, inorder, postorder, map)
        # 返回根节点
        return node

大法师安东尼ds
关注
  • 7
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树的几道典型例题
chenkaixin_1024的博客
05-02 3104
1.求二叉树的高度 int _GetTreeHight(Node* pRoot) { if(pRoot==NULL) return 0; if(pRoot->_pLeft==NULL&&pRoot->_pRight==NULL) return 1; int left=_GetTreeHight(pRoot->_pLeft)+1; int right=_GetTr
二叉树常见题目
清崎教练
08-05 363
“从0开始做LeetCode”之二叉树常见题目   1.实现二叉树的先序、中序、后序遍历，包括递归方式和非递归方式 打印时机——>先序，中序，后序 2.用数组结构实现大小固定的队列和栈 3.实现一个特殊的栈，在实现栈的基本功能的基础上，再实现返回栈中最小元素的操作 时间复杂度：O(1)，可以使用线程的栈结构 两个栈：同步进，同步弹 4. 如何仅用队列结构实现栈结构？如何仅用栈结构实现队列结构？ 两个队列 两个栈：倒数据 5. 猫狗队列 6. 转圈打印矩阵 额外空间复杂度：O(1) 宏观
二叉树的经典例题—数据结构
m0_61963422的博客
11-09 3349
二叉树
关于二叉树的几个经典例题详解
热门推荐
Mr_fengzi的博客
07-13 1万+
1.某二叉树的前序序列和后序序列正好相反，则该二叉树一定是( )的二叉树。 A.空或只有一个结点 B.高度等于其结点数 C.任一结点无左孩子 D.任一结点无右孩子 正确答案：B 详解： 一棵具有N个结点的二叉树的前序序列和后序序列正好相反，则该二叉树一定满足该二叉树只有左子树或只有右子树，即该二叉树一定是一条链（二叉树的高度为N，高度等于结点数）。 ...
常见二叉树及例题汇总
kyle的博客
05-29 4033
常见二叉树及例题汇总（更新中）
二叉树的基本概念与例题(一学就会)
Jiguoyuanyic的博客
07-08 657
今天我们来讲一下二叉树的概念和例题
【数据结构】二叉树经典题目
qq_63474430的博客
06-14 1023
二叉树创建字符串、二叉树的层序遍历、二叉树的最近公共祖先、二叉搜索树与双向链表、前序与中序构造二叉树、二叉树的三种非递归遍历方法
C语言经典例题100
12-31
《C语言经典例题100》是一份包含100个精心挑选的C语言编程题目，旨在帮助学习者深入理解和掌握C语言的关键概念、算法和常见编程技巧。这些题目覆盖了C语言的基础到进阶内容，对于初学者来说是巩固基础知识的好资料，...
几个值得研究的c语言经典例题
05-18
根据给定的信息，我们可以分析并总结出几个C语言的经典例题及其相关知识点： ### 例题一：寻找矩阵中的鞍点 #### 题目描述： 编写一个程序，输入一个3×3的整数矩阵，然后找出该矩阵中的鞍点（如果存在）。鞍点是...
数据结构1800题 经典例题
05-12
本资源"数据结构1800题 经典例题"提供了大量的练习题目，旨在帮助初学者掌握C语言实现数据结构的基本技巧和算法。下面我们将深入探讨其中涉及的主要知识点。 1. **线性数据结构**： - **数组**：是最基本的数据...
数据结构经典例题程序
01-22
本资源“数据结构经典例题程序”集合了数据结构领域的一些典型问题和解决方案，对于学习和理解数据结构有极大的帮助。下面我们将深入探讨其中涉及的一些关键知识点。 1. **数组**：数组是最基础的数据结构，它是一...
【数据结构】二叉树经典例题---＜你真的掌握二叉树了吗？＞(第一弹)
2302_76305195的博客
11-11 1936
中序< EFGH>和后序< FHGE >可以得知，< FGH>为E的右子树，然后根据后序 可以得之，G为结点。前序遍历(根左右): a->b->d->g->e->c->f->h。中序遍历(左根右): d->g->b->e->a->f->h->c。后序遍历(左右根): g->d->e->b->h->f->c->a。(6)中序线索化： d->g->b->e->a->f->h->c。前序线索化: a->b->d->g->e->c->f->h。G为子树的结点，根据中序可以得知，F为左结点，H为右结点。
【数据结构】二叉树经典例题---＜你真的掌握二叉树了吗?＞(第二弹)
2302_76305195的博客
11-14 3060
根据后序遍历，我们可以得之，这棵树的根节点为E，根据根节点E，从中序遍历结果中即可看出，左子树的所有结点为ABCD，右子树的所有结点为FG。因此树只有根结点，或者根结点只有左子树或右子树，依此类推，其子树有同样的性质，任意结点只能有一个孩子，才能满足先序序列和后序序列正好相反。20.将一颗有100个结点的完全二叉树从根这一层开始，每一层上从左到右一次对结点进行编号，根节点的编号为1，则编号为49的结点的左孩子的编号为()第6层的结点从64开始，63+17*2=97，则编号为49的结点的左孩子的编号为98。
【数据结构】二叉树经典习题
weixin_61932507的博客
04-17 3404
【数据结构】二叉树经典习题
LeetCode和牛客网二叉树经典例题合集
m0_70811813的博客
01-20 1083
本期博客给大家带来了九道二叉树经典例题：单值二叉树、相同的树、 二叉树的最大深度、另一课树的子树、二叉树的前序构建、二叉树的前序遍历、对称二叉树、翻转二叉树、平衡二叉树
二叉树经典的选择题（带你轻松理解）
weixin_72040293的博客
04-03 2506
讲解二叉树常见的三种选择题题型
Codeup——611 | 问题 D: 二叉树遍历
qq_44888152的博客
10-12 515
题目描述 编一个程序，读入用户输入的一串先序遍历字符串，根据此字符串建立一个二叉树（以指针方式存储）。 例如如下的先序遍历字符串： ABC##DE#G##F### 其中“#”表示的是空格，空格字符代表空树。建立起此二叉树以后，再对二叉树进行中序遍历，输出遍历结果。 输入 输入包括1行字符串，长度不超过100。 输出 可能有多组测试数据，对于每组数据， 输出将输入字符串建立二叉树后中序遍历的序列，每个字符后面都有一个空格。 每个输出结果占一行。 样例输入 a#b#cdef##### a## 样例输出 a b
数据结构：二叉树经典例题（单选题）--＞你真的掌握二叉树了吗？（第一弹）
Yikefore的博客
06-23 2225
关于二叉树的基本经典单选例题，对二叉树性质的巩固，相信你做完这些例题就可以对二叉树轻松拿捏（第一弹）你也快来试试吧！
二叉树经典题题解（超全题目）（力扣）
最新发布
2301_79293429的博客
02-05 1854
二叉树超全题目
c++数据结构经典例题名家代码
07-03
### 回答1： "数据结构经典例题名家代码"是一本经典的数据结构教材，其中包含了许多著名数据结构例题和相关的代码实现。 书中介绍了各种常见的数据结构，如线性结构（数组、链表、栈、队列）、树结构（二叉树、堆、哈夫曼树）、图结构（邻接矩阵、邻接表）等。每个数据结构都有详细的介绍和示例代码，可以帮助读者理解和掌握这些数据结构的基本原理和操作。 除了介绍数据结构的基本知识之外，书中还包含了许多算法和问题的实际应用。比如，如何使用数据结构解决迷宫问题、查找算法、排序算法等。这些例题和代码展示了数据结构在实际问题中的应用和灵活性，有助于读者培养解决问题的思维方式和能力。 作者通过清晰的讲解和简洁的代码示例，使得读者可以更好地理解和掌握数据结构的基本原理和使用方法。书中还附带了一些习题和答案，供读者巩固知识和提升编程能力。 综上所述，"数据结构经典例题名家代码"是一本非常适合学习和了解数据结构的经典教材，它通过丰富的例题和相关代码，帮助读者深入理解和掌握数据结构的概念和应用。无论是初学者还是有一定基础的人员，都可以从中受益。 ### 回答2： 经典例题名家代码之一是二叉树的遍历问题。二叉树是一种重要的数据结构，其遍历方式有三种：前序遍历、中序遍历和后序遍历。 前序遍历就是按照“根左右”的顺序访问二叉树的节点。中序遍历按照“左根右”的顺序进行访问，而后序遍历则是按照“左右根”的顺序进行访问。 以前序遍历为例，我们可以使用递归方法来实现。首先遍历根节点，然后递归地遍历左子树，最后递归地遍历右子树。这种递归思想可以通过以下代码实现： ```python class Node: def __init__(self, data): self.data = data self.left = None self.right = None def preorder_traversal(root): if root: print(root.data) preorder_traversal(root.left) preorder_traversal(root.right) # 示例二叉树 # 1 # / \ # 2 3 # / \ \ # 4 5 6 root = Node(1) root.left = Node(2) root.right = Node(3) root.left.left = Node(4) root.left.right = Node(5) root.right.right = Node(6) preorder_traversal(root) # 输出: 1 2 4 5 3 6 ``` 以上代码通过定义一个`Node`类来构造二叉树，并使用递归函数`preorder_traversal()`来进行前序遍历。输出结果为`1 2 4 5 3 6`，表示了二叉树的先序遍历结果。 通过这个经典的例题和代码，我们可以理解并掌握二叉树的遍历方式，深入理解数据结构的基本原理和常见操作。这些都是学习和理解数据结构的重要一步。 ### 回答3： 经典例题名家代码中，常见的一个例子是快速排序算法。快速排序算法是一种高效的排序算法，其核心思想是通过将待排序的序列划分为较小和较大的两个子序列，然后递归地对这两个子序列进行排序，最终实现整个序列的有序。 快速排序算法的名家代码主要体现在该算法的划分过程和递归思想上。其中，划分过程的关键是选择一个基准元素，并通过交换元素的位置，将小于基准元素的元素移到基准元素的左边，将大于基准元素的元素移到基准元素的右边。而递归思想则是对划分后的子序列进行递归调用，直到子序列只有一个元素或为空。 以下是一种经典的快速排序算法的代码示例： ``` void quickSort(int[] arr, int left, int right) { if (left < right) { int pivotIndex = partition(arr, left, right); // 获取基准元素的位置 quickSort(arr, left, pivotIndex - 1); // 对基准元素左边的子序列进行排序 quickSort(arr, pivotIndex + 1, right); // 对基准元素右边的子序列进行排序 } } int partition(int[] arr, int left, int right) { int pivot = arr[left]; // 选择第一个元素作为基准元素 int i = left, j = right; while (i < j) { while (i < j && arr[j] >= pivot) { j--; } if (i < j) { arr[i++] = arr[j]; } while (i < j && arr[i] <= pivot) { i++; } if (i < j) { arr[j--] = arr[i]; } } arr[i] = pivot; return i; } ``` 以上是一个典型的快速排序算法的代码实现，通过划分和递归的方式，能够高效地对一个序列进行排序。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值