数据结构与算法——二分查找与二叉排序树

最新推荐文章于 2022-05-17 00:32:41 发布
最新推荐文章于 2022-05-17 00:32:41 发布
阅读量318 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxr916/article/details/115958547
版权

文章目录

1.预备知识

1.1 题目目录

在这里插入图片描述

1.2 二分查找

在这里插入图片描述
在这里插入图片描述在这里插入图片描述

1.3 递归二分查找
bool binary_search(vector<int>& sort_array, int begin, int end, int target) {
    if (begin>end) {
        return false;
    }

    int mid = (begin + end) / 2;
    
    if (target == sort_array[mid]) {
        return true;
    }
    else if (target < sort_array[mid]) {
        binary_search(sort_array, begin, mid - 1, target);
    }
    else if (target > sort_array[mid]) {
        binary_search(sort_array, mid + 1, end, target);
    }
}
1.4 循环二分查找
bool binary_search(vector<int>& sort_array, int target) {
    int begin = 0;
    int end = sort_array.size() - 1;

    while (begin<=end) {
        int mid = (begin + end) / 2;
        if (target == sort_array[mid]) {
            return true;
        }
        else if(target < sort_array[mid]) {
            end = mid - 1;
        }
        else if (target > sort_array[mid]) {
            begin = mid + 1;
        }
    }

    return false;
}
1.5 二叉查找（排序）树

在这里插入图片描述
在这里插入图片描述

1.6 二叉搜索树的代码实现

1.二叉搜索树的插入

void solution::BST_insert(TreeNode* node, TreeNode* insert_node) {
	if (insert_node->val < node->val) {
		if (node->left) {
			BST_insert(node->left, insert_node);
		}
		else {
			node->left = insert_node;
		}
	}
	else {
		if (node->right) {
			BST_insert(node->right, insert_node);
		}
		else {
			node->right = insert_node;
		}
	}
}

2.二叉搜索树的搜索

bool solution::BST_search(TreeNode* node, int value) {
	if (value == node->val) {
		return true;
	}
	else if (value < node->val) {
		if (node->left) {
			BST_search(node->left, value);
		}
		else {
			return false;
		}
	}
	else if (value > node->val) {
		if (node->right) {
			BST_search(node->right, value);
		}
		else {
			return false;
		}
	}
}

2.搜索插入位置

2.1 题目描述

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

你可以假设数组中无重复元素。

2.2 C++代码实现
class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
        int begin=0;
        int end=nums.size()-1;
        int index=-1;

        while(index==-1){
            int mid=(begin+end)/2;

            if(target==nums[mid]){
                index=mid;
            }
            else if(target<nums[mid]){
                if(mid==0||target>nums[mid-1]){
                    index=mid;
                }
                end=mid-1;
            }
            else if(target>nums[mid]){
                if(mid==nums.size()-1||target<nums[mid+1]){
                    index= mid+1;
                }
                begin=mid+1;
            }
        }
        return index;
    }
};

3.区间查找

3.1 题目描述

给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。

如果数组中不存在目标值 target，返回 [-1, -1]。

3.2 算法思路

在这里插入图片描述在这里插入图片描述

3.3 C++代码实现
class Solution {
public:
    int left_bound(vector<int>& nums,int target){
        int begin=0;
        int end=nums.size()-1;

        while(begin<=end){
            int mid=(begin+end)/2;
            if(target==nums[mid]){
                if(mid==0||target>nums[mid-1]){
                    return mid;
                }
                end=mid-1;
            }
            else if(target<nums[mid]){
                end=mid-1;
            }
            else if(target>nums[mid]){
                begin=mid+1;
            }
        }
        return -1;

    }
        int right_bound(vector<int>& nums,int target){
        int begin=0;
        int end=nums.size()-1;

        while(begin<=end){
            int mid=(begin+end)/2;
            if(target==nums[mid]){
                if(mid==nums.size()-1||target<nums[mid+1]){
                    return mid;
                }
                begin=mid+1;
            }
            else if(target<nums[mid]){
                end=mid-1;
            }
            else if(target>nums[mid]){
                begin=mid+1;
            }
        }
        return -1;

    }
    vector<int> searchRange(vector<int>& nums, int target) {
        int left=left_bound(nums,target);
        int right=right_bound(nums,target);

        vector<int> result;
        result.push_back(left);
        result.push_back(right);
        return result;
    }
};

4.旋转数组查找

4.1 题目描述

整数数组 nums 按升序排列，数组中的值 互不相同 。

