C++中二叉搜索树的模拟实现(二叉搜索树是map,set的底层原理)

搜索二叉树

定义

搜索二叉树:左子树小于根,右子树大于根.搜索二叉树的中序序列是升序的.所以对于二叉树而言,它的左子树和右子数都是二叉搜索树

下图就是二叉搜索树
在这里插入图片描述

二叉搜索树的性质:

  • 二叉搜索树的中序遍历出的数据是有序的,并且二叉树搜索树在查找某个数的时候,一般情况下的时间复杂度是O(log2(N))级别的.
  • 二叉搜索树中是没有值相同的节点的,否则无法构成二叉搜索树.

节点的定义

二叉树和别的树的区别就是各个节点的排列有了区别,节点中存储的内容还是不会变的,仍然是左右指针,和一个值.

template<class K>
struct BinarySearchTreeNode
{
	typedef BinarySearchTreeNode<K> Node;
	Node* _left;
	Node* _right;
	K _key;
	BinarySearchTreeNode(const K& key)
        : _left(nullptr)
        , _right(nullptr)
        , _key(key){}
};

节点的构造方法

	BinarySearchTreeNode(const K& key)
        : _left(nullptr)
        , _right(nullptr)
        , _key(key){}

二叉搜索树的创建

二叉搜索树的创建首先只需要一个根节点即可,后续插入节点或者删除节点时,保持住连接关系就好.

template<class T>
class BinarySearchTree
{
	typedef BinarySearchTreeNode<K> Node;
	private:
	Node* _root = nullptr;
	public:
	// 各种函数
};

注意:后边的这些方法都是写在类的public中的.

向树中插入节点

例如:插入节点A的时候,要判断A中的key值和树中根节点开始,依次比较key值,我们定义一个cur指针,用于为新来的节点找到合适的插入位置,假如A节点的key值<cur节点的key值,那么就cur就向左树开始遍历.假如A的key值和cur的key值相同,直接返回.假如A的key值大于cur的key值,cur就向右数遍历.最终cur的位置就是能插入数据的地方,但是cur的值最后是为空的,那么我们如何将cur处的值替换为这个A节点呢?换句话说,如何让cur的父节点指向这个A节点呢?答案是:我们在cur向下一个节点行进之前,先保存当前节点的指针,也就是保存好cur的父节点的值.

但是A节点最终是链接在父节点的左边还是在父节点的右边呢??这个只能通过保存的父节点中保存的值进行判断.若A节点的值小于父节点,那么就链接在父节点的左边,否则链接在父节点的右边.
在这里插入图片描述

代码实现:

bool insert(const K& key)
{
	// 插入节点之前,检查是不是空树
	if(_root == nullptr)
	{
		_root = new Node(key);
		return true;
	}
	Node* cur = _root;
	Node* parent = _root;
	while(cur)
	{
        if(key<cur->_key)
        {
        	parent = cur;
            cur = cur->_left;
        }
        else if(key>cur->_key)
        {
        	parent = cur;
        	cur = cur->_right;
        }
        else
        {
        	// 值不能相同直接返回
        	return false;
        }
    }
        if(parent->_key<key)
        {
        	parent->_left = new Node(key);
        }
        else
        {
        	parent->_right = new Node(key);
        }
        return true;
}

查找元素

查找元素就比较简单了,要查找的值小于cur的当前值,那么就向左树查找,若大于当前值,就向右数查找.

代码实现:

bool find(const K& key)
{
	Node* cur = _root;
	while(cur)
	{
		if(key<cur->_key)
        {
			cur = cur->_left;		
        }
        else if(key>cur->_key)
        {
        	cur = cur->_right;
        }
        else
        {
        	return true;
        }
	}
	return false;
}

删除元素

