【C++】list的模拟实现来咯

news2024/11/19 14:39:28

文章目录

    • 一、整体框架
    • 二、迭代器
      • 1、list迭代器的引入
      • 2、迭代器的区分
      • 3、list迭代器的实现
      • 4、模板
    • 三、增删查改
      • 1、insert和erase
      • 2、push_back和push_front
      • 3、pop_back和pop_front
    • 四、list的接口
      • 1、构造
      • 2、析构
      • 3、赋值重载
    • 五、list和vector的对比

一、整体框架

list的本质就是带头双向循环链表，我们直接来看一看整体框架：

namespace hwc
{
    //结点
	template<class T>
	struct list_node
	{
		list_node* _next;
		list_node* _prev;
		T _data;

		list_node(const T& x)
			:_next(nullptr)
			, _prev(nullptr)
			, _data(x)
		{}
	};

	template<class T>
	class list
	{
		typedef list_node<T> node;
	public:
        //迭代器
		typedef __list_iterator<T> iterator;
        typedef __list_const_iterator<T> const_iterator;
        //构造
		list()
		{
			_head = new node(T());
			_head->_next = _head;
			_head->_prev = _head;
		}
	private:
		node* _head;
        size_t _size;
	};
}

第一个要实现测试的是push_back，后面可以直接复用insert()：

尾插就是把新结点和原来的尾结点和头结点进行链接，这是我们很熟悉的了，直接动手实现：

void push_back(const T& x)
{
    node* newnode = new node(x);
	node* tail = _head->_prev;
    
	tail->_next = newnode;
	newnode->_prev = tail;
	newnode->_next = _head;
	_head->_prev = newnode;
}

image-20221210091750913

这个接口是最基础的，有了这个接口，我们对于后面的实现更加容易。

二、迭代器

1、list迭代器的引入

把原生指针直接命名为迭代器？迭代器的价值在于封装底层的实现，不具体暴露底层的实现细节，提供统一的访问方式。

对于vector和string类而言，物理空间是连续的，原生的指针就是迭代器了（不一定哦，只是可能，版本可能不同），解引用就是数据了。但是对于这里的list而言，空间是不连续的，我们知道，迭代器有两个特征：1.解引用2.++ /–

此时如果解引用是拿不到数据的（空间不连续），更不用说++指向下一个结点了。所以，对于list的迭代器，原生指针已经不符合我们的需求了，我们需要去进行特殊处理：进行类的封装。我们可以通过类的封装以及运算符重载支持，这样就可以实现像内置类型一样的运算符。

2、迭代器的区分

const迭代器需要在这里重新说明一遍：

//1.const T* p1
list<int>::const_iterator cit = lt.begin();
//2.T* const p2
const list<int>::iterator cit = lt.begin();
//不符合const迭代器的行为，因为保护迭代器本身不能修改，那么我们也就不能++迭代器

灵魂拷问：const迭代器是p1还是p2？p1

const迭代器类似p1的行为，保护指向的对象不被修改，迭代器本身可以修改

3、list迭代器的实现

迭代器的实现我们需要去考虑普通迭代器和const迭代器。这两种迭代器的不同，也会带来不同的接口。我们可以分别单独去进行实现，我们先来看一看简单的构造迭代器，只需要提供一个结点即可,看一看实现的基本框架：

    template<class T>
	struct __list_iterator
	{
		typedef list_node<T> node;
		node* _pnode;

		__list_iterator(node* p)
			:_pnode(p)
		{}
    }

注意：对于迭代器的拷贝构造和赋值重载我们并不需要自己去手动实现，编译器默认生成的就是浅拷贝，而我们需要的就是浅拷贝，这也说明了，并不是说如果有指针就需要我们去实现深拷贝。另外，迭代器通过结构体指针访问修改链表，所以，对于迭代器我们并不需要构造函数，结点的释放由链表管理。

下面，我们来看看迭代器所需要的重载运算符：

重载*

这个比较简单，就是要获取迭代器指向的数据，并且返回数据的引用：

T& operator*()
{
    return _pnode->_data;
}

