LOFTER for ipad —— 让兴趣,更有趣

点击下载 关闭

LOFTER-网易轻博

c++

5844浏览    1669参与
万书汇

C++ Primer 中文版(第6版) PDF mobi 电子书 下载

C++ Primer 中文版(第6版)

[图片][图片]

作者: [美] Stanley B. Lippman / [美] Josée Lajoie / [美] Barbara E. Moo
出版社: 电子工业出版社
出品方: 博文视点
原作名: C++ Primer, 5th Edition
译者: 王刚 / 杨巨峰
出版年: 2013-9-1
页数: 838
定价: CNY 128.00
装帧: 平装
ISBN: 9787121155352

PDF 下载

mobi 下载

C++ Primer 中文版(第6版)


作者: [美] Stanley B. Lippman / [美] Josée Lajoie / [美] Barbara E. Moo
出版社: 电子工业出版社
出品方: 博文视点
原作名: C++ Primer, 5th Edition
译者: 王刚 / 杨巨峰
出版年: 2013-9-1
页数: 838
定价: CNY 128.00
装帧: 平装
ISBN: 9787121155352

PDF 下载

mobi 下载

javajiagoushiziyuanfenxiang
云青青雨潺潺

内存神偷

*《岁月神偷》词改,写给C艹

*凭什么我一个……好吧从某种程度上确实要学……(交叉学科苦啊……)


程序报错尚能debug

人脑当机痛苦谁懂得

内存流淌过 泄露着

麻木了你我


但求不见warning和error

纵别红粉蓝绿黑白色

语句方记下 迷惑着

全角半角又拼错


谁让

调试总带来猝不及防的惊喜

焦灼目光盯向黑屏

函数又报错 库名难寻觅

键盘声碎更静催霜鬓两席


啃书翻教辅又找大佬答疑

提交终于长吁一气

待到邮件收 看canvas一惊

助教你凭什么又诬我抄袭

反手一个零


C艹是让人猝不及防的东西...

*《岁月神偷》词改,写给C艹

*凭什么我一个……好吧从某种程度上确实要学……(交叉学科苦啊……)


程序报错尚能debug

人脑当机痛苦谁懂得

内存流淌过 泄露着

麻木了你我


但求不见warning和error

纵别红粉蓝绿黑白色

语句方记下 迷惑着

全角半角又拼错


谁让

调试总带来猝不及防的惊喜

焦灼目光盯向黑屏

函数又报错 库名难寻觅

键盘声碎更静催霜鬓两席


啃书翻教辅又找大佬答疑

提交终于长吁一气

待到邮件收 看canvas一惊

助教你凭什么又诬我抄袭

反手一个零


C艹是让人猝不及防的东西

难易都有凄风苦雨

争不过朝夕 又念着往昔

宁可不曾有从头再来的勇气


遥记得入学意气风发豪言壮语

谁想GPA满地飘零

别怪我贪心 只要二点零

至少有机会去继续努力

千万别退警

大风起兮云飞扬
白兔青柠

数据结构学习笔记——线性表(四)

有序表(Ordered List)是线性表的衍生物,区别只在于有序表在数据元素插入的时候就给它排好序,这有点像摸扑克牌。

有序表值得说的只有二路归并算法。

二路归并算法用于将两个有序表合并成一个,当然,也是有序的合并。如果一个个读取参数有序表的元素来插入的话,效率极低,所以我们需要采用如下方法。

假设我们合并一个递增的int有序表。

首先,我们将本表设为A表,设A表为

5,6,8,123

将传来的参数表设为B表,设B表为

1,2,7

之后,我们需要建立一个C表,然后看A表的第一个元素和B表的第一个元素,哪个小就把哪个放进C里,显然1小,将其放进C里,现在A表、B表如下:

5,...

有序表(Ordered List)是线性表的衍生物,区别只在于有序表在数据元素插入的时候就给它排好序,这有点像摸扑克牌。

有序表值得说的只有二路归并算法。

二路归并算法用于将两个有序表合并成一个,当然,也是有序的合并。如果一个个读取参数有序表的元素来插入的话,效率极低,所以我们需要采用如下方法。

假设我们合并一个递增的int有序表。

首先,我们将本表设为A表,设A表为

5,6,8,123

将传来的参数表设为B表,设B表为

1,2,7