二叉搜素树中,删除节点是最比较复杂的.分为了3种情况

  1. 要被删除的目标节点的左树是空:每次cur指针在找目标节点时,每次cur迭代之前,都需要记录cur的当前位置,也就是用parent指针来记录.

    • 当删除的节点是parent的右边时:就需要parent的右指针指向目标节点的右子树.
    • 当删除的节点是parent的左边时:就需要parent的左指针指向目标节点的右子树.
      在这里插入图片描述

  2. 要被删除的节点的右树是空:每次cur指针在找目标节点时,每次cur迭代之前,都需要记录cur的当前位置,也就是用parent指针来记录.

    • 当删除的节点是parent的右边时:就需要parent的右指针指向目标节点的左子树.
    • 当删除的节点是parent的左边时:就需要parent的左指针指向目标节点的左子树.
      在这里插入图片描述

  3. 要被删除的节点的左右都不是空的时候:
    此时就需要用替换法了,
    例如:我们要删除下图中的值为8的节点.删除节点但是不能破环二叉搜索树的结构,所以就需要找到一个值在3和10的节点来替换这里的值为8的节点.那么这值如何找呢?由于二叉搜索树的结构可知,左树的值小于根的值,右树的值总是大于根的值.所以我们可以在左树中找到最大的值或者是在右树中找到最小的值(这两个值的任意一个值都是符合要求的,即大于3小于10的)来替换要被删除节点的位置的值,如下图,就可以将7复制到8这个位置,紧接着删除原本的7所在的节点,就删除成功了.

    注意:删除原本值为7的节点时,一定属于第一种和第二种情况之一,因为:左树的最大值的右指针一定为空,右数的最小值的左树一定为空.
    在这里插入图片描述

代码实现:

bool erase(const K& key)
{
	Node* cur = _root;
	Node* parent = _root;
	while(cur)
	{
		if(key<cur->_key)
		{
			parent = cur;
			cur = cur->_left;
		}
		else if(key>cur->_key)
		{
			parent  = cur;
			cur = cur ->_right;
		}
		else
		{
		// 删除的节点的左树为空
			if(cur->_left == nullptr)
			{
                if(cur == _root)
                {
                    _root = _root->_right;
                }
                else
                {
                    	if(parent->_right == cur)
                        {
                            parent ->_right = cur->_right;
                        }
                        else
                        {
                            parent->_left = cur->_right;
                        }
                }
			
                delete cur;
                return true;
			}
            
			// 删除的节点的右树为空
			else if(cur->_right == nullptr)
			{
                if(cur == _root )
                {
                    _root = _root ->_left;
                }
                else
                {
                    		if(parent->_right == cur)
                            {
                                parent->_right = cur->_left;
                            }
                            else
                            {
                                parent->_left = cur->_left;
                            }
                }
                delete cur;
                return true;
			}
			 // 左右都不为空,替换法
			else
			{
				// 以右边的最小值为例子
				Node* rightMinParent = cur;
				Node* rightMin = cur->_right;
				while(rightMin->_left){
					rightMin = rightMin ->_left;
				}
				cur->_key = rightMin->_key;
				if(rightMinParent->_left == rightMin){
					rightMinParent->_left = rightMin->_right;
				}else
				{
					rightMinParent->_right = rightMin->_right;
				}
				delete rightMin;
				return true;
			}
		}
	}
	return false;
}

二叉树的中序遍历

由于类的成员函数不能递归调用,所以创建一个私有函数_Inorder,接着在public中定义Inorder方法,调用这个_Inorder犯法即可.

void Inorder()
{
    _Inorder(_root);
}
void _Inorder(Node* root)
{
	if(root==nullptr) return;
	_Inorder(root->_left);
	cout<<root->_key<<endl;
	_Inorder(root->_right);
}

二叉搜索树的递归找数字

bool _Find(Node* root,const K& key)
{
	if(root == nullptr) return false;
	else if(root->_key == key) return true;
	else if (root->_key < key)
    {
        _Find(root->_right, key);
    }
    else
    {
        _Find(root->_left, key);
    }
}

二叉搜索树删除元素的另一种方法

这里的root定义成引用即可,root必定是节点的左指针或者右指针的引用.这里直接改变引用的值即可.就不用找父节点了.更方便一点.

		bool _Erase(Node*& root, const K& key)
		{
			if (root == nullptr)
			{
				return false;
			}
			if (root->_key < key)
			{
				return _Erase(root->_right, key);
			}
			else if (root->_key > key)
			{
				return _Erase(root->_left, key);
			}
			else
			{
				Node* del = root;
				if (root->_right == nullptr)
				{
					root = root->_left;
				}
				else if (root->_left == nullptr)
				{
					root = root->_right;
				}
				else
				{
					// 替换法
					Node* rightMin = root->_right;
					while (rightMin->_left)
					{
						rightMin = rightMin->_left;
					}
					swap(rightMin->_key, root->_key);
					// 将当前root位置和rightMin位置的值进行交换,接着在root的右边的树中删除key

					return _Erase(root->_right, key);
				}
				delete del;
				return true;
			}
		}