重载++、–、！=

	   __list_iterator<T>& operator++()
		{
			_pnode = _pnode->_next;
			return *this;
		}

		__list_iterator<T>& operator--()
		{
			_pnode = _pnode->_prev;
			return *this;
		}

		bool operator!=(const __list_iterator<T>& it)
		{
			return _pnode != it._pnode;
		}

如果按照上面的做法，我们在来看看此时普通迭代器和const迭代器的区别：

//typedef __list_iterator<T> iterator;
//typedef __list_const_iterator<T> const_iterator;
    template<class T>
	struct __list_iterator
	{
		typedef list_node<T> node;
		node* _pnode;

		__list_iterator(node* p)
			:_pnode(p)
		{}

		T& operator*()
		{
			return _pnode->_data;
		}

		__list_iterator<T>& operator++()
		{
			_pnode = _pnode->_next;
			return *this;
		}

		__list_iterator<T>& operator--()
		{
			_pnode = _pnode->_prev;
			return *this;
		}

		bool operator!=(const __list_iterator<T>& it)
		{
			return _pnode != it._pnode;
		}
	};

	//跟普通迭代器的区别：遍历，不能用*it修改数据
	template<class T>
	struct __list_const_iterator
	{
		typedef list_node<T> node;
		node* _pnode;

		__list_const_iterator(node* p)
			:_pnode(p)
		{}

		const T& operator*()
		{
			return _pnode->_data;
		}

		__list_const_iterator<T>& operator++()
		{
			_pnode = _pnode->_next;
			return *this;
		}

		__list_const_iterator<T>& operator--()
		{
			_pnode = _pnode->_prev;
			return *this;
		}

		bool operator!=(const __list_const_iterator<T>& it)
		{
			return _pnode != it._pnode;
		}
	};

如果是这样子去实现的话，我们就会发现，这两个迭代器的实现并没有多大的区别，唯一的区别就在于operator*的不同。const迭代器和普通迭代器的唯一区别就是普通迭代器返回T&，可读可写，const迭代器返回const T&,可读不可写，上面的代码存在很大的问题：代码冗余，所以我们应该去解决这个问题：我们可以参考源码的实现：类模板参数解决这个问题，这也是迭代器的强大之处

4、模板

template <class T,class Ref,class Ptr>
//typedef __list_iterator<T, T&, T*> iterator;
//typedef __list_iterator<T, const T&, const T*> const_iterator;

同一个类模板，此时我们传递不同的参数实例化成不同的迭代器了！！！这解决了我们刚刚所说的代码冗余问题。

    //  typedef __list_iterator<T, T&, T*> iterator;
	//  typedef __list_iterator<T, const T&, const T*> const_iterator;
	template<class T, class Ref, class Ptr>
	struct __list_iterator
	{
		typedef list_node<T> node;
		typedef __list_iterator<T, Ref, Ptr> Self;
		node* _pnode;
		__list_iterator(node*p)
			:_pnode(p)
		{
		}
		//返回数据的指针
		Ptr operator->()
		{
			return &_pnode->_data;
		}
		//模板参数做返回值
		Ref operator *()
		{
			return _pnode->_data;
		}

		//++it
		Self& operator ++()
		{
			_pnode = _pnode->_next;
			return *this;
		}

		//it++
		Self operator ++(int)
		{
			Self tmp(*this);
			_pnode = _pnode->_next;
			return tmp;
		}

		Self& operator--()
		{
			_pnode = _pnode->_prev;
			return *this;
		}

		Self operator--(int)
		{
			Self tmp(*this);
			_pnode = _pnode->_prev;
			return tmp;
		}

		bool operator !=(const Self& it)const
		{
			return _pnode != it._pnode;
		}

		bool operator ==(const Self& it)const
		{
			return _pnode == it._pnode;
		}
	};

重载->问题：

对于内置类型我们可以通过*解引用访问数据，但是如果是自定义类型，我们访问其中的成员，就需要重载->:

