c++的学习之路：24、 二叉搜索树概念

摘要

本章主要是讲一下二叉搜索树的实现

目录

摘要

 一、二叉搜索树概念

二、 二叉搜索树操作

1、二叉搜索树的查找

2、二叉搜索树的插入

3、二叉搜索树的删除

三、二叉搜索树的实现

1、插入

2、中序遍历

3、删除

4、查找

四、二叉搜索树的递归实现

1、插入

2、删除

3、查找

五、代码

test.c

BSTree.h

六、思维导图

 一、二叉搜索树概念

二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树：

1、若它的左子树不为空，则左子树上所有节点的值都小于根节点的值

2、若它的右子树不为空，则右子树上所有节点的值都大于根节点的值

3、它的左右子树也分别为二叉搜索树

如下图所示的图片就是一个二叉搜索树。

二、 二叉搜索树操作

这个就是不在附图了，就是上面那个图，他的数值就是int a[] = {8, 3, 1, 10, 6, 4, 7, 14, 13};这个数组所示的数值。

1、二叉搜索树的查找

a、从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。

b、最多查找高度次，走到到空，还没找到，这个值不存在。

2、二叉搜索树的插入

a、树为空，则直接新增节点，赋值给root指针

b、树不空，按二叉搜索树性质查找插入位置，插入新节点

如下图所示

3、二叉搜索树的删除

首先查找元素是否在二叉搜索树中，如果不存在，则返回, 否则要删除的结点可能分下面四种情
况：

a、要删除的结点无孩子结点

b、要删除的结点只有左孩子结点

c、要删除的结点只有右孩子结点

d、要删除的结点有左、右孩子结点

根据上述情况有下面几种情况b：删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点--直接删除，情况c：删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点--直接删除，情况d：在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值填补到被删除节点中，再来处理该结点的删除问题--替换法删除，也就是找个保姆

三、二叉搜索树的实现

1、插入

想要插入首先要构建节点，如下方块种代码，就是申请一个节点，这个就不用多说了，第二个快的代码就是申请插入，就是如果没有也就是空的时候就申请一个节点，然后判断需要插入的数值，如果大于跟节点就给给左，如果小于就是右边，然后在循环中进行下去，直到找到合适的位置进行插入，如果有相同的就返回false，测试插入成功在中序遍历进行打印查看。

template<class T>
struct BSTreeNode
{
    BSTreeNode<T>* _left;
    BSTreeNode<T>* _right;
    T _key;
    BSTreeNode(const T& key)
        :_left(nullptr)
        , _right(nullptr)
        , _key(key)
    {}
};

typedef BSTreeNode<K> Node;
    bool Insert(const K& key)
    {
        if (_root == nullptr)
        {
            _root = new Node(key);
            return true;
        }
        Node* parent = nullptr;
        Node* cur = _root;
        while (cur)
        {
            if (cur->_key > key)
            {
                parent = cur;
                cur = cur->_left;
            }
            else if (cur->_key < key)
            {
                parent = cur;
                cur = cur->_right;
            }
            else
            {
                return false;
            }
        }
        cur = new Node(key);
        if (parent->_key > key)
        {
            parent->_left = cur;
        }
        else
        {
            parent->_right = cur;
        }
        return true;
    } 

2、中序遍历

在下方块种的代码就是测试中序的，这个就没啥说的就是递归打印，但是有一点要注意，root节点是私密的在外面访问不到，没法使用，这里需要借用一个没有参数的函数进行打印，如下方代码所示，测试结果如图。

void InOrder()
    {
        _InOrder(_root);
    }
    void _InOrder(Node* root)
    {
        if (root == nullptr)
            return;
        _InOrder(root->_left);
        cout << root->_key << ' ';
        _InOrder(root->_right);
    }

3、删除

这个就是优点麻烦了，他就是和上面所写操作中的三种情况，根据这三种情况进行写，首先就是寻找相等的，这个就没啥说的了，找到后就是判断左边为空和右边为空的两种情况，找到相等的时候，然后进行判断是否需要链接，这里是不管需不需要都进行链接，因为一种是后续有节点进行连接，一种是没有直接连接为空，刚好解决这两中情况，然后就是左右都不为空的时候，这个需要找个托孤的，就有点像我学Linux的时候遇到的孤儿进程被1号进程托孤一样，这里就是左边最大节点和右边最小节点，然后进行换一下，在进行删除，这里代码如下，测试如图。

