模板实现栈队列以及链表
2024-05-19 09:49:19
模板实现链表
//test.h
#include <iostream>
#include <cstdio>
#include <assert.h>
using namespace std;template <class T>
struct ListNode
{ListNode* _prev;ListNode* _next;T _data;ListNode(const T& x):_prev(NULL),_next(NULL),_data(x){}
};template <class T>
class List
{typedef ListNode<T> Node;
public:List();~List();//l(l1)//l.List(this, l1)List(const List<T>& l);List<T>& operator = (const List<int>& l);void Clean();void Insert(Node* pos, const T& x);void Erase(Node* pos);void PushFront(T x);void PushBack(T x);void PopBack();void PopFront();void Print();
protected:Node* _head;
};//test.cc
#include "test.h"
template <class T>
List <T>::List()
{_head = new Node(T());_head -> _next = _head;_head -> _prev = _head;
}template <class T>
List <T>::~List()
{Clean();delete _head;
}//l(l1)
//l.List(this, l1)
template <class T>
List<T>::List(const List<T>& l)
{_head = new Node(T());_head -> _next = _head -> _prev = _head;Node* cur = l._head -> _next;while(cur != l._head){PushBack(cur -> _data);cur = cur -> _next;}
}template <class T>
List <T>& List <T>::operator = (const List<int>& l)
{_head = l._head;return *this;
}template <class T>
void List <T>::Clean()
{Node* cur = _head -> _next;while(cur != _head){Node* next = cur -> _next;delete cur;cur = next;}
}template <class T>
void List <T>::Insert(Node* pos, const T& x)
{assert(pos);Node* new_node = new Node(x);Node* prev = pos -> _prev;Node* next = pos;new_node -> _next = next;next -> _prev = new_node;prev -> _next = new_node;new_node -> _prev = prev;
}template <class T>
void List <T>::Erase(Node* pos)
{assert(pos != _head);Node* prev = pos -> _prev;Node* next = pos -> _next;prev -> _next = next;next -> _prev = prev;delete [] pos;
}template <class T>
void List <T>::PushFront(T x)
{Insert(_head -> _next, x);
}template <class T>
void List <T>::PushBack(T x)
{Insert(_head -> _prev -> _next, x);
}template <class T>
void List <T>::PopBack()
{Erase(_head -> _prev);
}template <class T>
void List <T>::PopFront()
{Erase(_head -> _next);
}template <class T>
void List <T>::Print()
{Node* cur = _head -> _next;while(cur != _head){cout << cur -> _data << " ";cur = cur -> _next;}cout << endl;
}模板实现队列
//test.cc
#include "test.h"template <class T>
Vector<T>::Vector():_start(NULL),_finish(NULL),_endofstorage(NULL)
{
}template <class T>
//v1(v)
Vector <T>::Vector(const Vector <T>& v)
{size_t size = v.Size();T* start = new T[size];delete [] _start;_start = start;_finish = _start + size;_endofstorage = _start + v.Capacity;
}template <class T>
Vector <T>& Vector <T>::operator = (const Vector <T>& v)
{swap(_start, v._start);swap(_finish, v._start);swap(_endofstorage, v._endofstorage);return *this;
}template <class T>
void Vector <T>::Expand(size_t new_capacity)
{if(new_capacity > Capacity()){size_t size = Size();T* tmp = new T[new_capacity];if(_start){for(int i = 0; i < (int)size; i++){tmp[i] = _start[i]; }delete [] _start;}_start = tmp;_finish = _start + size;_endofstorage = _start + new_capacity;}
}template <class T>
void Vector <T>::Reserve(size_t size)
{Expand(size);
}template <class T>
const T& Vector <T>::operator [] (size_t pos)const
{return _start[pos];
}
template <class T>
size_t Vector <T>:: Size()
{return _finish - _start;
}template <class T>
void Vector <T>::Insert(size_t pos, const T& x)
{assert(pos <= Size());if(_finish == _endofstorage){size_t new_capacity = Capacity() == 0 ? 3 : Capacity() * 2;Expand(new_capacity);}T* end = _finish - 1;while(end >= _start + pos){*(end + 1) = *end; --end;}*end = x;++_finish;
}template <class T>
void Vector <T>::PushFront(const T& x)
{if(Size() == Capacity()){size_t new_capacity = Capacity() == 0 ? 3 : 2 * Capacity();Expand(new_capacity);}T* end = _finish;for(; end >= _start; --end){*(end + 1) = *(end);}*_start = x;++_finish;
}
template <class T>
void Vector <T>::PushBack(const T& x)
{if(_finish == _endofstorage){size_t new_capacity = Capacity() == 0 ? 3 : 2 * Capacity();Expand(new_capacity);}*_finish = x;++_finish;
}template <class T>
void Vector <T>::Erase(size_t pos)
{assert(pos < Size());T* start = _start + pos;while(start < _finish)// TODO{*start = *(start + 1);start++;}--_finish;
}template <class T>
void Vector <T>::ReSize(size_t size, const T& value)
{Expand(size);memset(_start, value, sizeof(T) * size);
}template <class T>
size_t Vector <T>::Capacity()
{return _endofstorage - _start;
}template <class T>
Vector <T> ::~Vector()
{if(_start){delete [] _start;}
}template <class T>
bool Vector <T> ::Empty()
{return _start == _finish;
}template <class T>
void Vector<T>::PopBack()
{Erase(Size() - 1);
}template <class T>
void Vector <T>::PopFront()
{Erase(0);
}template <class T, class Container>
void Queue <T, Container>::Push(const T& x)
{_con.PushBack(x);
}template <class T, class Container>
void Queue<T, Container>::Pop()
{_con.PopFront();
}template <class T>
T& Vector<T>::Front()
{if(_start != NULL){return *_start;}
}template <class T, class Container>
T& Queue <T, Container>::Front()
{return _con.Front();
}template <class T, class Container>
bool Queue <T, Container>::Empty()
{return _con.Empty();
}
//test.h
#include <iostream>
#include <cstdio>
#include <assert.h>
#include <string.h>
using namespace std;#define TESTHEADER printf("\n==============%s===========\n", __FUNCTION__)template <class T>
class Vector
{
public:Vector();~Vector();Vector(const Vector <T>& v);Vector& operator = (const Vector <T>& v);void Reserve(size_t size);void ReSize(size_t size, const T& value = T());const T& operator [] (size_t pos) const;void Insert(size_t pos, const T& x);void PushFront(const T& x);void PushBack(const T& x);void Erase(size_t pos);size_t Capacity();bool Empty();size_t Size();void PopBack();void PopFront();T& Front();
protected:void Expand(size_t size);
protected:T* _start;T* _finish;T* _endofstorage;
};template <class T, class Container>
class Queue
{
public:void Push(const T& x);void Pop();T& Front();bool Empty();
protected:Container _con;
};模板实现栈
//test.h
#include <iostream>
#include <cstdio>
#include <assert.h>
#include <string.h>
using namespace std;#define TESTHEADER printf("\n==================%s==================\n", __FUNCTION__)
template <class T>
class Vector
{
public:Vector();~Vector();Vector(const Vector <T>& v);Vector& operator = (const Vector <T>& v);void Reserve(size_t size);void ReSize(size_t size, const T& value = T());const T& operator [] (size_t pos) const;void Insert(size_t pos, const T& x);void PushFront(const T& x);void PushBack(const T& x);void Erase(size_t pos);size_t Capacity();bool Empty();size_t Size();void PopBack();void PopFront();const T& Back();
protected:void Expand(size_t size);
protected:T* _start;T* _finish;T* _endofstorage;
};template<class T, class Container>
class Stack
{
public:void Push(const T& x);void Pop();const T& Top();bool Empty();
protected:Container _con;
};
//test.cc
#include "test.h"
template <class T>
Vector<T>::Vector():_start(NULL),_finish(NULL),_endofstorage(NULL)
{
}template <class T>
//v1(v)
Vector <T>::Vector(const Vector <T>& v)
{size_t size = v.Size();T* start = new T[size];delete [] _start;_start = start;_finish = _start + size;_endofstorage = _start + v.Capacity;
}template <class T>
Vector <T>& Vector <T>::operator = (const Vector <T>& v)
{swap(_start, v._start);swap(_finish, v._start);swap(_endofstorage, v._endofstorage);return *this;
}template <class T>
void Vector <T>::Expand(size_t new_capacity)
{if(new_capacity > Capacity()){size_t size = Size();T* tmp = new T[new_capacity];if(_start){for(int i = 0; i < (int)size; i++){tmp[i] = _start[i]; }delete [] _start;}_start = tmp;_finish = _start + size;_endofstorage = _start + new_capacity;}
}template <class T>
void Vector <T>::Reserve(size_t size)
{Expand(size);
}template <class T>
const T& Vector <T>::operator [] (size_t pos)const
{return _start[pos];
}
template <class T>
size_t Vector <T>:: Size()
{return _finish - _start;
}template <class T>
void Vector <T>::Insert(size_t pos, const T& x)
{assert(pos <= Size());if(_finish == _endofstorage){size_t new_capacity = Capacity() == 0 ? 3 : Capacity() * 2;Expand(new_capacity);}T* end = _finish - 1;while(end >= _start + pos){*(end + 1) = *end; --end;}*end = x;++_finish;
}template <class T>
void Vector <T>::PushFront(const T& x)
{if(Size() == Capacity()){size_t new_capacity = Capacity() == 0 ? 3 : 2 * Capacity();Expand(new_capacity);}T* end = _finish;for(; end >= _start; --end){*(end + 1) = *(end);}*_start = x;++_finish;
}
template <class T>
void Vector <T>::PushBack(const T& x)
{if(_finish == _endofstorage){size_t new_capacity = Capacity() == 0 ? 3 : 2 * Capacity();Expand(new_capacity);}*_finish = x;++_finish;
}template <class T>
const T& Vector<T>::Back()
{return _start[Size() - 1];
}template <class T>
void Vector <T>::Erase(size_t pos)
{assert(pos < Size());T* start = _start + pos;while(start < _finish)// TODO{*start = *(start + 1);start++;}--_finish;
}template <class T>
void Vector <T>::ReSize(size_t size, const T& value)
{Expand(size);memset(_start, value, sizeof(T) * size);
}template <class T>
size_t Vector <T>::Capacity()
{return _endofstorage - _start;
}template <class T>
Vector <T> ::~Vector()
{if(_start){delete [] _start;}
}template <class T>
bool Vector <T> ::Empty()
{return _start == _finish;
}template <class T>
void Vector<T>::PopBack()
{Erase(Size() - 1);
}template <class T>
void Vector <T>::PopFront()
{Erase(0);
}///////////////////////////////////////////////////////////////////////////////////////////////
//模板参数实现容器适配器
///////////////////////////////////////////////////////////////////////////////////////////////template<class T, class Container>
void Stack<T, Container>::Push(const T& x)
{_con.PushFront(x);
}template<class T, class Container>
void Stack<T, Container>::Pop()
{_con.PopBack();
}template<class T, class Container>
bool Stack<T, Container>::Empty()
{_con.Empty();
}template<class T, class Container>
const T& Stack<T, Container>::Top()
{return _con.Back();
}模板实现栈队列以及链表相关推荐
- 栈,队列和链表三者之间的关系与区别
最近一直在学习算法,刷算法题,但是自从大学毕业以来,数据结构的知识都还给老师了,只会个数组,所以前期刷的题目也都是有关数组的 最近跟着小册重学了一遍数据结构,今天就记录一下栈,队列和链表三者之间的关系 ...
- 常见的数据结构：栈 队列 数组 链表 红黑树——List集合 _ HashSet集合、可变参数 collections集合 Map集合
2021-06-07复习java 一.常见的数据结构 栈(先进后出) 队列 数组 链表 红黑树 二.List集合_介绍&常用方法 ArrayList集合 Linkedlist集合 三.Hash ...
- 常见数据结构-栈-队列-数组-链表-哈希表
数据结构 数据结构是计算机存储.组织数据的方式.是指相互之间存在一种或多种特定关系的数据元素的集合 通常情况下,精心选择的数据结构可以带来更高的运行或者存储效率 持续更新,学一个记一个- 栈 ...
- Java集合常见数据结构-栈/队列/数组/链表/红黑树
数组 链表 红黑树
- 数据结构栈队列链表数组
目录: 数据结构 栈(stack) 队列 链表 数组 数据结构 数据结构是什么 简单来说,数据结构就是设计数据以何种方式存储在计算机中 比如:列表,集合,与字典等都是一种数据结构 程序 = 数据结构 ...
- 黑马程序员 C语言数据结构与算法之线性表（链表/栈/队列/顺序表）
C语言 链表基础知识清晰讲解(黑马) 讲的蛮好,就是音质不太好,有时听不清讲的啥! [黑马]数据结构与算法之线性表(链表/栈/队列/顺序表)[配套源码 嘛蛋,看错了,这是java的... 文章目录 链 ...
- 常见数据结构和算法实现(排序/查找/数组/链表/栈/队列/树/递归/海量数据处理/图/位图/Java版数据结构)
常见数据结构和算法实现(排序/查找/数组/链表/栈/队列/树/递归/海量数据处理/图/位图/Java版数据结构) 数据结构和算法作为程序员的基本功,一定得稳扎稳打的学习,我们常见的框架底层就是各类数据 ...
- 面试必备：高频算法题汇总「图文解析 + 教学视频 + 范例代码」必问之 链表 + 栈 + 队列 部分！
链表 链表是最基本的数据结构,面试官也常常用链表来考察面试者的基本能力,而且链表相关的操作相对而言比较简单,也适合考察写代码的能力.链表的操作也离不开指针,指针又很容易导致出错. 综合多方面的原因,链 ...
- c语言用两个栈构造队列伪码,数据结构习题线性表栈队列.doc
数据结构习题线性表栈队列 线性表(58) 1. 在单链表.双链表和单循环链表中,若仅知道指针p指向某结点,不知道头指针,能否将结点*p从相应的链表中删去?若可以,其时间复杂度各为多少? 2．设线性表的 ...
最新文章
- Geomagic Freeform Plus 2019中文版
- 团队开发git使用各种问题
- python 中 __name__ 的使用
- pb 执行存储过程带参数_PB级海量数据服务平台架构设计实践
- ubuntu(deepin)安装apache2并支持php7.0
- Android通过包名启动应用程序
- [CDQ][最小生成树]2018 [HNOI2010]CITY 城市建设
- 通过Redis入侵服务器
- Windows“控制面板”在哪?win10怎么打开控制面板(快捷方法)打开控制面板的多种方法都在这里
- 安卓从入门到进阶第一篇（环境搭建）
- MDC 实现 traceId 记录
- EVM 操作码（Opcode）与 字节码（Bytecode）
- 【数据库】GaussDB
- JavaBean之Builder模式
- 【5年Android从零复盘系列之二十】Android自定义View(15)：Matrix详解(图文)【转载】
- 同程旅游微服务最佳实践
- 人工智能除了下围棋还能干啥？
- win10 安装下载jupyter lab
- Poco库使用:事件通知
- gow在windows上使用的linux shell命令,Windows模拟linux终端工具Cmder+Gow