之后,我们需要建立一个C表,然后看A表的第一个元素和B表的第一个元素,哪个小就把哪个放进C里,显然1小,将其放进C里,现在A表、B表如下:

5,6,8,123

2,7

然后再看A表的第一个元素和B表的第一个元素,哪个小就把哪个放进C里,如此循环即可。

接下来会出现一个表都放进C里了,而另一个还剩下若干个数据元素的情况,这时只需将其依次放进C里即可。

这个算法的时间复杂度为O(n),n就是A、B表的长度之和。两个表都只遍历一次,是很高效的算法。

我的有序表从双链表改造而来,代码如下:

SortedIntList.h:

#pragma once

#include <initializer_list>

#include "LinkedListNode.h"

class SortedIntList

{

LinkedListNode<int>* Head = nullptr;

public:

SortedIntList() {}

SortedIntList(const std::initializer_list<int> elements);

~SortedIntList();

//在线性表插入值

void Insert(const int element);

//删除最近数据元素(从左向右遍历)

void Remove(const int element);

//删除所有指定数据元素

void RemoveAll(const int element);

//按位置删除数据元素,并返回值

int RemoveAt(const int i);

//返回线性表的长度

int Length();

//取得某个位置的值

int& operator[](const int id);

//按元素值查找元素位置

int Locate(const int element);

LinkedListNode<int>* GetHead();

//将另一个列表合并进来

SortedIntList& Union(SortedIntList* anotherlist);

};


SortedIntList.cpp:

#include <stdexcept>

#include "SortedIntList.h"

#include "LinkedListNode.h"

SortedIntList::SortedIntList(const std::initializer_list<int> elements)

{

for (auto i : elements)

Insert(i);

}

SortedIntList::~SortedIntList()

{

if (Head == nullptr) return;

LinkedListNode<int>* temppos = Head;

while (temppos != nullptr)

{

Head = Head->Next;

delete temppos;

temppos = Head;

}

}

void SortedIntList::Insert(const int element)

{

if (Head == nullptr)

{

Head = new LinkedListNode<int>;

Head->Data = element;

return;

}

LinkedListNode<int>* temppos = Head;

LinkedListNode<int>* temp;

while (temppos != nullptr && temppos->Data < element)

{

if (temppos->Next == nullptr)

{

temp = new LinkedListNode<int>;

temp->Data = element;

temp->Prev = temppos;

temppos->Next = temp;

return;

}

temppos = temppos->Next;

}

if (temppos->Prev == nullptr)

{

temp = new LinkedListNode<int>;

temp->Next = Head;

Head->Prev = temp;

temp->Data = element;

Head = temp;

return;

}

temp = new LinkedListNode<int>;

temp->Data = element;

temp->Prev = temppos->Prev;

temppos->Prev->Next = temp;

temp->Next = temppos;

temppos->Prev = temp;

}

void SortedIntList::Remove(const int element)

{

LinkedListNode<int>* temppos = Head;

if (Head->Data == element)

{

if (Head->Next == nullptr)

Head = nullptr;

else

{

Head->Next->Prev = nullptr;

Head = Head->Next;

}

delete temppos;

}

else

{

while (temppos != nullptr)

{

if (temppos->Data == element)

{

if (temppos->Next == nullptr)

temppos->Prev->Next = nullptr;

else

{

temppos->Next->Prev = temppos->Prev;

temppos->Prev->Next = temppos->Next;

}

delete temppos;

return;

}

temppos = temppos->Next;

}

}

}

void SortedIntList::RemoveAll(const int element)

{

LinkedListNode<int>* temppos = Head;

if (Head->Data == element)

{

if (Head->Next == nullptr)

{

Head = nullptr;

return;

}

else

{

Head->Next->Prev = nullptr;

Head = Head->Next;

}

delete temppos;

}

while (temppos != nullptr)

{

if (temppos == Head)

{

if (temppos->Data == element)

{

if (Head->Next == nullptr)

{

Head = nullptr;

return;

}

}

continue;

}

if (temppos->Data == element)

{

if (temppos->Next == nullptr)

temppos->Prev->Next = nullptr;

else

{

temppos->Next->Prev = temppos->Prev;

temppos->Prev->Next = temppos->Next;

}

LinkedListNode<int>* temp = temppos;

delete temp;

}

temppos = temppos->Next;

}

}