struct Pos
{
    int _row;
	int _col;
	Pos(int row = 0, int col = 0)
        :_row(row)
		, _col(col)
		{}
};
void test_list()
{
    int x = 5;
    int*p=&x;
    cout<<*p1<<endl;
    list<Pos> lt;
	Pos p1(1, 1);
	lt.push_back(p1);
	lt.push_back(p1);
	lt.push_back(p1);
	lt.push_back(Pos(2, 2));
	lt.push_back(Pos(3, 3));
	list<Pos>::iterator it = lt.begin();
	while (it != lt.end())
    {
        it->_row++;
		//cout << (&(*it))->_row << ":" << (*it)._col << endl;
		cout << it->_row << ":" << it->_col << endl;
		//cout << it.operator->()->_row << ":" << it->_col << endl;
		++it;
    }
    cout << endl;
}

对于内置类型（如上面的int），我们自然可以通过解引用访问。对于结构体指针，我们也可以（*it）对象.去进行访问成员，但是想通过->访问成员，我们就需要去进行重载了：

Ptr operator->()
{
    return &_pnode->_data;
}

image-20221208102139457

实际上本来应该是it->->_row，但是这样写可读性太差，也不好用，所以编译器做了优化，省略了一个->。

三、增删查改

1、insert和erase

insert：在pos位置上一个插入，返回插入位置的迭代器，对于list的insert迭代器不会失效，vector失效是因为扩容导致pos位置造成野指针问题。

		iterator insert(iterator pos,const T& x)
		{
			node* newnode = new node(x);
			node* cur = pos._pnode;
			node* prev = cur->_prev;

			newnode->_prev = prev;
			prev->_next = newnode;
			newnode->_next = cur;
			cur->_prev = newnode;

			++_size;
			return iterator(newnode);
		}

image-20221210092443015

erase:这里的带头（哨兵位）头结点不可删除，返回值是删除位置的下一个，对于list的erase迭代器是失效的

		iterator erase(iterator pos)
		{
			assert(pos != end());
			node* prev = pos._pnode->_prev;
			node* next = pos._pnode->_next;

			prev->_next = next;
			next->_prev = prev;
			delete pos._pnode;
			--_size;
			return iterator(next);
		}

2、push_back和push_front

push_back我们前面已经实现过了，这个地方只需要复用insert即可

        void push_back(const T& x)
		{
			/*node* newnode = new node(x);
			node* tail = _head->_prev;

			newnode->_prev = tail;
			tial->_next = newnode;
			newnode->_next = _head;
			_head->_prev = newnode;*/
			insert(end(), x);
		}

		void push_front(const T& x)
		{
			insert(begin(), x);
		}

对于end和begin的位置：

image-20221210093213762

3、pop_back和pop_front

尾删和头删，复用erase即可

		void pop_front()
		{
			erase(begin());
		}

		void pop_back()
		{
			erase(--end());
		}

这里的尾删刚好用上了我们的重载–

四、list的接口

1、构造

默认构造

list()
{
    _head = new node(T());
	_head->_next = _head;
	_head->_prev = _head;
	_size = 0;
}

我们可以用empty_initialize()来封装初始化，方便复用，不用每次都写：

void empty_initialize()
{
    _head = new node(T());
    _head->_next = _head;
	_head->_prev = _head;
	_size = 0;
}

迭代器区间构造

	    //迭代器区间构造
		template <class InputIterator>
		list(InputIterator first, InputIterator last)
		{
			empty_initialize();
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}

拷贝构造

传统写法

		list(const list<T>& lt)
		{
			empty_initialize();
			for (const auto& e : lt)
			{
				push_back(e);
			}
		}

用范围for进行尾插，但是要注意要加上&，范围for是*it赋值给给e，又是一个拷贝，e是T类型对象，依次取得容器中的数据，T如果是string类型，不断拷贝，push_back之后又销毁。

现代写法

		void swap(list<T>& lt)
		{
			std::swap(_head, lt._head);
			std::swap(_size, lt._size);
		}		
		list(const list<T>& lt)
		{
			empty_initialize();
			list<T> tmp(lt.begin(), lt.end());
			swap(tmp);
		}