bool Erase(const K& key)
    {
        Node* parent = nullptr;
        Node* cur = _root;
        while (cur)
        {
            //判断找到相等的
            if (cur->_key < key)
            {
                parent = cur;
                cur = cur->_right;
            }
            else if (cur->_key > key)
            {
                parent = cur;
                cur = cur->_left;
            }
            else//找到相等了
            {
                //左为空
                if (cur->_left == nullptr)
                {
                    if (cur == _root)//如果是根节点,就是左边都是空，只有右边的值
                    {
                        _root = cur->_right;
                    }
                    else//不是根节点
                    {
                        if (parent->_left == cur)//如果cur在父节点的左边，就把cur右边的值托孤给父,如果是空，刚好是空节点给父
                        {
                            parent->_left = cur->_right;
                        }
                        else//如果cur在父节点的右边，就把cur左边的值托孤给父
                        {
                            parent->_right = cur->_right;
                        }

                    }
                    delete cur;
                }
                //右为空
                else if (cur->_right == nullptr)
                {
                    if (cur == _root)//如果是根节点,右边都是空，只有左边有值
                    {
                        _root = cur->_left;
                    }
                    else//不是根节点
                    {
                        if (parent->_left = cur)//如果cur在父节点的左边，就把cur右边的值托孤给父,如果是空，刚好是空节点给父
                        {
                            parent->_left = cur->_left;
                        }
                        else//如果cur在父节点的右边，就把cur左边的值托孤给父
                        {
                            parent->_right = cur->_left;
                        }

                    }
                    delete cur;
                }
                else
                {
                    // 找右树最小节点替代，也可以是左树最大节点替代
                    Node* pminRight = cur;
                    Node* minRight = cur->_right;
                    while (minRight->_left)
                    {
                        pminRight = minRight;
                        minRight = minRight->_left;
                    }

                    cur->_key = minRight->_key;

                    if (pminRight->_left == minRight)
                    {
                        pminRight->_left = minRight->_right;
                    }
                    else
                    {
                        pminRight->_right = minRight->_right;
                    }
                    delete minRight;
                }
                return true;
            }
        }
        return false;
    }

4、查找

这个就是直接进行查找就好了，比根节点大就去右边找，小就是左边找，如下代码所示，测试如图。

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

四、二叉搜索树的递归实现

1、插入

这里世界利用递归去插入，如果为空就创建一个节点，没有的判断是否比根小，小的话就去左边递归，大的就去右边递归，因为这个需要root节点所以和上面所说的中序一样进行利用函数进行使用直接传递key值就可以了，如下代码，这里的测试放在最后了，和上面测试一样的。

bool InsertR(const K& key)
    {
        return _InsertR(_root, key);
    }

bool InsertR(const K& key)
    {
        return _InsertR(_root, key);
    }bool _InsertR(Node*& root, const K& key)
    {
        if (root == nullptr)
        {
            root = new Node(key);
            return true;
        }

        if (root->_key < key)
        {
            return _InsertR(root->_right, key);
        }
        else if (root->_key > key)
        {
            return _InsertR(root->_left, key);
        }
        else
        {
            return false;
        }
    }

2、删除

这个删除和上面差不多也是三种情况，这里也是利用递归去查找，就是在最后一种需要注意下，这里是利用左边最大的节点交换，然后进行递归查找，但是需要注意这里需要利用引用传值进行删除。

bool EraseR(const K& key)
    {
        return _EraseR(_root, key);
    }

    bool _EraseR(Node*& root, const K& key)
    {
        if (root == nullptr)
            return false;

        if (root->_key < key)
        {
            return _EraseR(root->_right, key);
        }
        else if (root->_key > key)
        {
            return _EraseR(root->_left, key);
        }
        else
        {
            Node* del = root;

            // 开始准备删除
            if (root->_right == nullptr)
            {
                root = root->_left;
            }
            else if (root->_left == nullptr)
            {
                root = root->_right;
            }
            else
            {
                Node* maxleft = root->_left;
                while (maxleft->_right)
                {
                    maxleft = maxleft->_right;
                }

                swap(root->_key, maxleft->_key);

                return _EraseR(root->_left, key);
            }

            delete del;

            return true;
        }
    }