在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转，使数组变为 [nums[k], nums[k+1], …, nums[n-1], nums[0], nums[1], …, nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。

给你 旋转后 的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1 。

4.2 解题思路

在这里插入图片描述
在这里插入图片描述

4.3 C++代码实现
class Solution {
public:
    int search(vector<int>& nums, int target) {
        int begin=0;
        int end=nums.size()-1;

        while(begin<=end){
            int mid=(begin+end)/2;
            if(target==nums[mid]){
                return mid;
            }
            else if(target<nums[mid]){
                if(nums[begin]<nums[mid]){
                    if(target>=nums[begin]){
                        end=mid-1;
                    }
                    else{
                        begin=mid+1;
                    }
                }
                else if(nums[begin]>nums[mid]){
                    end=mid-1;
                }
                else if(nums[begin]==nums[mid]){
                    begin=mid+1;
                }
            }
            else if(target>nums[mid]){
                if(nums[begin]<nums[mid]){
                    begin=mid+1;
                }
                else if(nums[begin]>nums[mid]){
                    if(target>=nums[begin]){
                        end=mid-1;
                    }
                    else{
                        begin=mid+1;
                    }
                }
                else if(nums[begin]==nums[mid]){
                    begin=mid+1;
                }
            }
        }
        return -1;
    }
};

5.序列化和反序列化二叉搜索树

5.1 题目描述

序列化是将数据结构或对象转换为一系列位的过程，以便它可以存储在文件或内存缓冲区中，或通过网络连接链路传输，以便稍后在同一个或另一个计算机环境中重建。

设计一个算法来序列化和反序列化 二叉搜索树 。 对序列化/反序列化算法的工作方式没有限制。 您只需确保二叉搜索树可以序列化为字符串，并且可以将该字符串反序列化为最初的二叉搜索树。

编码的字符串应尽可能紧凑。

5.2 算法思路

在这里插入图片描述
在这里插入图片描述

5.3 C++代码实现
class Codec {
public:
    void BST_insert(TreeNode* node, TreeNode* insert_node) {
        if (insert_node->val < node->val) {
            if (node->left) {
                BST_insert(node->left, insert_node);
            }
            else {
                node->left = insert_node;
            }
        }
        else {
            if (node->right) {
                BST_insert(node->right, insert_node);
            }
            else {
                node->right = insert_node;
            }
        }
    }
    void change_int_to_string(int val, string& str_val) {
        string tmp;
        while (val) {
            tmp += val % 10 + '0';
            val = val / 10;
        }
        for (int i = tmp.length()- 1; i >= 0; i--) {
            str_val += tmp[i];
        }
        str_val += '#';
    }
	/*9.2 将二叉查找树按照前序遍历的方式，转化为字符串，数字之间使用#隔开*/
    void BST_preorder(TreeNode* node, string& data) {
        if (!node) {
            return;
        }
        string str_val;
        change_int_to_string(node->val, str_val);
        data += str_val;
        BST_preorder(node->left, data);
        BST_preorder(node->right, data);
    }
    // Encodes a tree to a single string.
    string serialize(TreeNode* root) {
         string data;
         BST_preorder(root,data);
         return data;   
    }

    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) {
          int val=0;
          vector<TreeNode*> node_vec;

          if(data.length()==0){
              return NULL;
          } 

          for(int i=0;i<data.length();i++){
              if(data[i]=='#'){
                  node_vec.push_back(new TreeNode(val));
                  val=0;
              }
              else{
                  val=val*10+(data[i]-'0');
              }
          }

         for(int i=1;i<node_vec.size();i++){
             BST_insert(node_vec[0],node_vec[i]);
         }
         return node_vec[0];
    }
};

6.计算右侧小于当前元素的个数

6.1 题目描述

给定一个整数数组 nums，按要求返回一个新数组 counts。数组 counts 有该性质： counts[i] 的值是 nums[i] 右侧小于 nums[i] 的元素的数量。

示例：
输入：nums = [5,2,6,1]
输出：[2,1,1,0]
解释：
5 的右侧有 2 个更小的元素 (2 和 1)
2 的右侧仅有 1 个更小的元素 (1)
6 的右侧有 1 个更小的元素 (1)
1 的右侧有 0 个更小的元素

6.2 算法思路

在这里插入图片描述
在这里插入图片描述在这里插入图片描述在这里插入图片描述

6.3 C++代码实现
struct BSTNode{
    int val;
    int count;
    BSTNode* left;
    BSTNode* right;
    BSTNode(int x):val(x),count(0),left(NULL),right(NULL){}
};

class Solution {
public:
    void BSTInsert(BSTNode* node,BSTNode* insert_node,int& count_small){
        if(insert_node->val<=node->val){
            node->count++;
            if(node->left){
                BSTInsert(node->left,insert_node,count_small);
            }
            else{
                node->left=insert_node;
            }
        }
        else{
            count_small+=node->count+1;
            if(node->right){
                BSTInsert(node->right,insert_node,count_small);
            }
            else{
                node->right=insert_node;
            }
        }
    }