二叉搜索树插入数据的第二种方式

// 注意这里的&是不可少的,不然要使用二级指针进行操作了.
		bool _Insert(Node*& root, Node* parent, const K& key)
		{
			if (root == nullptr)
			{
				root = new Node(key);
			}
			if (root->_key > key)
			{
				return _Insert(root->_left, parent, key);
			}
			else if (root->_key < key)
			{
				return _Insert(root->_right, parent, key);
			}
			else if (root->_key == key)
			{
				return false;
			}
		}

二叉搜索树的构造方法

拷贝构造

先拷贝根,再拷贝左右子树

Node* Copy(Node* root)
{
	if(root == nullptr)return nullptr;
	Node* newRoot = new Node(root->_key);
	newRoot->_left = Copy(root->_left);
	newRoot->_right = Copy(root->_right);
	return newRoot;
}
// 在构造函数中:
BinarySearchTree(BinarySearchTree<K>& t){
    this->_root = Copy(t._root);
}

赋值拷贝

注意:要使用如下这种方法,参数必须是类实体,不能是类引用,返回值必须是类引用.

BinarySearchTree<K>& operator=(const BinarySearchTree<K> t)
{
	swap(t._root,this->_root);
	return *this;
}

默认构造

BinarySearchTree() = default;

析构函数

先写一个destroy函数

~BinarySearchTree()
{
	Destroy(_root);
}
void Destroy(Node* root)
{
	if(root== nullptr)return ;
	Destroy(root->_left);
	Destroy(root->_right);
	delete root;
}

源码

#include<iostream>
using namespace std;
namespace key 
{

	template<class K>
	struct BinarySearchTreeNode {
		typedef BinarySearchTreeNode<K> Node;
		Node* _left;
		Node* _right;
		K _key;
		BinarySearchTreeNode(const K& key)
			:_left(nullptr)
			, _right(nullptr)
			, _key(key)
		{}
	};

	template<class K>
	class BinarySearchTree {
		typedef BinarySearchTreeNode<K> Node;
	public:
		bool Erase(const K& key) // 删除指定的节点.
		{
			Node* cur = _root;
			Node* parent = _root;
			while (cur)
			{
				if (cur->_key == key)
				{
					if (cur->_right == nullptr)
					{
						if (cur == _root) {
							_root = _root->_left;
						}
						else
						{
							if (cur == parent->_left)
							{
								parent->_left = cur->_left;
							}
							else
							{
								parent->_right = cur->_left;
							}
						}
						delete cur;
						return true;
					}
					else if (cur->_left == nullptr)
					{
						if (cur == _root) {
							_root = _root->_right;
						}
						else
						{
							if (cur == parent->_left)
							{
								parent->_left = cur->_right;
							}
							else
							{
								parent->_right = cur->_right;
							}
						}
						delete cur;
						return true;
					}

					// 左右都不为空的时候使用替换法
					else
					{
						Node* rightMinParent = cur; // 这里要用cur进行初始化
						// 右边的最小值
						Node* rightMin = cur->_right;
						while (rightMin->_left)
						{
							rightMinParent = rightMin;
							rightMin = rightMin->_left;
						}
						cur->_key = rightMin->_key;
						if (rightMin == rightMinParent->_left)
							rightMinParent->_left = rightMin->_right;
						else
							rightMinParent->_right = rightMin->_right;
						delete rightMin;
						return true;
					}
				}
				else if (cur->_key > key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					parent = cur;
					cur = cur->_right;
				}
			}
			return false;
		}
		void Inorder()
		{
			_Inorder(_root);
		}
		bool Insert(const K& k)
		{
			if (_root == nullptr)
			{
				_root = new Node(k);
				return true;
			}
			Node* cur = _root;
			Node* parent = nullptr;
			while (cur)
			{
				if (cur->_key == k)
				{
					return false;
				}
				else if (cur->_key > k)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					parent = cur;
					cur = cur->_right;
				}
			}
			//保存父节点
			if (k < parent->_key)
			{
				parent->_left = new Node(k);
			}
			else
			{
				parent->_right = new Node(k);
			}
			return true;
		}
		bool Find(const K& k)
		{
			Node* cur = _root;
			while (cur)
			{
				if (cur->_key == k)
				{
					return true;
				}
				else if (cur->_key > k)
				{
					cur = cur->_left;
				}
				else
				{
					cur = cur->_right;
				}
			}
			return false;
		}