int SortedIntList::RemoveAt(const int i)

{

LinkedListNode<int>* temppos = Head;

int temp;

if (i < 0) throw std::out_of_range("所取位置不可小于0。");

else if (i == 0)

{

if (Head->Next != nullptr)Head = Head->Next;

else Head = nullptr;

temp = temppos->Data;

delete temppos;

return temp;

}

else

{

for (int j = 0; j < i - 1; j++)

{

if (temppos == nullptr)

throw std::out_of_range("所取位置超出链表范围。");

temppos = temppos->Next;

}

temppos->Prev->Next = temppos->Next;

if (temppos->Next != nullptr)temppos->Next->Prev = temppos->Prev;

temp = temppos->Data;

delete temppos;

return temp;

}

}

int SortedIntList::Length()

{

int temp = 0;

LinkedListNode<int>* temppos = Head;

while (temppos != nullptr)

{

temp++;

temppos = temppos->Next;

}

return temp;

}

int& SortedIntList::operator[](const int id)

{

LinkedListNode<int>* temppos = Head;

for (int j = 0; j < id; j++)

{

if (temppos == nullptr)

throw std::out_of_range("所取位置超出链表范围。");

temppos = temppos->Next;

}

return temppos->Data;

}

int  SortedIntList::Locate(const int element)

{

LinkedListNode<int>* temppos = Head;

int temp = 0;

while (temppos != nullptr)

{

if (temppos->Data == element) return temp;

temp++;

temppos = temppos->Next;

}

return -1;

}

LinkedListNode<int>* SortedIntList::GetHead()

{

return Head;

}

SortedIntList& SortedIntList::Union(SortedIntList* anotherlist)

{

LinkedListNode<int>* tempposA = Head;

LinkedListNode<int>* tempposB = anotherlist->GetHead();

LinkedListNode<int>* temppos = nullptr;

Head = nullptr;

while (tempposA != nullptr && tempposB != nullptr)

{

if (tempposA->Data < tempposB->Data)

{

if (Head == nullptr)

{

temppos = Head = tempposA;

tempposA = tempposA->Next;

}

else

{

temppos->Next = tempposA;

tempposA->Prev = temppos;

temppos = temppos->Next;

tempposA = tempposA->Next;

}

}

else

{

if (Head == nullptr) 

{

LinkedListNode<int>* temp = new LinkedListNode<int>;

temp->Data = tempposB->Data;

temppos = Head = temp;

tempposB = tempposB->Next;

}

else

{

LinkedListNode<int>* temp = new LinkedListNode<int>;

temp->Data = tempposB->Data;

temppos->Next = temp;

temp->Prev = temppos;

temppos = temppos->Next;

tempposB = tempposB->Next;

}

}

}

while (tempposA != nullptr)

{

if (Head == nullptr)

{

temppos = Head = tempposA;

tempposA = tempposA->Next;

}

else

{

temppos->Next = tempposA;

tempposA->Prev = temppos;

temppos = temppos->Next;

tempposA = tempposA->Next;

}

}

while (tempposB != nullptr)

{

if (Head == nullptr)

{

LinkedListNode<int>* temp = new LinkedListNode<int>;

temp->Data = tempposB->Data;

temppos = Head = temp;

tempposB = tempposB->Next;

}

else

{

LinkedListNode<int>* temp = new LinkedListNode<int>;

temp->Data = tempposB->Data;

temppos->Next = temp;

temp->Prev = temppos;

temppos = temppos->Next;

tempposB = tempposB->Next;

}

}

temppos->Next = nullptr;

return *this;

}


白兔青柠

数据结构学习笔记——线性表(三)

链表(Linked List)是线性表的链式存储结构,它的存储位置不连续,利用的是存储空间中零散的各部分,它没有容量限制,理论上可以无限延伸。

链表由若干个节点(Node)组成,每个节点包含它所储存的数据,以及前一个节点与后一个节点所在的内存地址,在C++中以指针实现,称为指针域。节点相连就成了链表。而第一个节点与最后一个节点的内存地址储存在头指针和尾指针中。

顺便说一句,链表的存储密度(节点中数据元素所占存储量/节点所占存储量)不如线性表。


链表分为单链表、双链表、循环链表。

节点前后相连即为双链表。


