• 哈希表、unordered_map和unordered_set模拟

    目录

    哈希表

    闭散列

    开散列

    unordered_map和unordered_set模拟

    对开散列的哈希表改造

    unordered_set模拟

    unordered_map模拟

    哈希表

    哈希概念：通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。

    ps：该方式即为哈希(散列)方法，哈希方法中使用的转换函数称为哈希(散列)函数，构造出来的结构称为哈希表(Hash Table)(或者称散列表)

    插入元素：根据待插入的元素的关键码，以此函数计算出该元素的存放位置并存放。

    搜索元素：根据元素的关键码，计算出该元素的存放位置，在该位置取元素比较，如果关键码相等，则查找成功。

    哈希冲突：不同关键字通过相同哈希函数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞。

    常见哈希函数----->1. 直接定址法--(常用)2. 除留余数法--(常用)

    解决哈希冲突的常见两种方法：闭散列和开散列

    闭散列

    闭散列：也叫开放定址法，当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然还有 空位置，那么可以把key存放到冲突位置中的“下一个” 空位置中去。

    线性探测：从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。

    1. //线性探测
    2. size_t start = val.first % _ht.size();
    3. size_t i = 0;
    4. size_t index = start;
    5. while (_ht[index]._state == EXIST) {
    6. 	i++;
    7. 	index = start + i;
    8. 	index %= _ht.size();
    9. }

    插入

            1、通过哈希函数获取待插入元素在哈希表中的位置

            2、如果该位置没有元素则直接插入新元素，如果该位置中发生哈希冲突，则使用线性探测找到下一个空位置，插入新元素。

     删除

            采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素会影响其他元素的搜索（ps：因为对于其他元素的查找遇见EMPTY即停止查找）。因此，线性探测采用标记来删除一个元素。

    闭散列实现如下：

    1. template<class K>//仿函数处理key
    2. struct Hash {
    3. 	size_t operator()(const K& key) {
    4. 		return key;
    5. 	}
    6. };
    7. template<>
    8. struct Hash {
    9. 	size_t operator()(const string& s) {
    10. 		size_t value = 0;
    11. 		for (auto e : s) {
    12. 			value *= 31;
    13. 			value += e;
    14. 		}
    15. 		return value;
    16. 	}
    17. };
    18.  
    19. namespace closeHash {
    20. 	enum State {
    21. 		EXIST,
    22. 		DELETE,
    23. 		EMPTY
    24. 	};
    25. 	template<class K,class V>
    26. 	struct HashData {
    27. 		pair _kv;
    28. 		State _state = EMPTY;
    29. 	};
    30. 	template<class K,class V,class HashFunc = Hash>
    31. 	class HashTable {
    32. 	public:
    33. 		bool Erase(const K& key) {
    34. 			HashData* ret = Find(key);
    35. 			if (ret == nullptr)
    36. 				return false;
    37. 			else {
    38. 				_n--;
    39. 				ret->_state = DELETE;
    40. 				return true;
    41. 			}
    42. 		}
    43. 		HashData* Find(const K& key) {
    44. 			if (_table.size() == 0)
    45. 				return nullptr;
    46. 			HashFunc hf;
    47. 			size_t start = hf(key) % _table.size();
    48. 			size_t i = 0;
    49. 			size_t index = start;
    50. 			while (_table[index]._state != EMPTY) {
    51. 				if (_table[index]._kv.first == key && _table[index]._state == EXIST)
    52. 					return &_table[index];
    53. 				i++;
    54. 				index = start + i;
    55. 				index %= _table.size();
    56. 			}
    57. 			return nullptr;
    58. 		}
    59. 		bool Insert(const pair& kv) {
    60. 			HashData* ret = Find(kv.first);
    61. 			if (ret)
    62. 				return false;
    63. 			if (_table.size() == 0 || _n * 10 / _table.size() > 7) {
    64. 				//扩容
    65. 				size_t newSize = _table.size() == 0 ? 10 : _table.size() * 2;
    66. 				HashTable newTable;
    67. 				newTable._table.resize(newSize);
    68. 				for (size_t i = 0; i < _table.size(); i++) {
    69. 					if (_table[i]._state == EXIST)
    70. 						newTable.Insert(_table[i]._kv);
    71. 				}
    72. 				_table.swap(newTable._table);
    73. 			}
    74. 			HashFunc hf;
    75. 			size_t start = hf(kv.first) % _table.size();
    76. 			size_t i = 0;
    77. 			size_t index = start;
    78. 			while (_table[index]._state != EMPTY) {
    79. 				i++;
    80. 				index = start + i;
    81. 				index %= _table.size();
    82. 			}
    83. 			_table[index]._kv = kv;
    84. 			_table[index]._state = EXIST;
    85. 			_n++;
    86. 			return true;
    87. 		}
    88. 	private:
    89. 		vector> _table;
    90. 		size_t _n;
    91. 	};
    92. 	void test() {
    93. 		HashTable<int, int> ht;
    94. 		int a[] = { 2,12,22,32,42,52,62 };
    95. 		for (auto& e : a) {
    96. 			ht.Insert(make_pair(e, e));
    97. 		}
    98. 		ht.Insert(make_pair(72, 72));
    99. 		ht.Insert(make_pair(32, 32));
    100. 		//ht.Insert(make_pair(-1, -1));
    101. 		ht.Insert(make_pair(-999, -999));
    102.  
    103. 		cout << ht.Find(12) << endl;
    104. 		ht.Erase(12);
    105. 		cout << ht.Find(12) << endl;
    106. 	}
    107. }

    开散列

    开散列法又叫链地址法(开链法)，首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。

    开散列的增容：桶的个数是一定的，随着元素的不断插入，每个桶中元素的个数不断增多，极端情况下，可 能会导致一个桶中链表节点非常多，会影响的哈希表的性能，因此在一定条件下需要对哈希 表进行增容，那该条件怎么确认呢？开散列最好的情况是：每个哈希桶中刚好挂一个节点， 再继续插入元素时，每一次都会发生哈希冲突，因此，在元素个数刚好等于桶的个数时，可以给哈希表增容。

    size_t newSize = _table.size() == 0 ? 10 : _table.size() * 2;

    开散列实现如下：

    1. template<class K>//仿函数处理key
    2. struct Hash {
    3. 	size_t operator()(const K& key) {
    4. 		return key;
    5. 	}
    6. };
    7. template<>
    8. struct Hash {
    9. 	size_t operator()(const string& s) {
    10. 		size_t value = 0;
    11. 		for (auto e : s) {
    12. 			value *= 31;
    13. 			value += e;
    14. 		}
    15. 		return value;
    16. 	}
    17. };
    18. namespace openHash {
    19. 	template<class K,class V>
    20. 	struct HashNode {
    21. 		pair _kv;
    22. 		HashNode* _next;
    23. 		HashNode(const pair& kv)
    24. 			:_kv(kv)
    25. 			,_next(nullptr)
    26. 		{}
    27. 	};
    28. 	template<class K,class V,class HashFunc = Hash>
    29. 	class HashBucket {
    30. 		typedef HashNode Node;
    31. 	public:
    32. 		bool Erase(const K& key) {
    33. 			if (_table.empty())
    34. 				return false;
    35. 			HashFunc hf;
    36. 			size_t index = hf(key) % _table.size();
    37. 			Node* cur = _table[index];
    38. 			Node* prev = nullptr;
    39. 			while (cur) {
    40. 				if (cur->_kv.first == key) {
    41. 					if (prev == nullptr)
    42. 						_table[index] = cur->_next;
    43. 					else
    44. 						prev->_next = cur->_next;
    45. 					delete cur;
    46. 					_n--;
    47. 					return true;
    48. 				}
    49. 				prev = cur;
    50. 				cur = cur->_next;
    51. 			}
    52. 			return false;
    53. 		}
    54. 		Node* Find(const K& key) {
    55. 			if (_table.empty())
    56. 				return nullptr;
    57. 			HashFunc hf;
    58. 			size_t index = hf(key) % _table.size();
    59. 			Node* cur = _table[index];
    60. 			while (cur) {
    61. 				if (cur->_kv.first == key)
    62. 					return cur;
    63. 				cur = cur->_next;
    64. 			}
    65. 			return nullptr;
    66. 		}
    67. 		bool Insert(const pair& kv) {
    68. 			Node* ret = Find(kv.first);
    69. 			if (ret)
    70. 				return false;
    71. 			HashFunc hf;
    72. 			if (_n == _table.size()) {
    73. 				//扩容
    74. 				size_t newSize = _table.size() == 0 ? 10 : _table.size() * 2;
    75. 				vector newBucket;
    76. 				newBucket.resize(newSize);
    77. 				for (size_t i = 0; i < _table.size(); i++) {
    78. 					Node* cur = _table[i];
    79. 					while (cur) {
    80. 						Node* next = cur->_next;
    81. 						size_t index = hf(cur->_kv.first) % newBucket.size();
    82. 						cur->_next = newBucket[index];
    83. 						newBucket[index] = cur;
    84.  
    85. 						cur = next;
    86. 					}
    87. 					_table[i] = nullptr;
    88. 				}
    89. 				_table.swap(newBucket);
    90. 			}
    91. 			
    92. 			size_t index = hf(kv.first) % _table.size();
    93. 			Node* newNode = new Node(kv);
    94. 			newNode->_next = _table[index];
    95. 			_table[index] = newNode;
    96. 			_n++;
    97. 			return true;
    98. 		}
    99. 	private:
    100. 		vector _table;
    101. 		size_t _n;
    102. 	};
    103. 	void test() {
    104. 		int a[] = { 4,24,14,7,37,27,57,67,34,14,54 };
    105. 		HashBucket<int, int> ht;
    106. 		for (auto e : a) {
    107. 			ht.Insert(make_pair(e, e));
    108. 		}
    109. 		ht.Insert(make_pair(84, 84));
    110. 	}
    111. }

    unordered_map和unordered_set模拟

    对开散列的哈希表改造

    1、将hashNode中存放的数据类型改为泛型

    1. template<class T>
    2. 	struct HashNode {
    3. 		T _data;
    4. 		HashNode* _next;
    5. 		HashNode(const T& data)
    6. 			:_data(data)
    7. 			,_next(nullptr)
    8. 		{}
    9. 	};

    2、对哈希表增加迭代器

    1. typedef __htIterator iterator;
    2.  
    3.  
    4.  
    5.         iterator begin() {
    6. 			for (size_t i = 0; i < _table.size(); i++) {
    7. 				if (_table[i])
    8. 					return iterator(_table[i], this);
    9. 			}
    10. 			return end();
    11. 		}
    12. 		iterator end() {
    13. 			return iterator(nullptr, this);
    14. 		}

    具体增加的迭代器类如下：

    1. template<class K,class T,class Ref, class Ptr,class KeyOfT,class HashFunc>
    2. 	struct __htIterator {
    3. 		typedef HashNode Node;
    4. 		typedef __htIterator self;
    5.  
    6.         //迭代器的成员变量
    7. 		Node* _node;
    8. 		HashBucket* _pht;
    9.  
    10. 		__htIterator(Node* node,HashBucket* pht)
    11. 			:_node(node)
    12. 			,_pht(pht)
    13. 		{}
    14. 		Ref operator*() {
    15. 			return _node->_data;
    16. 		}
    17. 		Ptr operator->() {
    18. 			return &_node->_data;
    19. 		}
    20. 		self& operator++() {
    21. 			if (_node->_next) {
    22. 				_node = _node->_next;
    23. 			}
    24. 			else {
    25. 				KeyOfT kot;
    26. 				HashFunc hf;
    27. 				size_t index = hf(kot(_node->_data)) % _pht->_table.size();
    28. 				index++;
    29. 				//找到下一个不为空的桶
    30. 				while (index < _pht->_table.size()) {
    31. 					if (_pht->_table[index])
    32. 						break;
    33. 					else
    34. 						index++;
    35. 				}
    36. 				if (index == _pht->_table.size())
    37. 					_node = nullptr;
    38. 				else
    39. 					_node = _pht->_table[index];
    40. 			}
    41. 			return *this;
    42. 		}
    43. 		bool operator==(const self& s) const {
    44. 			return _node == s._node;
    45. 		}
    46. 		bool operator!=(const self& s) const {
    47. 			return _node != s._node;
    48. 		}
    49. 	};

    3、对insert的返回值进行修改，改为pair，方便后续的unordered_map实现operator[]的实现。

    pairbool> Insert(const T& data)

    4、对闭散列增加默认构造、拷贝函数、赋值和以及析构函数

    1. HashBucket() = default;
    2. 		HashBucket(const self& hb) {
    3. 			_table.resize(hb._table.size());
    4. 			for (size_t i = 0; i < hb._table.size(); i++) {
    5. 				Node* cur = hb._table[i];
    6. 				while (cur) {
    7. 					Node* copy = new Node(cur->_data);
    8. 					copy->_next = _table[i];
    9. 					_table[i] = copy;
    10.  
    11. 					cur = cur->_next;
    12. 				}
    13. 			}
    14. 		}
    15.  
    16. 		self& operator=(self hb) {
    17. 			swap(_n, hb._n);
    18. 			_table.swap(hb._table);
    19. 			return *this;
    20. 		}
    21. 		~HashBucket() {
    22. 			for (size_t i = 0; i < _table.size(); i++) {
    23. 				Node* cur = _table[i];
    24. 				while (cur) {
    25. 					Node* next = cur->_next;
    26. 					delete cur;
    27. 					cur = next;
    28. 				}
    29. 				_table[i] = nullptr;
    30. 			}
    31. 		}

    完整的改造代码如下:

    1. namespace openHash {
    2. 	template<class T>
    3. 	struct HashNode {
    4. 		T _data;
    5. 		HashNode* _next;
    6. 		HashNode(const T& data)
    7. 			:_data(data)
    8. 			,_next(nullptr)
    9. 		{}
    10. 	};
    11.  
    12. 	template<class K, class T, class KeyOfT, class HashFunc>
    13. 	class HashBucket;
    14.  
    15. 	template<class K,class T,class Ref, class Ptr,class KeyOfT,class HashFunc>
    16. 	struct __htIterator {
    17. 		typedef HashNode Node;
    18. 		typedef __htIterator self;
    19.  
    20. 		Node* _node;
    21. 		HashBucket* _pht;
    22.  
    23. 		__htIterator(Node* node,HashBucket* pht)
    24. 			:_node(node)
    25. 			,_pht(pht)
    26. 		{}
    27. 		Ref operator*() {
    28. 			return _node->_data;
    29. 		}
    30. 		Ptr operator->() {
    31. 			return &_node->_data;
    32. 		}
    33. 		self& operator++() {
    34. 			if (_node->_next) {
    35. 				_node = _node->_next;
    36. 			}
    37. 			else {
    38. 				KeyOfT kot;
    39. 				HashFunc hf;
    40. 				size_t index = hf(kot(_node->_data)) % _pht->_table.size();
    41. 				index++;
    42. 				//找到下一个不为空的桶
    43. 				while (index < _pht->_table.size()) {
    44. 					if (_pht->_table[index])
    45. 						break;
    46. 					else
    47. 						index++;
    48. 				}
    49. 				if (index == _pht->_table.size())
    50. 					_node = nullptr;
    51. 				else
    52. 					_node = _pht->_table[index];
    53. 			}
    54. 			return *this;
    55. 		}
    56. 		bool operator==(const self& s) const {
    57. 			return _node == s._node;
    58. 		}
    59. 		bool operator!=(const self& s) const {
    60. 			return _node != s._node;
    61. 		}
    62. 	};
    63.  
    64. 	template<class K,class T,class KeyOfT,class HashFunc>
    65. 	class HashBucket {
    66. 		typedef HashNode Node;
    67.  
    68. 		template<class K, class T, class Ref, class Ptr, class KeyOfT, class HashFunc>
    69. 		friend struct __htIterator;
    70.  
    71. 		typedef HashBucket self;
    72. 	public:
    73. 		typedef __htIterator iterator;
    74.  
    75. 		/*HashBucket() {
    77. 		}*/
    78.  
    79. 		HashBucket() = default;
    80. 		HashBucket(const self& hb) {
    81. 			_table.resize(hb._table.size());
    82. 			for (size_t i = 0; i < hb._table.size(); i++) {
    83. 				Node* cur = hb._table[i];
    84. 				while (cur) {
    85. 					Node* copy = new Node(cur->_data);
    86. 					copy->_next = _table[i];
    87. 					_table[i] = copy;
    88.  
    89. 					cur = cur->_next;
    90. 				}
    91. 			}
    92. 		}
    93.  
    94. 		self& operator=(self hb) {
    95. 			swap(_n, hb._n);
    96. 			_table.swap(hb._table);
    97. 			return *this;
    98. 		}
    99. 		~HashBucket() {
    100. 			for (size_t i = 0; i < _table.size(); i++) {
    101. 				Node* cur = _table[i];
    102. 				while (cur) {
    103. 					Node* next = cur->_next;
    104. 					delete cur;
    105. 					cur = next;
    106. 				}
    107. 				_table[i] = nullptr;
    108. 			}
    109. 		}
    110. 		iterator begin() {
    111. 			for (size_t i = 0; i < _table.size(); i++) {
    112. 				if (_table[i])
    113. 					return iterator(_table[i], this);
    114. 			}
    115. 			return end();
    116. 		}
    117. 		iterator end() {
    118. 			return iterator(nullptr, this);
    119. 		}
    120. 		bool Erase(const K& key) {
    121. 			if (_table.empty())
    122. 				return false;
    123. 			HashFunc hf;
    124. 			size_t index = hf(key) % _table.size();
    125. 			Node* cur = _table[index];
    126. 			Node* prev = nullptr;
    127. 			KeyOfT kot;
    128. 			while (cur) {
    129. 				if (kot(cur->_data) == key) {
    130. 					if (prev == nullptr)
    131. 						_table[index] = cur->_next;
    132. 					else
    133. 						prev->_next = cur->_next;
    134. 					delete cur;
    135. 					_n--;
    136. 					return true;
    137. 				}
    138. 				prev = cur;
    139. 				cur = cur->_next;
    140. 			}
    141. 			return false;
    142. 		}
    143. 		iterator Find(const K& key) {
    144. 			if (_table.empty())
    145. 				return end();
    146. 			HashFunc hf;
    147. 			size_t index = hf(key) % _table.size();
    148. 			Node* cur = _table[index];
    149. 			KeyOfT kot;
    150. 			while (cur) {
    151. 				if (kot(cur->_data) == key)
    152. 					return iterator(cur, this);
    153. 				cur = cur->_next;
    154. 			}
    155. 			return end();
    156. 		}
    157. 		pairbool> Insert(const T& data) {
    158. 			KeyOfT kot;
    159. 			iterator ret = Find(kot(data));
    160. 			if (ret != end())
    161. 				return make_pair(ret, false);
    162. 			HashFunc hf;
    163. 			
    164. 			if (_n == _table.size()) {
    165. 				//扩容
    166. 				size_t newSize = _table.size() == 0 ? 10 : _table.size() * 2;
    167. 				vector newBucket;
    168. 				newBucket.resize(newSize);
    169. 				for (size_t i = 0; i < _table.size(); i++) {
    170. 					Node* cur = _table[i];
    171. 					while (cur) {
    172. 						Node* next = cur->_next;
    173. 						size_t index = hf(kot(cur->_data)) % newBucket.size();
    174. 						cur->_next = newBucket[index];
    175. 						newBucket[index] = cur;
    176.  
    177. 						cur = next;
    178. 					}
    179. 					_table[i] = nullptr;
    180. 				}
    181. 				_table.swap(newBucket);
    182. 			}
    183. 			
    184. 			size_t index = hf(kot(data)) % _table.size();
    185. 			Node* newNode = new Node(data);
    186. 			newNode->_next = _table[index];
    187. 			_table[index] = newNode;
    188. 			_n++;
    189. 			return make_pair(iterator(newNode, this), true);
    190. 		}
    191. 	private:
    192. 		vector _table;
    193. 		size_t _n = 0;
    194. 	};
    195. }

    unordered_set模拟

    unordered_set的底层使用的就是我们改造的开散列哈希表，因为改造的时候将hashnode中存放的数据改为了泛型，所以需要我们传入一个仿函数（这里我们传入的是SetKeyOfT这个函数），让哈希表拿到unordered_set的key，进行后续的逻辑操作。

    除了SetKeyOfT这个仿函数，我们还需要另一个仿函数，即hash = Hash，这个仿函数的作用是当我们通过SetKeyOfT拿到hashnode中的数据中的key值之后，将key的值转换成能够取模的整形。

    1. #pragma once
    2. #include "HTable.h"
    3.  
    4. namespace hzp {
    5. 	template<class K, class hash = Hash>
    6. 	class My_Unordered_Set {
    7. 		struct SetKeyOfT {
    8. 			const K& operator()(const K& key) {
    9. 				return key;
    10. 			}
    11. 		};
    12. 	public:
    13. 		typedef typename openHash::HashBucket::iterator iterator;
    14. 		iterator begin() {
    15. 			return _hb.begin();
    16. 		}
    17. 		iterator end() {
    18. 			return _hb.end();
    19. 		}
    20. 		pairbool> insert(const K& key) {
    21. 			return _hb.Insert(key);
    22. 		}
    23. 	private:
    24. 		openHash::HashBucket _hb;
    25. 	};
    26. 	void test_set() {
    27. 		My_Unordered_Set<int> mus;
    28. 		int a[] = { 4,14,34,7,24,17 };
    29. 		for (auto e : a)
    30. 			mus.insert(e);
    31.  
    32. 		My_Unordered_Set<int>::iterator it = mus.begin();
    33. 		while (it != mus.end()) {
    34. 			cout << *it << " ";
    35. 			++it;
    36. 		}
    37. 		cout << endl;
    38.  
    39. 		My_Unordered_Set uss;
    40. 		uss.insert("sort");
    41. 		uss.insert("hash");
    42. 	}
    43. }

    unordered_map模拟

    unordered_map的模拟与unordered_set的模拟极为相似，底层也是使用的改造的开散列的哈希表。请参考unordered_set的模拟读下边的代码。

    1. #pragma once
    2. #include "HTable.h"
    3.  
    4. namespace hzp {
    5. 	template<class K, class V, class hash = Hash>
    6. 	class My_Unordered_Map {
    7. 		struct MapKeyOfT {
    8. 			const K& operator()(const pair& key) {
    9. 				return key.first;
    10. 			}
    11. 		};
    12. 	public:
    13. 		typedef typename openHash::HashBucket, MapKeyOfT, hash>::iterator iterator;
    14. 		iterator begin() {
    15. 			return hb.begin();
    16. 		}
    17. 		iterator end() {
    18. 			return hb.end();
    19. 		}
    20. 		V& operator[](const K& key) {
    21. 			auto ret = hb.Insert(make_pair(key, V()));
    22. 			return ret.first->second;
    23. 		}
    24. 		pairbool> insert(const pair& kv) {
    25. 			return hb.Insert(kv);
    26. 		}
    27.  
    28. 	private:
    29. 		openHash::HashBucket, MapKeyOfT, hash> hb;
    30. 	};
    31. 	void test_map() {
    32. 		My_Unordered_Map dict;
    33. 		dict.insert(make_pair("sort", "排序"));
    34. 		dict.insert(make_pair("string", "ַ字符串"));
    35. 		dict.insert(make_pair("map", "地图"));
    36.  
    37. 		dict["sort"] = "排序1";
    38. 		cout << dict["sort"] << endl;
    39. 		My_Unordered_Map::iterator it = dict.begin();
    40. 		while (it != dict.end())
    41. 		{
    42. 			cout << it->first << ":" << it->second << endl;
    43. 			++it;
    44. 		}
    45. 		cout << endl;
    46.  
    47. 		My_Unordered_Map copy(dict);
    48. 		for (auto& e : copy) {
    49. 			cout << e.first << ":" << e.second << endl;
    50. 		}
    51. 	}
    52. }

  • 相关阅读:
    HTML中文本框\单选框\按钮\多选框
    Kafka实战 - 03 Kafka消费消息实现数据的处置状态同步
    金额转大写查询易语言代码
    基于springboot用户信息增删改查源码【附源码】
    webSocket的通信流程，以及对网络等错误的处理
    opensips的dispatcher模块笔记
    数组名是什么
    深入剖析JavaScript（二）——异步编程
    GPS学习（一）：在ROS2中将GPS经纬度数据转换为机器人ENU坐标系，在RVIZ中显示坐标轨迹
    NFTScan | 10.02~10.08 NFT 市场热点汇总
  • 原文地址：https://blog.csdn.net/qq_45576085/article/details/130838540