2、析构

对于list，有单独的clear()接口，list的析构可以直接复用clear()，同时还需要我们去释放掉头结点：

		~list()
		{
			clear();
            delete _head;
			_head = nullptr;
		}

		void clear()
		{
			iterator it = begin();
			while (it != end())
			{
				it = erase(it);
			}
		}

3、赋值重载

传统写法

		list<T>& operator=(list<T>& lt)
		{
			if (this != &lt)
			{
				clear();
				for (const auto& e : lt)
				{
					push_back(e);
				}
			}
			return *this;
		}

现代写法

		list<T>& operator=(list<T> lt)
		{
			swap(lt);
			return *this;
		}

类名和类型问题

查看官方文档，我们可以看到list没有类型：

image-20221210084548413

list<T>& operator=(list<T> lt)
list& operator=(list lt)

对于普通类：类名等价于类型,对于类模板：类名不等价于类型（如list模板，类名：list 类型：list）

类模板里面可以用类名代表类型，但是并不建议，在类外面则必须要带模板参数list

五、list和vector的对比

vector:vector的优点在于下标的随机访问，尾插尾删效率高，CPU高速缓存命中高。而缺点在于前面部分插入删除数据效率低O(N)，扩容有消耗，还存一定空间浪费。

list:list的优点在于无需扩容，按需申请释放，在任意位置插入删除O(1)。缺点在于不支持下标的随机访问，CPU高速缓存命中低。

vector和list的关系就想是在互补配合！

vectorlist
底 层 结 构动态顺序表，一段连续空间带头结点的双向循环链表
随 机 访 问支持随机访问，访问某个元素效率O(1)不支持随机访问，访问某个元素 效率O(N)
插 入 和 删 除任意位置插入和删除效率低，需要搬移元素，时间复杂 度为O(N)，插入时有可能需要增容，增容：开辟新空 间，拷贝元素，释放旧空间，导致效率更低任意位置插入和删除效率高，不 需要搬移元素，时间复杂度为 O(1)
空 间 利 用 率底层为连续空间，不容易造成内存碎片，空间利用率 高，缓存利用率高底层节点动态开辟，小节点容易 造成内存碎片，空间利用率低， 缓存利用率低
迭 代 器原生态指针对原生态指针(节点指针)进行封装
迭 代 器 失 效在插入元素时，要给所有的迭代器重新赋值，因为插入 元素有可能会导致重新扩容，致使原来迭代器失效，删 除时，当前迭代器需要重新赋值否则会失效插入元素不会导致迭代器失效， 删除元素时，只会导致当前迭代器失效，其他迭代器不受影响
使 用 场 景需要高效存储，支持随机访问，不关心插入删除效率大量插入和删除操作，不关心随 机访问

而对于string的insert和erase迭代器也会失效跟vector类似。但是我们并不太关注。因为string的接口参数大部分是下标支持，迭代器反而用得少。

list.h

#pragma once
namespace hwc
{
	template <class T>
	struct list_node
	{
		list_node<T>* _next;
		list_node<T>* _prev;
		T _data;

		list_node(const T& x)
			:_next(nullptr)
			, _prev(nullptr)
			, _data(x)
		{
		}
	};


	//	typedef __list_iterator<T, T&, T*> iterator;
	//  typedef __list_iterator<T, const T&, const T*> const_iterator;
	template<class T, class Ref, class Ptr>
	struct __list_iterator
	{
		typedef list_node<T> node;
		typedef __list_iterator<T, Ref, Ptr> Self;
		node* _pnode;
		__list_iterator(node*p)
			:_pnode(p)
		{
		}
		//返回数据的指针
		Ptr operator->()
		{
			return &_pnode->_data;
		}
		//模板参数做返回值
		Ref operator *()
		{
			return _pnode->_data;
		}

		//++it
		Self& operator ++()
		{
			_pnode = _pnode->_next;
			return *this;
		}

		//it++
		Self operator ++(int)
		{
			Self tmp(*this);
			_pnode = _pnode->_next;
			return tmp;
		}