3、查找

这个递归的查找就是判断，如果没有找到节点为空的时候就返回false，找到了就返回true，然后大于的话就去左边，小于就去右边，如下方代码所示，测试如图。

bool FindR(const K& key)
    {
        return _FindR(_root, key);
    }

    bool _FindR(Node* root, const K& key)
    {
        if (root == nullptr)
            return false;

        if (root->_key == key)
            return true;

        if (root->_key < key)
            return _FindR(root->_right, key);
        else
            return _FindR(root->_left, key);
    }

五、代码

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <vector>
using namespace std;
#include "BSTree.h"

//void Test()
//{
//	int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
//	BSTree<int> t1;
//	
//	for (auto e : a)
//	{
//		t1.Insert(e);
//	}
//	t1.Find(8);
//	t1.InOrder();
//	cout << endl;
//
//	for (auto e : a)
//	{
//		t1.Erase(e);
//		t1.InOrder();
//		cout << endl;
//	}
//
//	t1.InOrder();
//	cout << endl;
//}

void Test()
{
	int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
	BSTree<int> t1;
	
	for (auto e : a)
	{
		t1.InsertR(e);
	}
	cout<<t1.FindR(8)<<endl;
	t1.InOrder();
	cout << endl;

	for (auto e : a)
	{
		t1.EraseR(e);
		t1.InOrder();
		cout << endl;
	}

	t1.InOrder();
	cout << endl;
}

int main()
{
	Test();
	return 0;
}

BSTree.h

#pragma once

template<class T>
struct BSTreeNode
{
	BSTreeNode<T>* _left;
	BSTreeNode<T>* _right;
	T _key;
	BSTreeNode(const T& key)
		:_left(nullptr)
		, _right(nullptr)
		, _key(key)
	{}
};
template<class K>
class BSTree
{
public:
	typedef BSTreeNode<K> Node;
	BSTree() = default; // 制定强制生成默认构造

	BSTree(const BSTree<K>&t)
	{
		_root = Copy(t._root);
	}

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