单链表的节点不包含前节点的指针,只向后单向传递。


循环链表首尾相连,没有头...

链表(Linked List)是线性表的链式存储结构,它的存储位置不连续,利用的是存储空间中零散的各部分,它没有容量限制,理论上可以无限延伸。

链表由若干个节点(Node)组成,每个节点包含它所储存的数据,以及前一个节点与后一个节点所在的内存地址,在C++中以指针实现,称为指针域。节点相连就成了链表。而第一个节点与最后一个节点的内存地址储存在头指针和尾指针中。

顺便说一句,链表的存储密度(节点中数据元素所占存储量/节点所占存储量)不如线性表。


链表分为单链表、双链表、循环链表。

节点前后相连即为双链表。


单链表的节点不包含前节点的指针,只向后单向传递。


循环链表首尾相连,没有头节点、尾节点。



我写的是双链表,代码如下(LinkedList.h):

#pragma once

#include <stdexcept>

#include <initializer_list>

#include "LinkedListNode.h"

#include "LinearListBase.h"

template<typename T>

class LinkedList:public LinearListBase<T>

{

LinkedListNode<T>* Head = nullptr;

public:

LinkedList(){}

LinkedList(const std::initializer_list<T> elements);

//在线性表末尾插入值

void Insert(const T element);

//在线性表的第i个位置插入值

void Insert(const T element, const int i);

//删除最近数据元素(从左向右遍历)

void Remove(const T element);

//删除所有指定数据元素

void RemoveAll(const T element);

//按位置删除数据元素,并返回值

T RemoveAt(const int i);

//返回线性表的长度

int Length();

//取得某个位置的值

T& operator[](const int id);

//按元素值查找元素位置

int Locate(const T element);

~LinkedList();

};


template<typename T>

LinkedList<T>::LinkedList(const std::initializer_list<T> elements)

{

LinkedListNode<T>* temp = nullptr;

for (T i : elements)

{

if (i == elements.begin())

{

Head = new LinkedListNode<T>;

Head->Data = i;

temp = Head;

continue;

}

temp->Next = new LinkedListNode<T>;

temp->Next->Prev = temp;

*(temp->Next->Data) = i;

temp = temp->Next;

}

}

template<typename T>

LinkedList<T>::~LinkedList()

{

if (Head == nullptr)return;

LinkedListNode<T>* temppos = Head;

while (temppos != nullptr)

{

Head = Head->Next;

delete temppos;

temppos = Head;

}

}

template<typename T>

void LinkedList<T>::Insert(const T element)

{

if (Head == nullptr)

{

Head = new LinkedListNode<T>;

Head->Data = element;

}

else

{

LinkedListNode<T>* temp = Head;

while (temp->Next != nullptr)

temp = temp->Next;

temp->Next = new LinkedListNode<T>;

temp->Next->Prev = temp;

temp->Next->Data = element;

}

}

template<typename T>

void LinkedList<T>::Insert(const T element, const int i)

{

if (i < 0)return;

else if (i == 0)

{

LinkedListNode<T>* temp = new LinkedListNode<T>;

temp->Data = element;

temp->Next = Head;

Head->Prev = temp;

Head = temp;

}

else

{

LinkedListNode<T>* temppos = Head;

for (int j = 0; j < i - 1; j++)

{

if (temppos == nullptr)

throw std::out_of_range("所取位置超出链表范围。");

temppos = temppos->Next;

}

LinkedListNode<T>* temp = new LinkedListNode<T>;

temp->Data = element;

temp->Next = temppos->Next;

if (temppos->Next != nullptr) temppos->Next->Prev = temp;

temp->Prev = temppos;

temppos->Next = temp;

}

}

template<typename T>

void LinkedList<T>::Remove(const T element)

{

LinkedListNode<T>* temppos = Head;

if (Head->Data == element)

{

if (Head->Next == nullptr)

Head = nullptr;

else

{

Head->Next->Prev = nullptr;

Head = Head->Next;

}

delete temppos;

}

else

{

while (temppos != nullptr)

{

if (temppos->Data == element)

{

if (temppos->Next == nullptr)

temppos->Prev->Next = nullptr;

else

{

temppos->Next->Prev = temppos->Prev;

temppos->Prev->Next = temppos->Next;

}

delete temppos;

return;

}

temppos = temppos->Next;

}

}

}

