十七、模拟 实现栈和队列类

最新推荐文章于 2024-10-03 00:32:59 发布
最新推荐文章于 2024-10-03 00:32:59 发布
阅读量797 收藏 20
点赞数 23
分类专栏： C++ 文章标签： c++ 仿函数 优先级队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79989168/article/details/141606488
版权

Ⅰ . 模拟实现 stack

01 实现思路

插入数据删除数据这些逻辑其实没有必要自己实现，而是采用转换的方式

之前我们讲解了适配器的知识，这里采用的就是一些其他的适配的容器去实现

至于转换什么，我们可以进一步想到，好像有很多容器适合去转换

所以 STL 中增加了一个模板参数 Container，利用 Container 来进行转换

上一章末尾，我们利用了 deque 去实现栈和队列

template<class T, class Container = deque<T>>

对于栈而言， push 插入数据就是尾插 push_back，pop 删除数据就是尾删 pop_back

void push(const T& x) {
    _con.push_back(x);    // 对于栈而言，入栈就是尾插
}
void pop() {
    _con.pop_back();      // 对于栈而言，出栈就是尾删
}

返回堆顶数据我们可以用 back，即可返回尾上数据，本质是一种封装

const T& top() {
    return _con.back();  // 返回尾上数据
}

代码实现：

#include<iostream>
#include<deque>
using namespace std;

namespace yxt
{
	template<class T,class Container = deque<T>>
	class stack
	{
	public:
		void push(const T& x)
		{
			_con.push_back(x);
		}

		void pop()
		{
			_con.pop_back();
		}

		const T& top()
		{
			return _con.back();
		}

		size_t size()
		{
			return _con.size();
		}

		bool empty()
		{
			return _con.empty();
		}
	private:
		Container _con;
	};
}

02 代码测试

先使用 deque 去存储

namespace yxt
{
	void test_stack1()
	{
		stack<int> st;
		st.push(1);
		st.push(2);
		st.push(3);
		st.push(4);

		while (!st.empty())
		{
			cout << st.top() << " ";
			st.pop();
		}
		cout << endl;
	}
}

运行结果：

如果不想用 deque ，可以自由的去传

	void test_stack2()
	{
		stack<int, vector<int>> st;
		st.push(1);
		st.push(2);
		st.push(3);
		st.push(4);

		while (!st.empty())
		{
			cout << st.top() << " ";
			st.pop();
		}
		cout << endl;
	}

运行结果如下：

我们试试用 list 可不可行

	void test_stack3()
	{
		stack<int, list<int>> st;
		st.push(1);
		st.push(2);
		st.push(3);
		st.push(4);

		while (!st.empty())
		{
			cout << st.top() << " ";
			st.pop();
		}
		cout << endl;
	}

运行结果如下：

那么是否可以用 string 呢？

勉强可以，但有溢出的风险

	void test_stack4()
	{
		stack<int, string> st;
		st.push(1);
		st.push(2);
		st.push(3);
		st.push(400);

		while (!st.empty())
		{
			cout << st.top() << " ";
			st.pop();
		}
		cout << endl;
	}

运行结果如下：存在截断问题，发生数据丢失

总结：从上层角度看，其默认是一个双端队列，底层用什么去实现并不重要，只要符合要求即可，保存栈的性质，复用容器的代码

我们可以用 const 来限定成员函数，这意味着不能在类对象上调用这些函数来修改内部状态，避免了潜在的危险

namespace yxt
{
	template<class T,class Container = deque<T>>
	class stack
	{
	public:
		void push(const T& x)
		{
			_con.push_back(x);
		}

		void pop()
		{
			_con.pop_back();
		}

		const T& top() const
		{
			return _con.back();
		}

		size_t size() const
		{
			return _con.size();
		}

		bool empty() const
		{
			return _con.empty();
		}
	private:
		Container _con;
	};
}

const T& top() const 中的两个 const 限定符分别适用于不同的情况

① 第一个 const 限定符表示 top 函数不会修改调用它的对象的内部状态，这意味着你可以在一个常量对象上调用 top，而且它不会导致对象的状态被修改，这是对对象的只读