		bool FindR(const K& key) //递归找数字
		{
			return _Find(_root, key);
		}
		bool InsertR(const K& key)
		{
			return _Insert(_root, _root, key);
		}
		bool EraseR(const K& key)
		{
			return _Erase(_root, key);
		}

		~BinarySearchTree()
		{
			Destroy(_root);
		}
		// 自动生成默认的构造
		BinarySearchTree() = default;
		// 拷贝构造
		BinarySearchTree(const BinarySearchTree<K>& t)
		{
			this->_root = Copy(t._root);
		}
		// 赋值拷贝
		BinarySearchTree<K>& operator=(const BinarySearchTree<K> t)
		{
			swap(_root, t._root);
			return *this;
		}

	private:
		Node* Copy(const Node* root)
		{
			if (root == nullptr)
				return nullptr;
			Node* newRoot = new Node(root->_key);
			newRoot->_left = Copy(root->_left);
			newRoot->_right = Copy(root->_right);
			return newRoot;
		}
		void Destroy(Node*& root)
		{
			if (root == nullptr)
				return;
			Destroy(root->_left);
			Destroy(root->_right);
			delete root;
		}
		bool _Erase(Node*& root, const K& key)
		{
			if (root == nullptr)
			{
				return false;
			}
			if (root->_key < key)
			{
				return _Erase(root->_right, key);
			}
			else if (root->_key > key)
			{
				return _Erase(root->_left, key);
			}
			else
			{
				Node* del = root;
				if (root->_right == nullptr)
				{
					root = root->_left;
				}
				else if (root->_left == nullptr)
				{
					root = root->_right;
				}
				else
				{
					// 替换法
					Node* rightMin = root->_right;
					while (rightMin->_left)
					{
						rightMin = rightMin->_left;
					}
					swap(rightMin->_key, root->_key);
					// 将当前root位置和rightMin位置的值进行交换,接着在root的右边的树中删除key

					return _Erase(root->_right, key);
				}
				delete del;
				return true;
			}
		}
		// 注意这里的&是不可少的,不然要使用二级指针进行操作了.
		bool _Insert(Node*& root, Node* parent, const K& key)
		{
			if (root == nullptr)
			{
				root = new Node(key);
			}
			if (root->_key > key)
			{
				return _Insert(root->_left, parent, key);
			}
			else if (root->_key < key)
			{
				return _Insert(root->_right, parent, key);
			}
			else if (root->_key == key)
			{
				return false;
			}
		}
		Node* _root = nullptr;
		void _Inorder(Node* root)
		{
			if (root == nullptr)
				return;
			_Inorder(root->_left);
			cout << root->_key << " ";
			_Inorder(root->_right);
		}
		bool _Find(Node* root, const K& key)        
		{
			if (root == nullptr)return false;        
			else if (root->_key == key)return true;        
			else if (root->_key < key)        
			{
				_Find(root->_right, key);        
			}
			else        
			{
				_Find(root->_left, key);        
			}
		}
	};
}

结束

本篇文章就到这里就结束啦,若有不足,请在评论区指正,下期再见,

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/518339.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

9proxy—数据采集工具全面测评

9proxy—数据采集工具全面测评

9Proxy数据采集工具Unlock the web with 9Proxy, the top residential proxy provider. Get unlimited bandwidth, affordable prices, and secure HTTPS and Socks5 configurations.https://9proxy.com/?utm_sourceblog&utm_mediumcsdn&utm_campaignyan 前言 在当今数…
阅读更多...
如何实现仿微信界面[我的+首页聊天列表+长按菜单功能+添加菜单功能]

如何实现仿微信界面[我的+首页聊天列表+长按菜单功能+添加菜单功能]

如何实现仿微信界面[我的首页聊天列表长按菜单功能添加菜单功能] 一、简介 如何实现仿微信界面[我的首页聊天列表长按菜单功能添加菜单功能] 采用 uni-app 实现&#xff0c;可以适用微信小程序、其他各种小程序以及 APP、Web等多个平台 具体实现步骤如下&#xff1a; 下载…
阅读更多...
Windows 2008虚拟机安装、安装VM Tools、快照和链接克隆、添加硬盘修改格式为GPT