		Self& operator--()
		{
			_pnode = _pnode->_prev;
			return *this;
		}

		Self operator--(int)
		{
			Self tmp(*this);
			_pnode = _pnode->_prev;
			return tmp;
		}

		bool operator !=(const Self& it)const
		{
			return _pnode != it._pnode;
		}

		bool operator ==(const Self& it)const
		{
			return _pnode == it._pnode;
		}
	};


	template<class T>
	class list
	{
		typedef list_node<T> node;
	public:
		typedef __list_iterator<T, T&, T*> iterator;
		typedef __list_iterator<T, const T&, const T*> const_iterator;

		const_iterator begin() const
		{
			return const_iterator(_head->_next);
		}

		const_iterator end() const
		{
			return const_iterator(_head);
		}

		iterator begin()
		{
			return iterator(_head->_next);
		}

		iterator end()
		{
			//iterator it(_head);
			//return it;
			return iterator(_head);
		}


		void empty_initialize()
		{
			_head = new node(T());
			_head->_next = _head;
			_head->_prev = _head;

			_size = 0;

		}

		//迭代器区间构造
		template <class InputIterator>
		list(InputIterator first, InputIterator last)
		{
			empty_initialize();
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}

		void swap(list<T>& lt)
		{
			std::swap(_head, lt._head);
			std::swap(_size, lt._size);
		}

		/*list(const list<T>& lt)
		{
			empty_initialize();
			for (const auto& e : lt)
			{
				push_back(e);
			}
		}*/
		list(const list<T>& lt)
		{
			empty_initialize();
			list<T> tmp(lt.begin(), lt.end());
			swap(tmp);
		}

		/*list<T>& operator=(list<T>& lt)
		{
			if (this != &lt)
			{
				clear();
				for (const auto& e : lt)
				{
					push_back(e);
				}
			}
			return *this;
		}*/
		//现代写法
		list<T>& operator=(list<T> lt)
		{
			swap(lt);
			return *this;
		}

		size_t size()const
		{
			return _size;
		}

		bool empty() const
		{
			return _size == 0;
		}

		~list()
		{
			clear();
			delete _head;
			_head = nullptr;
		}

		void clear()
		{
			iterator it = begin();
			while (it != end())
			{
				it = erase(it);
			}
		}

		list()
		{
			empty_initialize();
		}

		void push_back(const T& x)
		{
			/*node* newnode = new node(x);
			node* tail = _head->_prev;

			newnode->_prev = tail;
			tial->_next = newnode;
			newnode->_next = _head;
			_head->_prev = newnode;*/
			insert(end(), x);
		}

		void push_front(const T& x)
		{
			insert(begin(), x);
		}

		void pop_front()
		{
			erase(begin());
		}

		void pop_back()
		{
			erase(--end());
		}

		iterator insert(iterator pos,const T& x)
		{
			node* newnode = new node(x);
			node* cur = pos._pnode;
			node* prev = cur->_prev;

			newnode->_prev = prev;
			prev->_next = newnode;
			newnode->_next = cur;
			cur->_prev = newnode;

			++_size;
			return iterator(newnode);
		}
		
		iterator erase(iterator pos)
		{
			assert(pos != end());
			node* prev = pos._pnode->_prev;
			node* next = pos._pnode->_next;

			prev->_next = next;
			next->_prev = prev;
			delete pos._pnode;
			--_size;
			return iterator(next);
		}
		private:
			node* _head;
			size_t _size;
	};

	void test_list1()
	{
		list<int> lt;
		lt.push_back(1);
		lt.push_back(2);
		lt.push_back(3);
		lt.push_back(4);
		list<int>::iterator it = lt.begin();
		while (it != lt.end())
		{
			cout << *it << " ";
			++it;
		}
		cout << endl;

		for (auto e : lt)
		{
			cout << e << " ";
		}
		cout << endl;
	}