② 第二个 const 限定符表示这个函数返回的引用不能用于修改底层容器 _con 中的元素，这个 const 限定符是用于确保函数不会意外地修改堆栈的底层数据，在这种情况下，它适用于返回类型，表示返回的引用是一个常量引用，不允许修改

这两个 const 限定符的组合是为了提供对堆栈对象的只读访问，并且保护了堆栈的内部数据免受意外的修改

像 size 函数只是返回堆栈的大小，不会修改堆栈的状态或底层容器的内容，因此，只需要在函数声明和定义中使用一个 const 限定符，来确保这个函数不会修改对象的内部状态，足以满足只读访问的要求

Ⅱ . 模拟实现 queue

01 实现思路

其默认容器也是 deque

template<class T, class Container = deque<T>>

queue 是先进先出的，queue 的 push 就是尾插，pop 需要支持头删

void push(const T& x) 
{ 
    _con.push_back(x);  // 进队
}
void pop() 
{ 
    _con.pop_front();   // 出队
}

值得注意的是，queue 不能使用 vector 去适配，因为 vector 没有 push_front 这个接口

front 和 back 直接调对应的接口即可

代码实现：

namespace yxt
{
	template<class T, class Container = deque<T>>
	class queue
	{
	public:
		void push(const T& x)
		{
			_con.push_back(x);
		}

		void pop()
		{
			_con.pop_front();
		}

		const T& front()
		{
			return _con.front();
		}

		const T& back()
		{
			return _con.back();
		}

		size_t size() const 
		{
			return _con.size();
		}

		bool empty() const
		{
			return _con.empty();
		}
	private:
		Container _con;
	};
}

02 代码测试

先使用 deque 去存储

	void test_queue1()
	{
		queue<int> q;
		q.push(1);
		q.push(2);
		q.push(3);
		q.push(4);

		while (!q.empty())
		{
			cout << q.front() << " ";
			q.pop();
		}
		cout << endl;
	}

运行结果如下：

使用 list 去存储：

	void test_queue2()
	{
		queue<int, list<int>> q;
		q.push(1);
		q.push(2);
		q.push(3);
		q.push(4);

		while (!q.empty())
		{
			cout << q.front() << " ";
			q.pop();
		}
		cout << endl;
	}

运行结果如下：

我们试一下，如果使用 vector 会怎么样：

	void test_queue3()
	{
		queue<int, vector<int>> q;
		q.push(1);
		q.push(2);
		q.push(3);
		q.push(4);

		while (!q.empty())
		{
			cout << q.front() << " ";
			q.pop();
		}
		cout << endl;
	}

运行结果如下：

error C2039: "pop_front": 不是 "std::vector<int,std::allocator<T>>" 的成员
1>        with
1>        [
1>            T=int
1>        ]
1>D:\360MoveData\Users\Chaos\Desktop\code2022\2022_7_17\2022_7_17\test.cpp(62): message : 参见“std::vector<int,std::allocator<T>>”的声明
1>        with
1>        [
1>            T=int
1>        ]
1>D:\360MoveData\Users\Chaos\Desktop\code2022\2022_7_17\2022_7_17\test.cpp(14): message : 在编译 类 模板 成员函数“void foxny::queue<int,std::vector<int,std::allocator<T>>>::pop(void)”时……

Ⅲ . 模拟实现 priority_queue

01 实现思路

在优先级队列中，插入数据和删除数据的时间复杂度为 O(logN) 。

默认情况下的优先级队列是大堆，我们先不考虑用仿函数去实现兼容大堆小队排列问题，

我们先去实现大堆，先把基本的功能实现好，带着讲解完仿函数后再去进行优化实现

优先级队列相较于普通的队列，区别主要在 push 和 pop 上

需要在插入和删除的同时，增添调整的功能，并且 STL 的优先级队列是由堆来维护的

void push(const T& x) 
{
    _con.push_back(x);
    AdjustUp(_con.size() - 1);
}

入队时将数据插入后，从最后一个元素开始往上调整

出队时采用堆的删除手法，将根元素（即队头）和最后一个元素进行交换，并调用尾删

既然使用了头尾交换，我们就不得不对队列进行重新调整，所以从根位置进行下调，即可完成出队