Windows 2008虚拟机安装、安装VM Tools、快照和链接克隆、添加硬盘修改格式为GPT

一、安装vmware workstation软件 VMware workstation的安装介质&#xff0c;获取路径&#xff1a; 链接&#xff1a;https://pan.baidu.com/s/1AUAw_--yjZAUPbsR7StOJQ 提取码&#xff1a;umz1 所在目录&#xff1a;\vmware\VMware workstation 15.1.0 1.找到百度网盘中vmwa…
阅读更多...
【Android】App通信基础架构相关类源码解析

【Android】App通信基础架构相关类源码解析

应用通信基础架构相关类源码解析 这里主要对Android App开发时&#xff0c;常用到的一些通信基础类进行一下源码的简单分析&#xff0c;包括&#xff1a; Handler&#xff1a;处理器&#xff0c;与某个Looper&#xff08;一个线程对应一个Looper&#xff09;进行关联。用于接…
阅读更多...
【React】React hooks 清除定时器并验证效果

【React】React hooks 清除定时器并验证效果

React hooks 清除定时器并验证效果 目录结构如下useTime hookClock.tsx使用useTime hookApp.tsx显示Clock组件显示时间&#xff08;开启定时器&#xff09;隐藏时间&#xff08;清除定时器&#xff09; 总结参考 目录结构如下 useTime hook // src/hooks/common.ts import { u…
阅读更多...
亚马逊AWS永久免费数据库

亚马逊AWS永久免费数据库

Amazon DynamoDB 是一项无服务器的 NoSQL 数据库服务&#xff0c;您可以通过它来开发任何规模的现代应用程序。作为无服务器数据库&#xff0c;您只需按使用量为其付费&#xff0c;DynamoDB 可以扩展到零&#xff0c;没有冷启动&#xff0c;没有版本升级&#xff0c;没有维护窗…
阅读更多...
05-延迟任务精准发布文章

05-延迟任务精准发布文章

延迟任务精准发布文章 1)文章定时发布 2)延迟任务概述 2.1)什么是延迟任务 定时任务&#xff1a;有固定周期的&#xff0c;有明确的触发时间延迟队列&#xff1a;没有固定的开始时间&#xff0c;它常常是由一个事件触发的&#xff0c;而在这个事件触发之后的一段时间内触发…
阅读更多...
HuggingFace踩坑记录-连不上，根本连不上

HuggingFace踩坑记录-连不上，根本连不上

学习 transformers 的第一步&#xff0c;往往是几句简单的代码 from transformers import pipelineclassifier pipeline("sentiment-analysis") classifier("We are very happy to show you the &#x1f917; Transformers library.") ""&quo…
阅读更多...
Vue - 1（ 13000 字 Vue 入门级教程）

Vue - 1（ 13000 字 Vue 入门级教程）

一&#xff1a;Vue 1.1 什么是 Vue Vue.js&#xff08;通常称为Vue&#xff09;是一款流行的开源JavaScript框架&#xff0c;用于构建用户界面。Vue由尤雨溪在2014年开发&#xff0c;是一个轻量级、灵活的框架&#xff0c;被广泛应用于构建单页面应用&#xff08;SPA&#xf…
阅读更多...
golang设计模式图解——模板方法模式

golang设计模式图解——模板方法模式

设计模式 GoF提出的设计模式有23个&#xff0c;包括&#xff1a; &#xff08;1&#xff09;创建型(Creational)模式&#xff1a;如何创建对象&#xff1b; &#xff08;2&#xff09;结构型(Structural )模式&#xff1a;如何实现类或对象的组合&#xff1b; &#xff08;3&a…
阅读更多...
移动WEB开发之flex布局

移动WEB开发之flex布局

一、flex布局体验 传统布局兼容性好&#xff0c;布局繁琐&#xff0c;局限性&#xff0c;不能再移动端很好布局 flex弹性布局操作方便&#xff0c;布局极为简单&#xff0c;移动端应用广泛&#xff0c;PC端浏览器支持情况较差 建议&#xff1a;如果是PC端页面布局&#xff0…
阅读更多...
07-app端文章搜索