	~BSTree()
	{
		Destroy(_root);
		//_root = nullptr;
	}
	bool Insert(const K& key)
	{
		if (_root == nullptr)
		{
			_root = new Node(key);
			return true;
		}
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false;
			}
		}
		cur = new Node(key);
		if (parent->_key > key)
		{
			parent->_left = cur;
		}
		else
		{
			parent->_right = cur;
		}
		return true;
	}
	bool Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key > key)
			{
				cur->_left;
			}
			else if(cur->_key<key)
			{
				cur->_right;
			}
			else
			{
				cout << cur->_key << endl;
				return true;
			}
		}
		return false;
	}
	bool Erase(const K& key)
	{
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			//判断找到相等的
			if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else//找到相等了
			{
				//左为空
				if (cur->_left == nullptr)
				{
					if (cur == _root)//如果是根节点,就是左边都是空，只有右边的值
					{
						_root = cur->_right;
					}
					else//不是根节点
					{
						if (parent->_left == cur)//如果cur在父节点的左边，就把cur右边的值托孤给父,如果是空，刚好是空节点给父
						{
							parent->_left = cur->_right;
						}
						else//如果cur在父节点的右边，就把cur左边的值托孤给父
						{
							parent->_right = cur->_right;
						}

					}
					delete cur;
				}
				//右为空
				else if (cur->_right == nullptr)
				{
					if (cur == _root)//如果是根节点,右边都是空，只有左边有值
					{
						_root = cur->_left;
					}
					else//不是根节点
					{
						if (parent->_left = cur)//如果cur在父节点的左边，就把cur右边的值托孤给父,如果是空，刚好是空节点给父
						{
							parent->_left = cur->_left;
						}
						else//如果cur在父节点的右边，就把cur左边的值托孤给父
						{
							parent->_right = cur->_left;
						}

					}
					delete cur;
				}
				else
				{
					// 找右树最小节点替代，也可以是左树最大节点替代
					Node* pminRight = cur;
					Node* minRight = cur->_right;
					while (minRight->_left)
					{
						pminRight = minRight;
						minRight = minRight->_left;
					}

					cur->_key = minRight->_key;

					if (pminRight->_left == minRight)
					{
						pminRight->_left = minRight->_right;
					}
					else
					{
						pminRight->_right = minRight->_right;
					}
					delete minRight;
				}
				return true;
			}
		}
		return false;
	}
	void InOrder()
	{
		_InOrder(_root);
	}
	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;
		_InOrder(root->_left);
		cout << root->_key << ' ';
		_InOrder(root->_right);
	}

	void Destroy(Node*& root)
	{
		if (root == nullptr)
			return;

		Destroy(root->_left);
		Destroy(root->_right);

		delete root;
		root = nullptr;
	}

	bool FindR(const K& key)
	{
		return _FindR(_root, key);
	}

	bool _FindR(Node* root, const K& key)
	{
		if (root == nullptr)
			return false;

		if (root->_key == key)
			return true;

		if (root->_key < key)
			return _FindR(root->_right, key);
		else
			return _FindR(root->_left, key);
	}

	bool InsertR(const K& key)
	{
		return _InsertR(_root, key);
	}

	bool _InsertR(Node*& root, const K& key)
	{
		if (root == nullptr)
		{
			root = new Node(key);
			return true;
		}

		if (root->_key < key)
		{
			return _InsertR(root->_right, key);
		}
		else if (root->_key > key)
		{
			return _InsertR(root->_left, key);
		}
		else
		{
			return false;
		}
	}

	bool EraseR(const K& key)
	{
		return _EraseR(_root, key);
	}

	bool _EraseR(Node*& root, const K& key)
	{
		if (root == nullptr)
			return false;

		if (root->_key < key)
		{
			return _EraseR(root->_right, key);
		}
		else if (root->_key > key)
		{
			return _EraseR(root->_left, key);
		}
		else
		{
			Node* del = root;

			// 开始准备删除
			if (root->_right == nullptr)
			{
				root = root->_left;
			}
			else if (root->_left == nullptr)
			{
				root = root->_right;
			}
			else
			{
				Node* maxleft = root->_left;
				while (maxleft->_right)
				{
					maxleft = maxleft->_right;
				}

				swap(root->_key, maxleft->_key);

				return _EraseR(root->_left, key);
			}

			delete del;

			return true;
		}
	}
private:
	Node* _root = nullptr;
};

六、思维导图

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

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

相关文章

Web前端-Vue组件库Element

Web前端-Vue组件库Element

黑马程序员JavaWeb开发教程 文章目录 一、快速入门&#xff08;1&#xff09;什么是Element&#xff08;2&#xff09;快速入门 二、常见组件1、表格2、分页&#xff08;Pagination&#xff09;3、表单 三、案例&#xff08;1&#xff09;根据页面原型完成员工管理页面开发&…
阅读更多...
vue实现文字转语音的组件，class类封装，实现项目介绍文字播放，不需安装任何包和插件（2024-04-17）

vue实现文字转语音的组件，class类封装，实现项目介绍文字播放，不需安装任何包和插件（2024-04-17）

1、项目界面截图 2、封装class类方法&#xff08;实例化调用&#xff09; // 语音播报的函数 export default class SpeakVoice {constructor(vm, config) {let that thisthat._vm vmthat.config {text: 春江潮水连海平&#xff0c;海上明月共潮生。滟滟随波千万里&#xf…
阅读更多...
MySQL高级（性能分析-查看执行频次、慢查询日志）

MySQL高级（性能分析-查看执行频次、慢查询日志）

目录 1、SQL性能分析 1.1、SQL执行频率 1.2、慢查询日志 1、SQL性能分析 1.1、SQL执行频率 MySQL 客户端连接成功后&#xff0c;通过 show [ session | global ] status 命令可以提供服务器状态信息。通过如下指令&#xff0c;可以查看当前数据库的 insert、update、delete、…
阅读更多...
[CSS]样式属性+元素设置

