체인 템플릿, 대기열 템플릿, 순서표 템플릿, 창고 템플릿,
11100 단어 순서체인 테이블 템플릿대기열 템플릿
//
#pragma once
#include
#include
#include
using namespace std;
template
struct Node
{
public:
Node(const T& d)
:_next(NULL)
, _prev(NULL)
,_data(d){}
T _data;
Node *_next;
Node *_prev;
};
template
class LinkList
{
public:
LinkList()
:_head(NULL)
, _tail(NULL){}
LinkList(const LinkList& list);
LinkList& operator=(LinkList list);
~LinkList();
void PushBack(const T& d);
void PushFront(const T& d);
void PopBack();
void PopFront();
void Insert(Node *addr, const T& d); //
Node* Search(const T& d);
void Remove(const T& d);
void RemoveAll(const T& d);
void Sort();
void Display();
size_t Size();
T& GetFront()
{
assert(_head);
return _head->_data;
}
T& GetBack()
{
assert(_tail);
return _tail->_data;
}
private:
Node *_head;
Node *_tail;
};
template
size_t LinkList::Size()
{
Node *cur = _head;
size_t count = 0;
while (cur)
{
count++;
cur = cur->_next;
}
return count;
}
template
LinkList::LinkList(const LinkList& list)
:_head(NULL)
, _tail(NULL)
{
Node *cur = list._head;
while (cur)
{
PushBack(cur->_data);
cur = cur->_next;
}
}
template
LinkList& LinkList::operator=(LinkList list)
{
std::swap(_head,list._head);
std::swap(_tail,list._tail);
return *this;
}
template
LinkList::~LinkList()
{
Node *cur = _head;
while (cur)
{
_head = _head->_next;
delete cur;
cur = _head;
}
_tail = NULL;
}
template
void LinkList::PushBack(const T& d)
{
Node *NewHead = new Node(d);
if (NULL == _head)
{
_head = NewHead;
_tail = NewHead;
}
else
{
_tail->_next = NewHead;
NewHead->_prev = _tail;
_tail = _tail->_next;
}
}
template
void LinkList::PushFront(const T& d)
{
Node *NewHead = new Node(d);
if (NULL == _head)
{
_head = NewHead;
_tail = NewHead;
}
else
{
NewHead->_next = _head;
_head->_prev = NewHead;
_head = NewHead;
}
}
template
void LinkList::PopBack()
{
if (NULL == _head)
{
return;
}
else if (NULL==_head->_next)
{
delete _tail;
_head = NULL;
_tail = NULL;
}
else
{
Node *cur = _tail;
_tail = _tail->_prev;
_tail->_next = NULL;
delete cur;
}
}
template
void LinkList::PopFront()
{
if (NULL == _head)
{
return;
}
else if (NULL == _head->_next)
{
delete _tail;
_head = NULL;
_tail = NULL;
}
else
{
Node *cur = _head;
_head = _head->_next;
_head->_prev = NULL;
delete cur;
}
}
template
void LinkList::Insert(Node *addr, const T& d) //
{
Node *NewNode = new Node(d);
if (_head == addr)
{
NewNode->_next = _head;
_head->_prev = NewNode;
_head = NewNode;
}
else if (_tail == addr)
{
PushBack(d);
}
else
{
NewNode->_next = addr->_next;
addr->_next->_prev = NewNode;
addr->_next = NewNode;
NewNode->_prev = addr;
}
}
template
Node* LinkList::Search(const T& d)
{
Node *cur = _head;
while (cur)
{
if (cur->_data == d)
{
return cur;
}
cur = cur->_next;
}
return NULL;
}
template
void LinkList::Remove(const T& d)
{
Node *cur =Search(d);
if (cur == _head)
{
PopFront();
}
else if (cur == _tail)
{
PopBack();
}
else
{
cur->_prev->_next = cur->_next;
cur->_next->_prev = cur->_prev;
delete cur;
}
}
template
void LinkList::RemoveAll(const T& d)
{
while (Search(d) != NULL)
{
Remove(d);
}
}
template
void LinkList::Sort()
{
Node *end = _tail;
while (_head != end)
{
Node *cur = _head;
int flag = 1;
while (cur!=end)
{
if (cur->_data > cur->_next->_data)
{
T tmp = cur->_data;
cur->_data = cur->_next->_data;
cur->_next->_data=tmp;
flag = 0;
}
cur = cur->_next;
}
if (flag)
{
return;
}
end = end->_prev;
}
}
template
void LinkList::Display()
{
Node *cur = _head;
while (cur)
{
cout <_data <_next;
}
cout <
#include"LinkList.h"
template class Container>
class Queue
{
public:
void Push(const T& d);
void Pop();
T& Front();
T& Back();
size_t Size();
bool Empty();
void Display()
{
while (!Empty())
{
cout < _con;
};
template class Container>
void Queue::Push(const T& d)
{
_con.PushBack(d);
}
template class Container>
void Queue::Pop()
{
_con.PopFront();
}
template class Container>
T& Queue::Front()
{
return _con.GetFront();
}
template class Container>
T& Queue::Back()
{
return _con.GetBack();
}
template class Container>
size_t Queue::Size()
{
return _con.Size();
}
template class Container>
bool Queue::Empty()
{
return _con.Size()== 0;
}
#pragma once
#include
#include
#include
#include
using namespace std;
template
class Seqlist
{
public:
Seqlist();
Seqlist(const Seqlist& seq);
Seqlist & operator=(Seqlist seq);
~Seqlist();
void PushBack(const T& d);
void PushFront(const T& d);
void PopBack();
void PopFront();
void Insert(int index,const T& d);
int Search(const T& d);
void Remove(const T& d);
void RemoveAll(const T& d);
void Sort();
void Reserve(int n);
void Display();
int GetSize();
T& operator[](int index);
private:
void CheckCapacity(int n=0);
private:
T *_pdata;
int _sz;
int _capacity;
};
template
T& Seqlist::operator[](int index)
{
assert(index >= 0);
assert(index
int Seqlist::GetSize()
{
return _sz;
}
template
Seqlist::Seqlist()
:_sz(0)
, _capacity(0)
, _pdata(NULL){}
template
Seqlist::Seqlist(const Seqlist& seq)
{
_pdata = new T[seq._capacity];
for (int i = 0; i
Seqlist& Seqlist::operator=(Seqlist seq)
{
swap(_pdata,seq._pdata);
_sz = seq._sz;
_capacity = seq._capacity;
return *this;
}
template
Seqlist::~Seqlist()
{
if (_pdata != NULL)
{
delete[] _pdata;
_pdata = NULL;
_sz = 0;
_capacity = 0;
}
}
template
void Seqlist::CheckCapacity(int n=0)
{
if (_sz == _capacity||n>_capacity)
{
int NewCapacity =2*_capacity+1;
if (n > _capacity)
{
NewCapacity = n;
}
T* tmp = new T[NewCapacity];
for (int i = 0; i
void Seqlist::PushBack(const T& d)
{
CheckCapacity();
_pdata[_sz++] = d;
}
template
void Seqlist::PushFront(const T& d)
{
CheckCapacity();
//memmove(_pdata + 1,_pdata,sizeof(T)*_sz);
for (int i =_sz;i>0; i--)
{
_pdata[i] = _pdata[i-1];
}
_pdata[0] = d;
_sz++;
}
template
void Seqlist::PopBack()
{
_sz--;
}
template
void Seqlist::PopFront()
{
//memmove(_pdata,_pdata+1,sizeof(T)*(--_sz));
for (int i = 0; i<_sz-1 _pdata="" _sz--="" template="">
void Seqlist::Insert(int index, const T& d)
{
assert(index >= 0);
assert(index<_sz checkcapacity="" for="">index; i--)
{
_pdata[i] = _pdata[i - 1];
}
_sz++;
_pdata[index] = d;
}
template
int Seqlist::Search(const T& d)
{
int i = 0;
for (i = 0; i
void Seqlist::Remove(const T& d)
{
int index = Search(d);
if (index == -1)
{
return;
}
else
{
//memmove(_pdata+index,_pdata+index+1,sizeof(T)*(_sz-index-1));
for (int i =index; i<_sz-1 _pdata="" _sz--="" template="">
void Seqlist::RemoveAll(const T& d)
{
while (Search(d) != -1)
{
Remove(d);
}
}
template
void Seqlist::Reserve(int n)
{
CheckCapacity(n);
}
template
void Seqlist::Sort()
{
int end = _sz - 1;
for (int i = 0; i _pdata[j+1])
{
T tmp = _pdata[j];
_pdata[j] = _pdata[j + 1];
_pdata[j + 1] = tmp;
flag = 0;
k= j;
}
}
if (flag == 1)
{
return;
}
end = k;
}
}
template
void Seqlist::Display()
{
for (int i = 0; i
#include"Seqlist.h"
template class Container>
class Stack
{
public:
bool Empty();
void Push(const T& d);
void Pop();
T& Top();
int Size();
void Display()
{
while (!Empty())
{
cout < _con;
};
template class Container>
bool Stack::Empty()
{
return _con.GetSize()==0;
}
template class Container>
void Stack::Pop()
{
_con.PopBack();
}
template class Container>
void Stack::Push(const T& d)
{
_con.PushBack(d);
}
template class Container>
int Stack::Size()
{
return _con.GetSize();
}
template class Container>
T& Stack::Top()
{
int sz=_con.GetSize()-1;
return _con[sz];
}
이 내용에 흥미가 있습니까?
현재 기사가 여러분의 문제를 해결하지 못하는 경우 AI 엔진은 머신러닝 분석(스마트 모델이 방금 만들어져 부정확한 경우가 있을 수 있음)을 통해 가장 유사한 기사를 추천합니다:
Sql의 실행 순서가 어떻게 되는지 알려드릴게요.select*단지 당신이 Sql 대문에 들어서는 첫걸음일 뿐, 실제 업무에서 틀림없이 이렇게 간단하지 않을 것이다.우리 예를 하나 봅시다. 위의 요구 사항을 수행하려면 다음과 같이 Sql을 사용할 수 있습니다. 위의...
텍스트를 자유롭게 공유하거나 복사할 수 있습니다.하지만 이 문서의 URL은 참조 URL로 남겨 두십시오.
CC BY-SA 2.5, CC BY-SA 3.0 및 CC BY-SA 4.0에 따라 라이센스가 부여됩니다.