void pop() 
{
    assert(!_con.empty());
    swap(_con[0], _con[_con.size() - 1]);
    _con.pop_back();
 
    AdjustDown(0);
}

既然需要上调和下调操作，我们这里先暂时写死，设计成大堆的 AdjustUp 和 AdjustDown

/* 向上调整算法 */
void AdjustUp(size_t child) {
    size_t father = (child - 1) / 2;
    while (child > 0) {
        if (_con[father] < _con[child]) {
            swap(_con[father], _con[child]);
            child = father;
            father = (child - 1) / 2;
        }
        else {
            break;
        }
    }
}
/* 向下调整算法 */
void AdjustDown(size_t father) {
    size_t child = father * 2 + 1; // 默认认为左孩子大
    while (child < _con.size()) {
        // 判断右孩子是否存在，并且是否比左孩子大？
        if (child + 1 < _con.size() && _con[child] < _con[child + 1]) {
            child += 1;
        }
 
        if (_con[father] < _con[child]) {
            swap(_con[father], _con[child]);
            father = child;
            child = father * 2 + 1;
        }
        else {
            break;
        }
    }
}

 剩下的直接使用已有的接口即可

const T& top() {
    return _con[0];
}
 
size_t size() const
{
    return _con.size();
}
 
bool empty() const
{
    return _con.empty();
}

那这里的 top 接口，我们为什么要写成 const T&呢？

① 考虑到这里如果是 string，或更大的对象，传值返回就有一次拷贝构造，减少拷贝构造

② 如果允许随意修改堆顶数据，这是很危险的

02 大堆优先级队列

代码实现：

 

namespace yxt
{
	template<class T, class Container = vector<T>>
	class priority_queue
	{
	public:
        /* 向上调整算法 */
        void AdjustUp(size_t child) 
        {
            size_t father = (child - 1) / 2;
            while (child > 0) 
            {
                if (_con[father] < _con[child]) 
                {
                    swap(_con[father], _con[child]);
                    child = father;
                    father = (child - 1) / 2;
                }
                else 
                {
                    break;
                }
            }
        }
        /* 向下调整算法 */
        void AdjustDown(size_t father) 
        {
            size_t child = father * 2 + 1; // 默认认为左孩子大
            while (child < _con.size())
            {
                // 判断右孩子是否存在，并且是否比左孩子大？
                if (child + 1 < _con.size() && _con[child] < _con[child + 1]) 
                {
                    child += 1;
                }

                if (_con[father] < _con[child]) 
                {
                    swap(_con[father], _con[child]);
                    father = child;
                    child = father * 2 + 1;
                }
                else 
                {
                    break;
                }
            }
        }

        void push(const T& x)
        {
            _con.push_back(x);
            AdjustUp(_con.size() - 1);
        }

        void pop()
        {
            assert(!_con.empty());
            swap(_con[0], _con[_con.size() - 1]);
            _con.pop_back();

            AdjustDown(0);
        }

        const T& top()
        {
            return _con[0];
        }

        size_t size() const
        {
            return _con.size();
        }

        bool empty() const
        {
            return _con.empty();
        }
	private:
		Container _con;
	};
}

测试：

	void test_priority_queue1()
	{
		priority_queue<int> pq;
		pq.push(2);
		pq.push(5);
		pq.push(1);
		pq.push(6);
		pq.push(8);

		while (!pq.empty())
		{
			cout << pq.top() << " ";
			pq.pop();
		}
		cout << endl;
	}

运行结果如下：

我们写死的话，如果想按升序排列，就没办法排了

如果想排升序我们需要写小堆

C++ 在这里有一种叫仿函数的东西，可以帮我们控制这些东西

03 仿函数

使一个类的使用看上去像一个函数，可以像函数一样使用的对象，称为函数对象

其实现就是在类中重载 operator() ，使得该类具备类似函数的行为，就是一个仿函数类了

代码实现：我们写一个最简单的仿函数

namespace yxt 
{
    struct less {
        // 仿函数（函数对象）———— 对象可以像调用函数一样去使用
        bool operator()(int x, int y) {
            return x < y;
        }
    };
 