[CSS]样式属性+元素设置

哎呀&#xff0c;好多东西&#xff0c;根本记不住&#xff0c;更多的还是边用边记吧&#xff0c;这里的代码就当使用范例&#xff0c;但其实如果可以让gpt应该会更好&#xff0c;哎学吧&#xff0c;反正记得住当然更好 文本 属性名描述word-break单词换行。取值如下&#xff1…
阅读更多...
海康威视IPC配置NAS

海康威视IPC配置NAS

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 前言一、安装Samba1.Windows102.Ubuntu-22.04 二、配置IPC总结 前言 简而言之&#xff0c;我手上几个海康威视的IPC都是比较老的设备吧&#xff0c;经过测试不支持…
阅读更多...
【C语言】贪吃蛇项目（1） - 部分Win32 API详解 及 贪吃蛇项目思路

【C语言】贪吃蛇项目（1） - 部分Win32 API详解 及 贪吃蛇项目思路

文章目录 一、贪吃蛇项目需要实现的基本功能二、Win32 API介绍2.1 控制台2.2 部分控制台命令及调用函数mode 和 title 命令COORD 命令GetStdHandle&#xff08;获取数据&#xff09;GetConsoleCursorInfo&#xff08;获取光标数据&#xff09;SetConsoleCursorInfo &#xff08…
阅读更多...
Free day2

Free day2

1.总结串口的发送和接收功能使用到的函数 发送函数&#xff1a;HAL_StatusTypeDef HAL_UART_Transmit(UART_HandleTypeDef *huart, const uint8_t *pData, uint16_t Size, uint32_t Timeout) 参数1&#xff1a;指定要使用的串口 参数2&#xff1a;要发送的数据字节数&#xff…
阅读更多...
VIT论文阅读

VIT论文阅读

论文地址&#xff1a;https://arxiv.org/pdf/2010.11929.pdf VIT论文阅读 摘要INTRODUCTION结论RELATEDWORKMETHOD1.VISIONTRANSFORMER(VIT)整体流程消融实验HEAD TYPE AND CLASSTOKENpoisitional embedding 整体过程公式Inductive biasHybrid Architecture 2.FINE-TUNINGANDH…
阅读更多...
阿里面试：DDD中的实体、值对象有什么区别？

阿里面试：DDD中的实体、值对象有什么区别？

在领域驱动设计&#xff08;DDD&#xff09;中&#xff0c;有两个基础概念&#xff1a;实体&#xff08;Entity&#xff09;和值对象&#xff08;Value Object&#xff09;。 使用这些概念&#xff0c;我们可以把复杂的业务需求映射成简单、明确的数据模型。正确使用实体和值对…
阅读更多...
AI大模型日报#0417：国产音乐SOTA、AI评标师上岗、北大ASC全球超算冠军

AI大模型日报#0417：国产音乐SOTA、AI评标师上岗、北大ASC全球超算冠军

导读&#xff1a; 欢迎阅读《AI大模型日报》&#xff0c;内容基于Python爬虫和LLM自动生成。目前采用“文心一言”生成了每条资讯的摘要。 标题: 首个国产音乐SOTA模型来了&#xff01;专为中文优化&#xff0c;免费用&#xff0c;不限曲风 摘要: 昆仑万维发布「天工3.0」和…
阅读更多...
华为 2024 届实习招聘——硬件-电源机试题（四套）

华为 2024 届实习招聘——硬件-电源机试题（四套）

华为 2024 届实习招聘——硬件-电源机试题&#xff08;四套&#xff09; 部分题目分享&#xff0c;完整版带答案(有答案&#xff0c;答案非官方&#xff0c;未仔细校正&#xff0c;仅供参考&#xff09;&#xff08;共四套&#xff09; 获取&#xff08;WX:didadidadidida313&…
阅读更多...
LeetCode———100——相同的树

LeetCode———100——相同的树

目录 ​编辑 1.题目 2.解答 1.题目 . - 力扣&#xff08;LeetCode&#xff09; 给你两棵二叉树的根节点 p 和 q &#xff0c;编写一个函数来检验这两棵树是否相同。 如果两个树在结构上相同&#xff0c;并且节点具有相同的值&#xff0c;则认为它们是相同的。 示例 1&…
阅读更多...
两台服务器如何超快速互传文件/文件夹【xshell详细版 速度真的超快！】