    vector<int> countSmaller(vector<int>& nums) {
        vector<int> result;
        vector<int> count;
        vector<BSTNode*> node_vec;

        for(int i=nums.size()-1;i>=0;i--){
            node_vec.push_back(new BSTNode(nums[i]));
        }

        count.push_back(0);
        for(int i=1;i<node_vec.size();i++){
            int count_small=0;
            BSTInsert(node_vec[0],node_vec[i],count_small);
            count.push_back(count_small);
        }

        for(int i=node_vec.size()-1;i>=0;i--){
            delete node_vec[i];
            result.push_back(count[i]);
        }
        return result;
    }
};
二二牧人
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——查找(二叉排序树)
weixin_47924016的博客
09-15 1399
二叉排序树查找定义二叉排序树构造二叉排序树查找递归和非递归算法二叉排序树插入递归和非递归算法二叉排序树删除递归和非递归算法二叉排序树查找定义二叉排序树构造二叉排序树查找递归和非递归算法二叉排序树插入递归和非递归算法二叉排序树删除递归和非递归算法。
数据结构与算法详解——二叉查找树篇（附c++实现代码）
JMasker的博客
05-23 1409
目录二叉树相关概念和术语二叉树特殊类型二叉树的存储链式存储顺序存储二叉树的遍历二叉查找树查找插入删除完整代码 二叉树相关概念和术语   二叉树的递归定义为：二叉树是一棵空树，或者是一棵由一个根节点和两棵互不相交的，分别称作根的左子树和右子树组成的非空树；左子树和右子树又同样都是二叉树。 度：一个节点拥有子树的数目称为结点的度，叶子结点的度为0。 叶子结点：也称为终端结点，没有子树的结点或者度为零的结点。 结点的层次：从根结点开始，假设根结点为第1层，根节点的子结点为第2层，依此类推，如果某一个结点位于第L
二分搜索树和二叉树
DramaLifes的博客
07-25 386
我们在前面学习的数组。链表等等，是都呈线性排列的，因此我们称作线性结构，我们今天来学习数据结构中的树结构。 树结构本身就是一种天然的组织结构，我们为什么要使用树结构呢？答案就是因为树结构高效。 二叉树和链表一样具有动态结构。 二叉树顾名思义就是一个节点分为两个，也就是有左右节点，然后在以此类推，注意二叉树有唯一一个根节点如果最后不能再进行分叉了，那个这些节点称为叶子结点，我们将左右节点称为 称为左...
LeetCodeHot15-20
fan__lee的博客
05-28 259
leetCode23 --- 合并k个有序链表31 - 下一个排列 23 — 合并k个有序链表 /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode(int val) { this.val = val; } * ListNode(int val, ListNode n
二分查找与二叉排序树
一只养生的程序猿。
09-11 548
文章目录二分查找与二叉排序树二分查找1. 二分查找2. 区间查找3. 旋转数组 二分查找与二叉排序树 二分查找 1. 二分查找 将 target 插入有序数组中，要求插入后数组仍然有序，返回插入位置的下标 int search(vector<int> &nums, int target) { int index = -1; int begin = 0; int end = nums.size()-1; while(index == -1) { int mid = begin
二分查找和二叉排序树
你的BoyZ的博客
11-27 1989
二分查找和二叉排序树 预备知识 1 二分查找算法 前提： 要有顺序 逻辑（默认升序）： 将中间位置的关键字与查询关键字比较： 如果两者相等，则查找成功。 否则利用中间位置将表分成前、后两个子表： 如果中间位置的的关键字大于查找关键字，则进一步查找前一子表 否则进一步查找后一字表 重复以上过程，直到找到满足条件的记录，则查询成功，或这直到子表不存在为止，此时查找不成功。 //递归 public static boolean binary_search(int[] val,int begin,int
数据结构—查找（二分，二叉排序树，平衡二叉树，B树与B+树，哈希表）
qq_41409979的博客
05-17 686
数据结构—查找 文章目录数据结构—查找前言一、二分查找法二、二叉排序树1.二叉排序树的构建2.查找3.删除三 平衡二叉树总结 前言 本章主要介绍一些经典的查找算法，二分查找，搜索二叉树，平衡二叉树，B树，B+树，哈希表等。 一、二分查找法 时间复杂度是O(logn),远远要好于顺序查找的O(n),不过二分查找方法前提条件是需要数组是有序的。 代码如下： #include<iostream> #include<vector> #include<algorithm>
数据结构与算法——二叉搜索树、二叉平衡树、红黑树 总结
nswdiphone6的博客
03-12 608
二叉排序树，平衡二叉树，红黑树总结 二叉排序树 二叉排序树，相信大家都接触过，二叉查找树的特点就是左子树的节点值比父亲节点小，而右子树的节点值比父亲节点大，如图 基于二叉查找树的这种特点，我们在查找某个节点的时候，可以采取类似于二分查找的思想，快速找到某个节点。n 个节点的二叉查找树，正常的情况下，查找的时间复杂度为 O（logn）。 之所以说是正常情况下，是因为二叉查找树有可能出现一种极端的情况，例如 这种情况也是满足二叉查找树的条件，然而，此时的二叉查找树已经近似退化为一条链表，这样的二叉查找树的查
数据结构与算法基础课程 C语言C++程序语言设计教程8_1集合与查找（静态查找、哈希、二叉排序树、平衡二叉树）共28页.pptx
最新发布
07-20
### 数据结构与算法基础课程——第八章：集合与查找 #### 一、集合 - **集合的定义**：集合是一种不包含重复元素的数据结构。在数学中，集合是一些特定对象的无序组合。 - **集合上的基本运算**： - **元素的增删...
数据结构——二叉排序树的创建、插入、查找（循环和递归）
Prescu的博客
07-10 893
#include <stdio.h> #include <stdlib.h> typedef struct BSTNode{ int data; struct BSTNode *lchild,*rchild; }BSTNode,*BiTree; BSTNode *BST_Search1(BiTree T,int key){ //查找值为key的结点(while循环) while(T!=NULL&&key!=T->data){ if(key<
二分查找和二叉排序树（C++实现）
06-24
二分查找（C++）：查找过程中能够记录比较元素的下标并输出 二叉排序树（C++）：建立；显示结点、插入元素、删除元素。
数据结构-查找（顺序、二分、二叉排序树）
帅子的博客
04-20 322
#include <iostream> using namespace std; typedef int keyType; typedef int infoType; typedef struct{ keyType key; infoType info; }Node; typedef Node seqList[5+1]; //顺序查找 int seqSearch(int R[],keyType k,int n){ R[0] = k; int i = n;...
二分搜索树(二叉排序树)（源代码)
qq_43701330的博客
04-11 381
二叉排序树或者是一棵空树，或者是具有下列性质的二叉树： （1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值； （2）若右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值； （3）左、右子树也分别为二叉排序树； 二叉树：就是一种特殊的树结构 元素节点最多有两个孩子节点 二叉树怎么存？动态数组 动态链表 如果动态数组存一个深度为h的二叉树 最多需要2^h-1 每一层最...
二分查找与二叉树排序
Fan9_的博客
02-06 503
#-*-coding=utf-8 -*- def binarysearch(list, value): low = 0 hight = len(list) - 1 key = value i = 0 while low <= hight: i += 1 mid = (low + hight) // 2 if
6.算法之二分查找与二叉排序树
CarmenIsOK的博客
03-29 477
（一）复杂度 log2n （二）二分查找代码 //递归实现 bool binary_search(vector<int> &sort_array,int beg,int end,int target) { if(beg>end) return false; int mid=(end-beg)/2+beg;//迭代器时使用 //int mid=(beg+end)/...
第六章 二分查找与二叉排序树
Stay Hungry Stay Foolish 求知若饥 虚心若愚
08-31 1397
文章目录二分查找与二叉排序树二分查找基础知识 && 二叉查找（排序）树基础知识leetCode例1：插入位置例2：区间查找例3：旋转数组查找例4：二叉查找树编码与解码例5：逆序数剑指offer 二分查找与二叉排序树 二分查找基础知识 && 二叉查找（排序）树基础知识 （1）二分查找 二分查找又称折半查找，首先假设表中元素是按升序排列，将表中间位置的关键字与查找关键字...
二分查找、二叉排序树查找
cszhangchao的专栏
04-21 1355
准备面试，整理了一下二分查找的递归与非递归实现方式，面试挺常见的。dai
二分搜索树（二叉排序树）Java实现
宋七夏的博客
05-03 441
二分搜索树（二叉查找树） ​ 参考：《数据结构与算法分析》和《算法（第四版）》 特性 ​ 二分搜索树（Binary Search Tree，BST，后面全用BST代替）也可叫做二叉查找树。它不仅可以查找数据，还可以高效地插入、删除数据。 ​ 特性: 若任意节点的左子树不空，则左子树上所有节点的值均小于它的根节点的值； 若任意节点的右子树不空，则右子树上所有节点的值均大于它的根节点的值； ...
二分查找，二叉排序树与平衡二叉树
weixin_56631477的博客
12-13 1022
二分查找，二叉排序树/二叉搜索树，二叉平衡树的相关操作
数据结构实验：查找技术与二叉排序树实现
本次实验主要涉及了数据结构中的查找技术，包括顺序查找、二分查找以及二叉排序树的操作。实验目的是深入理解和掌握这些查找算法的原理、适用场景以及性能特点。 1. 查找算法 - 顺序查找：在无序序列中查找目标...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值