    void test_functor() {
        less lessCmp;   // 定义一个对象（这里我用小驼峰，能看上去更像函数）
        cout << lessCmp(10, 20) << endl;   // 是对象，但是却能像函数一样去使用
    }
}

运行结果：1

我们定义的 lessCmp 是一个对象，但是我们却可以像使用函数一样给它传递参数

我们还可以使其能够支持泛型，我们加一个 template 模板：

// 支持泛型
template<class T> struct less {
    bool operator()(const T& x, const T& y) const {
        return x < y;
    }
};
 
void test_functor() {
    less<int> lessCmp;
    cout << lessCmp(10, 20) << endl;
}

less 是用来比较谁小的，对应的，我们再实现一个比较谁大的 greater：

// less: 小于的比较
template<class T> struct less {
    bool operator()(const T& x, const T& y) const {
        return x < y;
    }
};
// greater: 大于的比较
template<class T> struct greater {
    bool operator()(const T& x, const T& y) const {
        return x > y;
    }
};
 
void test_functor() {
    less<int> lessCmp;
    cout << lessCmp(10, 20) << endl;
 
    greater<int> GreaterCmp;
    cout << GreaterCmp(10, 20) << endl;
}

运行结果：1 0

一个对象能像函数一样用，看上去很神奇，实际上调用的只是我们重载的 operator() 而已。

这些操作都是归功于运算符重载功能，这就是仿函数！

04 优化后的优先级队列

代码实现：

namespace yxt
{
    // less：小于的比较
    template<class T>
    struct less
    {
        bool operator() (const T& x, const T& y) const
        {
            return x < y;
        }
    };

    // greater：大于的比较
    template<class T>
    struct greater
    {
        bool operator() (const T& x, const T& y) const
        {
            return x > y;
        }
    };

	template<class T, class Container = vector<T>, class Compare = less<T>>
	class priority_queue
	{
	public:
        /* 向上调整算法 */
        void AdjustUp(size_t child) 
        {
            Compare comFunc;

            size_t father = (child - 1) / 2;
            while (child > 0) 
            {
                //if (_con[father] < _con[child]) 
                if(comFunc(_con[father], _con[child]))
                {
                    swap(_con[father], _con[child]);
                    child = father;
                    father = (child - 1) / 2;
                }
                else 
                {
                    break;
                }
            }
        }
        /* 向下调整算法 */
        void AdjustDown(size_t father) 
        {
            Compare comFunc;

            size_t child = father * 2 + 1; // 默认认为左孩子大
            while (child < _con.size())
            {
                // 判断右孩子是否存在，并且是否比左孩子大？
                //if (child + 1 < _con.size() && _con[child] < _con[child + 1]) 
                if (child + 1 < _con.size() && comFunc(_con[child], _con[child + 1]))
                {
                    child += 1;
                }

                //if (_con[father] < _con[child]) 
                if(comFunc(_con[father], _con[child]))
                {
                    swap(_con[father], _con[child]);
                    father = child;
                    child = father * 2 + 1;
                }
                else 
                {
                    break;
                }
            }
        }

        void push(const T& x)
        {
            _con.push_back(x);
            AdjustUp(_con.size() - 1);
        }

        void pop()
        {
            assert(!_con.empty());
            swap(_con[0], _con[_con.size() - 1]);
            _con.pop_back();

            AdjustDown(0);
        }

        const T& top()
        {
            return _con[0];
        }

        size_t size() const
        {
            return _con.size();
        }

        bool empty() const
        {
            return _con.empty();
        }
	private:
		Container _con;
	};
}

测试：

	void test_priority_queue2()
	{
		priority_queue<int, vector<int>, greater<int>> pq;
		pq.push(2);
		pq.push(5);
		pq.push(1);
		pq.push(6);
		pq.push(8);

		while (!pq.empty())
		{
			cout << pq.top() << " ";
			pq.pop();
		}
		cout << endl;
	}

运行结果如下：

这里的仿函数在编译器视角是这样的：

if (cmpFunc(_con[father], _con[child]))
                 👇
if (cmpFunc.operator()(_con[father], _con[child]))
                 👇
 
    // 以 less 为例
    template<class T> 
    struct less {
        bool operator()(const T& x, const T& y) const {
            return x < y;
        }
    };
 