	void test_list2()
	{
		list<int> lt;
		lt.push_back(1);
		lt.push_back(2);
		lt.push_back(3);
		lt.push_back(4);
		lt.push_front(5);
		lt.push_front(6);

		for (auto e : lt)
		{
			cout << e << " ";
		}
		cout << endl;

		lt.pop_back();
		lt.pop_back();
		lt.pop_front();
		lt.pop_front();

		for (auto e : lt)
		{
			cout << e << " ";
		}
		cout << endl;
	}

	void test_list3()
	{
		list<int> lt;
		lt.push_back(1);
		lt.push_back(2);
		lt.push_back(3);
		lt.push_back(4);
		lt.push_front(5);
		lt.push_front(6);

		for (auto e : lt)
		{
			cout << e << " ";
		}
		cout << endl;
		cout << lt.size() << endl;

		list<int> lt1(lt);
		for (auto e : lt1)
		{
			cout << e << " ";
		}
		cout << endl;
		list<int> lt2;
		lt2.push_back(10);
		lt2.push_back(20);
		lt2.push_back(30);
		lt2.push_back(40);
		cout << lt2.size() << endl;

		lt = lt2;
		for (auto e : lt)
		{
			cout << e << " ";
		}
		cout << endl;
	}

	void print_list(const list<int>& lt)
	{
		list<int>::const_iterator it = lt.begin();
		while (it != lt.end())
		{
			// (*it) += 2; // 不能写
			cout << *it << " ";
			++it;
		}
		cout << endl;
	}

	void test_list4()
	{
		list<int> lt1;
		lt1.push_back(1);
		lt1.push_back(2);
		lt1.push_back(3);
		lt1.push_back(4);

		list<int>::iterator it = lt1.begin();
		while (it != lt1.end())
		{
			(*it) += 2;
			cout << *it << " ";
			++it;
		}
		cout << endl;
		print_list(lt1);
	}

	struct Pos
	{
		int _row;
		int _col;

		Pos(int row = 0, int col = 0)
			:_row(row)
			, _col(col)
		{}
	};

	void print_list(const list<Pos>& lt)
	{
		list<Pos>::const_iterator it = lt.begin();
		while (it != lt.end())
		{
			cout << it->_row << ":" << it->_col << endl;
			++it;
		}
		cout << endl;
	}

	void test_list5()
	{
		list<Pos> lt;
		Pos p1(1, 1);
		lt.push_back(p1);
		lt.push_back(p1);
		lt.push_back(p1);
		lt.push_back(Pos(2, 2));
		lt.push_back(Pos(3, 3));
		list<Pos>::iterator it = lt.begin();
		while (it != lt.end())
		{
			it->_row++;
			cout << it->_row << ":" << it->_col << endl;
			++it;
		}
		cout << endl;
		print_list(lt);
	}
}

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

中润光学通过科创板注册：预计年营收4亿 拟募资4亿

中润光学通过科创板注册：预计年营收4亿 拟募资4亿

雷递网 雷建平 12月9日嘉兴中润光学科技股份有限公司&#xff08;简称&#xff1a;“中润光学”&#xff09;日前通过注册&#xff0c;准备在科创板上市。中润光学计划募资4.05亿&#xff0c;其中&#xff0c;2.7亿元用于高端光学镜头智能制造项目&#xff0c;5629万元用于高端…
阅读更多...
【HDU No. 2243】单词情结 考研路茫茫——单词情结

【HDU No. 2243】单词情结 考研路茫茫——单词情结

【HDU No. 2243】单词情结 考研路茫茫——单词情结 杭电OJ 题目地址 【题意】 单词和词根仅由小写字母组成。给定N个词根&#xff0c;求长度不超过L 且至少包含一个词根的单词可能有多少个&#xff1f; 若有两个词根aa和ab&#xff0c;则长度不超过3且至少包含一个词根的单词…
阅读更多...
IO流,,

IO流,,

标题1. 文件基础知识1.1 文件基础知识-文件流1.2 创建文件的3种方式(不是目录)3. 获取文件的相关信息4. 删除文件及创建多级(一极)目录2. IO流原理及流的分类2.1 InputStream 字节输入流2.1.1 FileInputStream2.1.2 FileOutStream2.1.3 拷贝文件2.2 FileReader2.3 FileWriter2.…
阅读更多...
MyCat教程【mysql主从复制实现】