template<typename T>

void LinkedList<T>::RemoveAll(const T element)

{

LinkedListNode<T>* temppos = Head;

if (Head->Data == element)

{

if (Head->Next == nullptr)

{

Head = nullptr;

return;

}

else

{

Head->Next->Prev = nullptr;

Head = Head->Next;

}

delete temppos;

}

while (temppos != nullptr)

{

if (temppos == Head)

{

if (temppos->Data == element)

{

if (Head->Next == nullptr)

{

Head = nullptr;

return;

}

}

continue;

}

if (temppos->Data == element)

{

if (temppos->Next == nullptr)

temppos->Prev->Next = nullptr;

else

{

temppos->Next->Prev = temppos->Prev;

temppos->Prev->Next = temppos->Next;

}

LinkedListNode<T>* temp = temppos;

delete temp;

}

temppos = temppos->Next;

}

}

template<typename T>

T LinkedList<T>::RemoveAt(const int i)

{

LinkedListNode<T>* temppos = Head;

T temp;

if (i < 0) throw std::out_of_range("所取位置不可小于0。");

else if (i == 0)

{

if (Head->Next != nullptr)Head = Head->Next;

else Head = nullptr;

temp = temppos->Data;

delete temppos;

return temp;

}

else

{

for (int j = 0; j < i - 1; j++)

{

if (temppos == nullptr)

throw std::out_of_range("所取位置超出链表范围。");

temppos = temppos->Next;

}

temppos->Prev->Next = temppos->Next;

if (temppos->Next != nullptr)temppos->Next->Prev = temppos->Prev;

temp = temppos->Data;

delete temppos;

return temp;

}

}

template<typename T>

int LinkedList<T>::Length()

{

int temp = 0;

LinkedListNode<T>* temppos = Head;

while (temppos != nullptr)

{

temp++;

temppos = temppos->Next;

}

return temp;

}

template<typename T>

T& LinkedList<T>::operator[](const int id)

{

LinkedListNode<T>* temppos = Head;

for (int j = 0; j < id; j++)

{

if (temppos == nullptr)

throw std::out_of_range("所取位置超出链表范围。");

temppos = temppos->Next;

}

return temppos->Data;

}

template<typename T>

int  LinkedList<T>::Locate(const T element)

{

LinkedListNode<T>* temppos = Head;

int temp = 0;

while (temppos != nullptr)

{

if (temppos->Data == element) return temp;

temp++;

temppos = temppos->Next;

}

return -1;

}

这些好像也是没啥好说明的,只是我的算法应该效率较低= =。

白兔青柠

数据结构学习笔记——线性表(二)

线性表按存储结构可分为顺序表与链表,还衍生出了有序表。

顺序表(Sequential List)是线性表的顺序存储结构。它使线性表中所有元素依次存储到存储器中一块连续的空间中,表中逻辑顺序相邻的元素,其存储位置也相邻,这称为直接映射。比如创建了一个顺序表,其a1在1001-1004内存空间中,a2就在1005-1008内存空间中。


数组就是典型的顺序表,我的顺序表即是以数组为基础扩展增删改查的功能,可视为增强数组。

代码如下(SequentialList.h):

#pragma once

#include <stdexcept>

#include ...

线性表按存储结构可分为顺序表与链表,还衍生出了有序表。

顺序表(Sequential List)是线性表的顺序存储结构。它使线性表中所有元素依次存储到存储器中一块连续的空间中,表中逻辑顺序相邻的元素,其存储位置也相邻,这称为直接映射。比如创建了一个顺序表,其a1在1001-1004内存空间中,a2就在1005-1008内存空间中。



数组就是典型的顺序表,我的顺序表即是以数组为基础扩展增删改查的功能,可视为增强数组。

代码如下(SequentialList.h):

#pragma once

#include <stdexcept>

#include <initializer_list>

#include "LinearListBase.h"

template<typename T,int capacity>

class SequentialList:public LinearListBase<T>

{

T Data[capacity];

int Count = 0;

public:

SequentialList(){}

SequentialList(const std::initializer_list<T> elements);

//在线性表末尾插入值

void Insert(const T element);

//在线性表的第i个位置插入值

void Insert(const T element, const int i);

//删除最近数据元素(从左向右遍历)

void Remove(const T element);

//删除所有指定数据元素

void RemoveAll(const T element);

//按位置删除数据元素,并返回值

T RemoveAt(const int i);

//返回线性表的长度

int Length();

//取得某个位置的值

T& operator[](const int id);

//按元素值查找元素位置

int Locate(const T element);

};