最后返回 _con[father] < _con[child] ，true 还是 false

05 迭代器的实现

        // 创造空的优先级队列
        priority_queue()
            :_con()
        {}

        // 迭代器
        template<class InputIterator>
        priority_queue(InputIterator first, InputIterator last)
            : _con(first, last)
        {
            while (first != last)
            {
                _con.push_back(*first++);
            }

            for (int father = (_con.size() - 1 - 1) / 2; father >= 0; father++)
            {
                AdjustDown(father);
            }
        }

可以拿这个来解决一些问题，比如 Top K

    void test_priority_queue3() 
    {
        // TOP K
        int arr[] = {1,4,2,7,8,9};
        priority_queue<int> pQ(arr, arr + 6);  // 传一个迭代器区间
    }

Ⅳ . 完整代码

01 stack

#pragma once
#include<deque>
using namespace std;

namespace yxt
{
	template<class T,class Container = deque<T>>
	class stack
	{
	public:
		void push(const T& x)
		{
			_con.push_back(x);
		}

		void pop()
		{
			_con.pop_back();
		}

		const T& top() const
		{
			return _con.back();
		}

		size_t size() const
		{
			return _con.size();
		}

		bool empty() const
		{
			return _con.empty();
		}
	private:
		Container _con;
	};
}

02 queue

#pragma once
#include<deque>
using namespace std;

namespace yxt
{
	template<class T, class Container = deque<T>>
	class queue
	{
	public:
		void push(const T& x)
		{
			_con.push_back(x);
		}

		void pop()
		{
			_con.pop_front();
		}

		const T& front()
		{
			return _con.front();
		}

		const T& back()
		{
			return _con.back();
		}

		size_t size() const 
		{
			return _con.size();
		}

		bool empty() const
		{
			return _con.empty();
		}
	private:
		Container _con;
	};
}

03 priority_queue

#pragma once
#include<assert.h>
#include<vector>
#include<functional>
using namespace std;

namespace yxt
{
    // less：小于的比较
    template<class T>
    struct less
    {
        bool operator() (const T& x, const T& y) const
        {
            return x < y;
        }
    };

    // greater：大于的比较
    template<class T>
    struct greater
    {
        bool operator() (const T& x, const T& y) const
        {
            return x > y;
        }
    };

	template<class T, class Container = vector<T>, class Compare = less<T>>
	class priority_queue
	{
	public:
        // 创造空的优先级队列
        priority_queue()
            :_con()
        {}

        // 迭代器
        template<class InputIterator>
        priority_queue(InputIterator first, InputIterator last)
            : _con(first, last)
        {
            while (first != last)
            {
                _con.push_back(*first++);
            }

            for (int father = (_con.size() - 1 - 1) / 2; father >= 0; father++)
            {
                AdjustDown(father);
            }
        }

        /* 向上调整算法 */
        void AdjustUp(size_t child) 
        {
            Compare comFunc;

            size_t father = (child - 1) / 2;
            while (child > 0) 
            {
                //if (_con[father] < _con[child]) 
                if(comFunc(_con[father], _con[child]))
                {
                    swap(_con[father], _con[child]);
                    child = father;
                    father = (child - 1) / 2;
                }
                else 
                {
                    break;
                }
            }
        }
        /* 向下调整算法 */
        void AdjustDown(size_t father) 
        {
            Compare comFunc;

            size_t child = father * 2 + 1; // 默认认为左孩子大
            while (child < _con.size())
            {
                // 判断右孩子是否存在，并且是否比左孩子大？
                //if (child + 1 < _con.size() && _con[child] < _con[child + 1]) 
                if (child + 1 < _con.size() && comFunc(_con[child], _con[child + 1]))
                {
                    child += 1;
                }

                //if (_con[father] < _con[child]) 
                if(comFunc(_con[father], _con[child]))
                {
                    swap(_con[father], _con[child]);
                    father = child;
                    child = father * 2 + 1;
                }
                else 
                {
                    break;
                }
            }
        }

        void push(const T& x)
        {
            _con.push_back(x);
            AdjustUp(_con.size() - 1);
        }