MyCat教程【mysql主从复制实现】

单个mysql数据库在处理业务的时候肯定是有限的&#xff0c;这时我们扩展数据库的第一种方式就是对数据库做读写分离&#xff08;主从复制&#xff09;,本文我们就先来介绍下怎么来实现mysql的主从复制操作。 1. 读写分离 原理&#xff1a;需要搭建主从模式&#xff0c;让主数…
阅读更多...
Python实现房产数据分析与可视化 数据分析 实战

Python实现房产数据分析与可视化 数据分析 实战

Python库的选择 话说&#xff0c;工欲善其事&#xff0c;必先利其器&#xff0c;虽然我们已经选择Python来完成剩余的工作&#xff0c;但是我们需要考虑具体选择使用Pytho的哪些利器来帮助我们更快更好地完成剩余的工作。 我们可以看一下&#xff0c;在这个任务中&#xff0c…
阅读更多...
elasticsearch global 、 filters 和 cardinality 聚合

elasticsearch global 、 filters 和 cardinality 聚合

文章目录1. 背景2、解释1、global2、filters3、cardinality3、需求4、前置条件4.1 创建mapping4.2 准备数据5、实现3的需求5.1 dsl5.2 java 代码5.3 运行结果6、实现代码7、参考文档1. 背景 此处将单记录一下 global 、 filters和cardinality的聚合操作。 2、解释 1、global…
阅读更多...
C++学习笔记(十八)——stack和queue

C++学习笔记(十八)——stack和queue

stack stack的介绍 stack接口的介绍 queue queue的介绍 queue接口的介绍 stack stack的介绍 stack是一种先进后出的容器. stack是一种容器适配器,专门用在具有后进先出(last-in first-out)操作的上下文环境中,其删除只能从容器的一端进行元素的插入与提取操作.stack是作…
阅读更多...
Java——封装——Encapsulation

Java——封装——Encapsulation

封装什么是封装访问权限修饰符导入import一个包package&#xff1f;Static到底是什么面向对象的三大特征&#xff1a;封装、继承、多态。今天我们来浅谈一下封装。什么是封装 我们不用那么专业那么难懂的语言讲解&#xff0c;我们就走一波野路子&#xff1a;封装就是指用priva…
阅读更多...
理想汽车季报图解：营收93亿运营亏损21亿 沈亚楠卸任总裁职务

理想汽车季报图解：营收93亿运营亏损21亿 沈亚楠卸任总裁职务

雷递网 雷建平 12月9日理想汽车&#xff08;纳斯达克&#xff1a;LI&#xff1b;香港交易所&#xff1a;2015&#xff09;今日公布财报。财报显示&#xff0c;理想汽车2022年第三季度营收93.4亿元&#xff08;13.1亿美元&#xff09;&#xff0c;较上年同期的77.8亿元增长20.2%…
阅读更多...
【考研数据】一.2020年BJTU计算机学院考研录取数据分析

【考研数据】一.2020年BJTU计算机学院考研录取数据分析

欢迎订阅本专栏：《北交计算机复试经验》 订阅地址：https://blog.csdn.net/m0_38068876/category_12110003.html 【考研数据】一.2020年BJTU计算机学院考研录取数据分析【考研数据】二.2021年BJTU计算机学院考研录取数据分析【考研数据】三.2022年BJTU计算机学院考研录取数据分…
阅读更多...
vue.js：父子组件的实训案例watch实现

vue.js：父子组件的实训案例watch实现

作业需求 需求1&#xff1a;定义两个输入框&#xff0c;通过输入框输输入的值改变页面显示的值需求2&#xff1a;改变第一个输入框的值的同时使得第二个输入框的值变为100倍并显示需求3&#xff1a;改变第二个输入框的值的同时使得第一个输入框的值变为1/100并显示用watch实现…
阅读更多...
Redis 特性。

Redis 特性。