template<typename T, int capacity>

SequentialList<T,capacity>::SequentialList(const std::initializer_list<T> elements)

{

for (T i : elements) 

{

if (Count >= capacity) return;

Data[Count++] = i;

}

}

template<typename T, int capacity>

void SequentialList<T, capacity>::Insert(const T element)

{

if (Count >= capacity) return;

Data[Count++] = element;

}

template<typename T, int capacity>

void SequentialList<T,capacity>::Insert(const T element, const int i)

{

if (Count >= capacity) return;

if (i == Count) Insert(element);

else if (i > Count) return;

else

{

for (int j = Count; j > i; j--)

Data[j] = Data[j - 1];

Data[i] = element;

Count++;

}

}

template<typename T, int capacity>

void SequentialList<T, capacity>::Remove(const T element)

{

for (int i = 0; i < Count; i++)

if (Data[i] == element)

{

RemoveAt(i);

break;

}

}

template<typename T, int capacity>

void SequentialList<T, capacity>::RemoveAll(const T element)

{

int k = 0;

for (int i = 0; i < Count; i++)

if (Data[i] == element)

Data[k++] = Data[i];

Count = k;

}

template<typename T, int capacity>

T SequentialList<T, capacity>::RemoveAt(const int i)

{

if (i < 0 || i >= Count) throw std::out_of_range("所取位置超出顺序表范围。");

Count--;

T temp = Data[i];

for (int j = i; j < Count; j++)

Data[j] = Data[j + 1];

return temp;

}

template<typename T, int capacity>

int SequentialList<T, capacity>::Length()

{

return Count;

}

template<typename T, int capacity>

T& SequentialList<T, capacity>::operator[](const int id)

{

if (id < 0 || id >= Count) throw std::out_of_range("所取下标超出顺序表范围。");

return Data[id];

}

template<typename T, int capacity>

int SequentialList<T, capacity>::Locate(const T element)

{

for (int i = 0; i < Count; i++)

if (Data[i] == element)

return i;

return -1;

}

白兔青柠

数据结构学习笔记——线性表(一)

线性表(Linear List)是具有相同特性的数据元素的一个有限序列,具有有穷性、一致性、序列性。

数组其实就是最典型的线性表。数组中的元素数量有限,逻辑元素一个接着一个,每个都有下标位置,以及,一切逻辑元素的类型都是相同的。


当然我们还是需要定义一个比数组功能更强大的线性表数据容器。我在初学数据结构的同时也是初学C++,我便用C++来表现线性表。本文重点记录我对数据结构的理解,代码上不做过多叙述。


一个线性表理应具备如下功能:

  1. 它是泛型的,可以适用于多种类型。

  2. 初始化时能够直接指定数据。

  3. 插入元素。

  4. 删除元素。

  5. 取得长度。

  6. 取得某个位置的值。

  7. 按值...

线性表(Linear List)是具有相同特性的数据元素的一个有限序列,具有有穷性、一致性、序列性。

数组其实就是最典型的线性表。数组中的元素数量有限,逻辑元素一个接着一个,每个都有下标位置,以及,一切逻辑元素的类型都是相同的。


当然我们还是需要定义一个比数组功能更强大的线性表数据容器。我在初学数据结构的同时也是初学C++,我便用C++来表现线性表。本文重点记录我对数据结构的理解,代码上不做过多叙述。


一个线性表理应具备如下功能:

  1. 它是泛型的,可以适用于多种类型。

  2. 初始化时能够直接指定数据。

  3. 插入元素。

  4. 删除元素。

  5. 取得长度。

  6. 取得某个位置的值。

  7. 按值查找位置。

于是产生了如下抽象类(LinearListBase.h):

 

#pragma once

template<typename T>

class LinearListBase