        void pop()
        {
            assert(!_con.empty());
            swap(_con[0], _con[_con.size() - 1]);
            _con.pop_back();

            AdjustDown(0);
        }

        const T& top()
        {
            return _con[0];
        }

        size_t size() const
        {
            return _con.size();
        }

        bool empty() const
        {
            return _con.empty();
        }
	private:
		Container _con;
	};
}
今后123
关注
专栏目录
Java实现栈和队列面试题
09-03
以上就是Java实现栈和队列面试题的主要内容。理解和熟练掌握这些知识点对于Java开发者来说至关重要，因为它们涉及到基础数据结构的运用，能够反映候选人在解决实际问题时的逻辑思维和算法能力。在面试中，候选人可能...
Python实现栈和队列的简单操作方法示例
09-18
本篇文章将深入探讨Python中如何实现栈（Stack）和队列（Queue）这两种基础数据结构。 栈是一种后进先出（Last In, First Out, LIFO）的数据结构，常用于临时存储和快速访问数据。在Python中，由于列表（List）的...
【C++】模拟实现栈和队列
2301_79345909的博客
06-04 1129
上面我们用list实现了栈和队列，但是当我们查看文档时，发现Container用的并不是vector或是list，而是deque那么这个deque又是什么呢？deque(双端队列)：是一种双开口的"连续"空间的数据结构双开口的含义是：可以在头尾两端进行插入和删除操作，且时间复杂度为O(1)它与vector比较，头插效率高，不需要搬移元素；与list比较，空间利用率比较高。
两个栈模拟实现队列
Oliver King 的小窝
09-13 1742
两个栈模拟实现队列
Golang实现数组模拟栈和队列
qq_61453210的博客
05-26 309
栈（Stack）和队列（Queue）是两种常见的数据结构，用于存储和管理数据。
数据结构——Java实现栈和队列
2301_77116754的博客
01-19 855
Java实现栈，Java实现队列，以数组为底层来实现栈和队列，232.用栈实现队列，225.用队列实现栈
【Java数据结构】实现栈和队列
yanxiang3306
10-04 6449
【Java数据结构】实现栈和队列
手把手教你Java实现栈和队列
weixin_73616913的博客
04-25 1142
C选项是不可能做到的，因为如果按照31的顺序出栈，那么2必然先比1出栈。D选项则是先把12入栈，再将34轮流进行出栈入栈的操作后，再将12出栈。B选项是先将1入栈，再将234轮流入栈出栈，最后将1出栈得到的结果。：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出。我们可以发现，A选项中是先将1入栈再出栈，再将234依次入栈后出栈所得到的结果。综上，我们可以得知：通过栈的实现，我们可以将递归转化成循环。我们可以根据栈的先进后出的特性来对其进行分析。
【数据结构】栈和队列（链表模拟队列）
唯有忍受别人不能忍受的，才能享受别人不能享受的
04-18 1008
【适合会C语言选手】【含 gif 动图思路演示】单链表模拟队列：实现 入队push、出队pop、判空empty、队头元素front、队尾元素back 等功能函数、最后精选题【队列实现栈、 栈实现队列 的 LeetCode题：含 gif 动图思路演示】
LinkedList实现栈和队列操作
diweikang的博客
04-09 1505
LinkedList 不仅实现了List接口还实现了Dueue接口（双端队列，既具有队列的特征，也具有栈的特征），Dueue接口是Queue的子接口。它也可以被当作堆栈、队列或双端队列进行操作。 LinkedList 实现 List 接口，能对它进行队列操作。 LinkedList 实现 Deque 接口，能将LinkedList当作双端队列使用。 使用LinkedList实现堆栈 impo...
C++ stack&&queue 栈和队列的使用&&模拟实现
weixin_57761086的博客
10-03 2305
讲解C++的栈和队列的使用与模拟实现。模拟实现中，用文字叙述来帮助读者更好地理解堆和栈的模拟实现。
【C++】STL：栈和队列模拟实现
Renswc的博客
06-03 2381
C++中的stack（栈）和queue（队列）是两种常见的数据结构，用于存储和管理数据。栈是一种先进后出（LIFO）的数据结构，类似于我们平时堆叠的一摞书，只能在顶部进行操作。在C++中，可以使用std::stack模板类来创建栈。栈的主要操作包括压入（push）元素到栈顶、弹出（pop）栈顶元素以及获取栈顶元素等。队列是一种先进先出（FIFO）的数据结构，类似于排队等候的人群，新元素插入队尾，最早插入的元素在队头。在C++中，可以使用std::queue模板类来创建队列。
Java模拟栈和队列数据结构的基本示例讲解共4页.pdf
10-30
本篇文档《Java模拟栈和队列数据结构的基本示例讲解共4页.pdf》将深入浅出地介绍如何在Java中实现栈和队列，以帮助开发者更好地理解和应用这些概念。 首先，让我们来了解栈和队列的基本特性： 1. **栈（Stack）**...
数据结构栈和队列试题及答案
11-26
### 数据结构之栈和队列知识点详解 #### 一、选择题知识点解析 1. **栈的操作原则** 栈是一种特殊的线性表，它只允许在一端进行插入和... 使用S表示入栈操作，X表示出栈操作，这些指令在实现栈的功能时非常重要。
Java模拟栈和队列数据结构的基本示例讲解
09-02
Java中的栈和队列是两种基本的数据结构，...总之，理解和掌握栈和队列的原理以及在Java中的实现方式，对于提升编程能力至关重要。通过实践和运用这些基本数据结构，可以解决很多复杂的问题，提高程序的效率和可读性。
ubuntu22上C/C++程序使用weston+wayland+OpenGLES渲染
Flying_Motor的博客
09-27 473
一，安装依赖软件：sudo apt install zlib1g-dev libssl-dev libgles2-mesa-dev libsystemd-dev libpng-dev libglib2.0-dev libwayland-dev weston libweston-9-dev。
C语言中的日志机制：打造全面强大的日志系统
极客代码
09-30 406
构建一个全面强大的日志机制对于软件开发至关重要。通过上述示例，你应该已经了解了如何在C语言中实现日志记录的不同方面。这种能力对于调试程序、监控应用程序状态和维护系统的稳定性非常有帮助。在软件开发中，良好的日志记录机制对于调试、监控程序状态和维护系统的稳定性至关重要。本文将介绍如何在C语言中构建一个全面强大的日志系统，并提供一些示例代码。实现日志文件的自动旋转，以便管理日志文件的大小。定义日志级别的宏，便于管理和调整日志输出。使用定义好的日志宏来记录日志。实现日志配置的读取和设置。1. 日志的基本概念。
stm32f103调试，程序与定时器同步设置
最新发布
m0_74644005的博客
10-03 244
在调试定时器相关代码时，注意到定时器的中断位总是置1，怀疑代码有问题，经过增大定时器的中断时间，发现定时器与代码调试并不同步，这一点对于调试涉及定时器的代码是非常不利的，这里给出keil调试stm32使定时器与代码同步的设置方法。点击下面的use custom SVD file ,然后点击文件选择，粘贴路径进入，选择调试的芯片，这里使用的使stm32f103，所以选择STM32F103xx.SFR，保存后重启keil，
AI驱动TDSQL-C Serverless数据库技术实战营--- 操作与电商可视分析
chasemydreamidea的博客
09-27 749
本文将基于腾讯云的高性能应用服务HAI和TDSQL-C MYSQL Serverless版构建AI电商数据分析系统。HAI作为一个面向AI和科学计算的GPU应用服务产品，它具有强大的计算能力，让复杂的AI模型的快速部署和运行的可行性加大，进而支持自然语言处理和图形生成等高级任务。TDSQL-C MYSQL版是一款云原生关系型数据库，其100%的MySQL兼容性，以及极致的弹性、高性能和高可用性，是电商业务中处理海量数据存储和查询的理想选择。本文实践除了使用TDSQL-C MYSQL外，通过python语言和
利用列表模拟实现栈和队列
05-31
下面是利用列表模拟实现栈和队列的示例代码： ## 栈 ```python class Stack: def __init__(self): self.stack = [] def push(self, item): self.stack.append(item) def pop(self): if self.is_empty(): ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值