Remote Dict Serve 分类 实时同步数据 要求缓存中的数据必须与db中的数据保持一致&#xff0c;如何保证&#xff0c;只要DB发生了变化&#xff0c;缓存中的数据立即消息 阶段性缓存为了缓存数据 添加了生存时长属性 Redis 的特性。 性能极高 读的速度 11w/s 写的速度 8w次/s…
阅读更多...
10.spring源码之registerListeners()

10.spring源码之registerListeners()

1. 准备 ApplicationEvent: 事件对象&#xff0c;Spring事件驱动模型中的对象源&#xff0c;继承JDK EventObject&#xff0c;通过在发布事件时通过EventObject.source字段携带事件相关的数据。 ApplicationListener: 应用监听器&#xff0c;负责监听事件对象是否有发生变化&a…
阅读更多...
学习Java8 Stream流，让我们更加便捷的操纵集合

学习Java8 Stream流，让我们更加便捷的操纵集合

1. 概述 本篇文章会简略的介绍一下 Lambda 表达式&#xff0c;然后开启我们的正题 Java8 Stream 流&#xff0c;希望观众老爷们多多支持&#xff0c;并在评论区批评指正! Java8 的 Stream 流使用的是函数式编程模式。它可以被用来对集合或数组进行链状流式的操作&#xff0c;…
阅读更多...
推荐系统基本问题及系统优化路径

推荐系统基本问题及系统优化路径

省时查报告-专业、及时、全面的行研报告库省时查方案-专业、及时、全面的营销策划方案库【免费下载】2022年10月份热门报告盘点大规模推荐类深度学习系统的设计实践.pdf荣耀推荐算法架构演进实践.pdf推荐系统在腾讯游戏中的应用实践.pdf清华大学256页PPT元宇宙研究报告.pdf&…
阅读更多...
产品设计杂感

产品设计杂感

概述 前面多篇文章提过我近一年以来几乎是一个人在负责一款数据产品&#xff0c;一款公司内部使用的报表开发工具。市面上的类似产品如Tableau&#xff0c;QuickBI等。工作角色&#xff08;职责&#xff09;包括&#xff1a;后端开发&#xff0c;前端开发&#xff0c;功能测试…
阅读更多...
STM32 bootloader简单实现的验证

STM32 bootloader简单实现的验证

目录 背景知识 STM32的启动模式 Flash memory的大小 实验验证 分区分配 bootloader代码 systeminit 背景知识 STM32的启动模式 STM32有三种启动模式, 这里验证的bootloader是通过Flash memory启动方式, 使用STM32内置的Flash,其首地址是0x08000000&#xff0c;一般我们…
阅读更多...
[论文阅读] 颜色迁移-梯度保护颜色迁移

[论文阅读] 颜色迁移-梯度保护颜色迁移

[论文阅读] 颜色迁移-梯度保护颜色迁移 文章: [Gradient-Preserving Color Transfer], [代码未公开] 本文目的: 如题所示为梯度保护的颜色迁移方法. 1-算法原理 人类的视觉系统对局部强度差异比强度本身更敏感, 因而, 保持颜色梯度是场景保真度的必要条件, 因而作者认为: 一…
阅读更多...
python+django留守儿童爱心捐赠网站

python+django留守儿童爱心捐赠网站

开发语言&#xff1a;Python 框架&#xff1a;django Python版本&#xff1a;python3.7.7 数据库&#xff1a;mysql 数据库工具&#xff1a;Navicat11 开发软件&#xff1a;PyCharm 目录 1 绪论 1 1.1课题背景 1 1.2课题研究现状 1 1.3初步设计方法与实施方案 2 1.4本文研究…
阅读更多...
城市应急处置系统实施目标

城市应急处置系统实施目标

针对需求分析中的业务目标&#xff0c;本系统在实施中&#xff0c;通过 “两个工作台七个子系统”的目标来支撑业务目标&#xff0c;满足系统延续需求、功能需求、制度建设需求、平台拓展需求和技术性能需求。 具体分为事前6个子系统、事中2个工作台和事后1个子系统这三方面目标…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023