两台服务器如何超快速互传文件/文件夹【xshell详细版 速度真的超快！】

如果您需要将一台服务器上的资料传到另一台服务器上&#xff0c;您如果老实地先下载文件到本地或者另外一个地方&#xff0c;再上传到另外一台服务器上&#xff0c;那这样也太浪费您宝贵的时间了吧&#xff01;在这里&#xff0c;只需要使用一个简单的命令&#xff0c;即可实现…
阅读更多...
Python 物联网入门指南（八）

Python 物联网入门指南（八）

原文&#xff1a;zh.annas-archive.org/md5/4fe4273add75ed738e70f3d05e428b06 译者&#xff1a;飞龙 协议&#xff1a;CC BY-NC-SA 4.0 第三十章&#xff1a;制作机械臂 最后&#xff0c;我们终于到达了大多数人自本书开始以来就想要到达的地方。制作一个机械臂&#xff01;在…
阅读更多...
【MATLAB源码-第25期】基于matlab的8QAM调制解调仿真，手动实现未调用内置函数，星座图展示。

【MATLAB源码-第25期】基于matlab的8QAM调制解调仿真，手动实现未调用内置函数，星座图展示。

操作环境&#xff1a; MATLAB 2022a 1、算法描述 8QAM调制&#xff08;8 Quadrature Amplitude Modulation&#xff09;是一种数字调制技术&#xff0c;它可以在有限带宽内传输更多的信息比特。在8QAM调制中&#xff0c;每个符号可以携带3个比特的信息。QAM调制是将数字信号…
阅读更多...
充电桩--OCPP 充电通讯协议介绍

充电桩--OCPP 充电通讯协议介绍

一、OCPP协议介绍 OCPP的全称是 Open Charge Point Protocol 即开放充电点协议&#xff0c; 它是免费开放的协议&#xff0c;该协议由位于荷兰的组织 OCA&#xff08;开放充电联盟&#xff09;进行制定。Open Charge Point Protocol (OCPP) 开放充电点协议用于充电站(CS)和任何…
阅读更多...
同城O2O系统开发实战：外卖送餐APP的技术架构与实现

同城O2O系统开发实战：外卖送餐APP的技术架构与实现

今天&#xff0c;我们将深入探讨同城O2O系统开发实战中&#xff0c;外卖送餐APP的技术架构与实现。 一、概述 外卖送餐APP是一种典型的O2O应用&#xff0c;通过移动互联网技术&#xff0c;将用户与商家连接起来&#xff0c;实现用户在线订餐&#xff0c;商家配送服务的模式。…
阅读更多...
JVM 方法调用之方法分派

JVM 方法调用之方法分派

JVM 方法调用之方法分派 文章目录 JVM 方法调用之方法分派1.何为分派2.静态分派3.动态分派4.单分派与多分派5.动态分派的实现 1.何为分派 在上一篇文章《方法调用之解析调用》中讲到了解析调用&#xff0c;而解析调用是一个静态过程&#xff0c;在类加载的解析阶段就确定了方法…
阅读更多...
4.1 返回JSON数据

4.1 返回JSON数据

1. 默认实现方式 JSON是目前主流的前后端数据传输方式&#xff0c;Spring MVC中使用消息转换器HttpMessageConverter对JSON的转换提供了很好的支持&#xff0c;在Spring Boot中更进一步&#xff0c;对相关配置做了更进一步的简化。 默认情况下&#xff0c;当开发者新创建一个S…
阅读更多...
4.17号驱动

4.17号驱动

中断子系统 1. 中断工作原理 1.1 异常处理流程 保存现场(cpu自动完成) 保存cpsr寄存器中的值&#xff0c;到spsr_寄存器中 修改cpsr寄存器中的值 修改状态位(T位) 根据需要禁止相应的中断位(I/F) 修改对应模式位 保存函数的返回地址到lr寄存器中 修改pc指向异常向量表 …
阅读更多...
最新文章

Copyright @ 2022~2023