{

public:

//在线性表末尾插入值

virtual void Insert(const T element) = 0;

//在线性表的第i个位置插入值

virtual void Insert(const T element, const int i) = 0;

//删除最近数据元素(从左向右遍历)

virtual void Remove(const T element) = 0;

//删除所有指定数据元素

virtual void RemoveAll(const T element) = 0;

//按位置删除数据元素,并返回值

virtual T RemoveAt(const int i) = 0;

//返回线性表的长度

virtual int Length() = 0;

//取得某个位置的值

virtual T& operator[](const int id) = 0;

//按元素值查找元素位置

virtual int Locate(const T element) = 0;

};

做到这些,就基本具备了增删改查的功能。可惜我的C++是初学,还不能够添加上迭代器。

大风起兮云飞扬
大风起兮云飞扬
大风起兮云飞扬
大风起兮云飞扬
周四下雨

2019CSP

2019CSP旁观

刚和高二的学长混熟他们就要退役了,结果学长他们还自己装作傻逼一样防止自己过于悲伤。

在公交站台等去火车站的公交的时候一个学长没忍住突然喊了一句:“老子TM就要退役了呀!”后面又在那里一直说“老子TM就要退役了”,我们照常用自己的傻逼掩盖这几分溢出来的不知道是什么的情感,后面谁也说不出话,一群人挤满了一整辆公交,谁也没说什么,只是在车上日常虚伪互夸对方AK IOI。

高二学长提醒我们去找他拿机房钥匙,不知道说些什么好。

第一天考完之后空了一个下午,我们带坏dalao一起打d5,血虐dalao,爽。

原来相比与打牌游戏,dalao更喜欢电视综艺。

晚上就随便吃了点晚...

2019CSP旁观

刚和高二的学长混熟他们就要退役了,结果学长他们还自己装作傻逼一样防止自己过于悲伤。

在公交站台等去火车站的公交的时候一个学长没忍住突然喊了一句:“老子TM就要退役了呀!”后面又在那里一直说“老子TM就要退役了”,我们照常用自己的傻逼掩盖这几分溢出来的不知道是什么的情感,后面谁也说不出话,一群人挤满了一整辆公交,谁也没说什么,只是在车上日常虚伪互夸对方AK IOI。

高二学长提醒我们去找他拿机房钥匙,不知道说些什么好。

第一天考完之后空了一个下午,我们带坏dalao一起打d5,血虐dalao,爽。

原来相比与打牌游戏,dalao更喜欢电视综艺。

晚上就随便吃了点晚饭,就一伙人骑着共享单车绕着nc大学随便的逛着,想停就停,某dalao还拍了很多照片,一群人开着玩笑,还讲要围绕考场一周。我们把手机塞到口袋里,随便点开一个歌单放到最响,与歌声同行。

我不太会骑自行车,不过一直有人跟在我身后,不论我骑得多慢我都不是车队最后的那一个,几个dalao怕我跟不上还提醒我不要掉队。

真好。

只是这样的时光太少。

晚上一伙人趁着老师收完手机睡觉,跑到一个房间集体打牌,还用明天早上的饭币做筹码,结果第二天早上我加了个荷包蛋,某dalao靠别人接济喝了碗粥。

回去的时候我们在火车上打牌,吃面。

转机来了。

Jx那个新来的傻逼特派员据说是什么官僚主义+不懂装懂,搞丢了数据,整个jx重考。

高二学长高兴的疯了一个下午。

“噫!好!老子还活着!”

“哈哈哈哈哈老子还没退役!!”

“啊哈哈哈哈哈哈哈哈哈哈哈!!!!”

老师给我们弄了一次模拟考,从下午两点考到六点半,一帮人都没吃饭,点了外卖,正好有人的快递火锅泡面到了,借了一张走读卡偷跑出去拿。

恰逢大佬生日,高二学长们把他a了(“a”:我也没明白这玩意儿是什么意思)。

外卖与火锅的香气传遍二楼,其他竞赛组表示羡慕;

今天他们出发,我留守机房。

等他们归来。


月游

大半夜学c++


谁知道我这个大半夜戴着个U型枕学c++是什么奇怪的脑回路。

大概是只有在这种夜深人静的时刻学习编程才比平常更容易进入状态吧。


谁知道我这个大半夜戴着个U型枕学c++是什么奇怪的脑回路。

大概是只有在这种夜深人静的时刻学习编程才比平常更容易进入状态吧。

hdw2000
大风起兮云飞扬

LOFTER

让兴趣,更有趣

简单随性的记录
丰富多彩的内容
让生活更加充实

下载移动端
关注最新消息