07-app端文章搜索

app端文章搜索 1) 今日内容介绍 1.1)App端搜索-效果图 1.2)今日内容 文章搜索 ElasticSearch环境搭建 索引库创建 文章搜索多条件复合查询 索引数据同步 搜索历史记录 Mongodb环境搭建 异步保存搜索历史 查看搜索历史列表 删除搜索历史 联想词查询 联想词的来源 联…
阅读更多...
外围极简便携式T12电烙铁（CH32X035）－第二篇

外围极简便携式T12电烙铁（CH32X035）－第二篇

文章目录 系列文章目录前言一、pandas是什么&#xff1f;二、使用步骤 1.引入库2.读入数据总结 一、工程简介 原理图&#xff1a; PCB&#xff1a; 外壳&#xff1a; BOM&#xff1a; 二、功能模块介绍 1、 |----系统初始化 0&#xff1a;填写系统初值 …
阅读更多...
推荐使用AI开源平台：搭建GA领域案件分类的自动化处理

推荐使用AI开源平台：搭建GA领域案件分类的自动化处理

引言 公安和消防机构面临着日益复杂的案件处理任务。为了提高案件管理和分派的效率&#xff0c;自然语言处理&#xff08;NLP&#xff09;和文本分类技术的应用变得尤为重要。本文将探讨如何通过自动化处理技术快速识别案件性质和关键特征&#xff0c;从而优化资源分配&#x…
阅读更多...
9Proxy，跨境电商一站式解决方案

9Proxy，跨境电商一站式解决方案

文章目录 跨境电商什么是跨境电商跨境电商的机遇跨境电商技术支撑 海外代理IP什么是海外代理IP海外代理IP的作用如何选择海外代理IP 9Proxy9Proxy的优势9Proxy的解决方案价格汇总搜索引擎优化市场调查多重核算数据抓取广告技术 价格上手体验注册登录下载安装数据采集 总结福利 …
阅读更多...
Oracle中实现一次插入多条数据

Oracle中实现一次插入多条数据

一、需求描述 在我们实际的业务场景中&#xff0c;由于单条插入的效率很低&#xff08;每次都需要数据库资源连接关闭的开销&#xff09;&#xff0c;故需要实现一次性插入多条数据&#xff0c;用以提升数据插入的效率&#xff1b; 如下图是常见的单条插入数据&#xff1a; 二…
阅读更多...
stable diffsuinon生成动漫美女

stable diffsuinon生成动漫美女

anything-v5-PrtRE.safetensors [7f96a1a9ca]模型 delicate, masterpiece, beautiful detailed, colourful, finely detailed,detailed lips, intricate details, (50mm Sigma f/1.4 ZEISS lens, F1.4, 1/800s, ISO 100,&#xff08;photograpy:1.1), (large breast:1.0),(a b…
阅读更多...
【APUE】网络socket编程温度采集智能存储与上报项目技术------多进程编程

【APUE】网络socket编程温度采集智能存储与上报项目技术------多进程编程

作者简介&#xff1a; 一个平凡而乐于分享的小比特&#xff0c;中南民族大学通信工程专业研究生在读&#xff0c;研究方向无线联邦学习 擅长领域&#xff1a;驱动开发&#xff0c;嵌入式软件开发&#xff0c;BSP开发 作者主页&#xff1a;一个平凡而乐于分享的小比特的个人主页…
阅读更多...
优先队列c++

优先队列c++

内容&#xff1a; priority_quene是一个优先队列&#xff0c;优先级别高的先入队&#xff0c;默认最大值优先 因此出队和入队的时间复杂度均为O&#xff08;logn&#xff09;,也可以自定义优先级 头文件<quene> 函数&#xff1a; 构建优先队列 priority_queue<in…
阅读更多...
C语言中的字符与字符串：魔法般的函数探险（续）

C语言中的字符与字符串：魔法般的函数探险（续）

七、字符数组与字符串的关系 在C语言中&#xff0c;字符串实际上是以字符数组的形式存在的。了解这一关系&#xff0c;对于深入理解字符串函数和字符操作至关重要。 字符数组与字符串字面量&#xff1a;当我们定义一个字符串字面量&#xff0c;如char str[] "Hello"…
阅读更多...
最新文章

Copyright @ 2022~2023