目录
一、一点感想
自学数据结构和算法到现在时间也不短了,一直犹豫着要不要写一写向量等几个最最基本的数据结构,因为总觉得是最基本的,太容易了,不想花这个时间去写。然而学着学着慢慢发现,虽然这个很基本,但我并不一定能够做好(尤其是以前的我)。实际上我几次因为需要写过简单的结构,但是没有专门写过,而且体验也不是很好。最近在学图算法,里面涉及到一些更复杂的算法和结构,又时需要用上这几个基本数据结构作为辅助,于是我觉得,不如自己这次认真的写一下,作为模板放在电脑里,以后需要用向量什么的就用自己写的,这样可以帮助自己更好的理解数据结构。于是就有了现在的成果。
我觉得事情虽然简单,但是我还是很有收获的,因为以前是看上去简单,但是没有真正去做这件事,而现在我真正做了,完成了基本的工作,但是有的难点还是没有克服,比如遍历问题。这说明之前的认识有很大的错误,没有亲力亲为就以为自己懂了,那是无知的表现。从某种意义上讲,不断学习的目的之一就是为了克服这种无知,并且做到真正掌握知识和技术。讲这些基本的完成了,心里更有底了,以后在学习更难的内容的时候,我会更加清楚的知道自己以前做过什么工作,在使用数据结构的时候,也会有更好的掌控。
二、代码
1、Vector
#ifndef VECTOR__H__
#define VECTOR__H__
#include <cstdio>
template <typename T> class Vector
{
protected: //受保护的成员外部是不可访问的
int size, N;
T* a;
void check_overflow();
void check_underflow();
public:
Vector();
Vector(T e);
Vector(T* a, int len);
~Vector() { delete [] a; }
void print() { print(0, N); }
void print(int st, int end);
int getSize() { return N; }
T operator[](int id) { return a[id]; }
void reverse();
void insert(T e);
void insert(int id, T e);
T del(int id);
T del() { return del(N - 1); }
};
template <typename T> Vector<T>::Vector()
{
size = 1;
N = 0;
a = new T[size];
}
template <typename T> Vector<T>::Vector(T e)
{
size = 2;
N = 1;
a = new T[size];
a[0] = e;
}
template <typename T> Vector<T>::Vector(T *arr, int len)
{
N = len;
size = 2 * len;
a = new T[size];
for (int i = 0; i < len; i++) a[i] = arr[i];
}
template <typename T> void Vector<T>::insert(T e)
{
check_overflow();
a[N++] = e;
}
template <typename T> void Vector<T>::insert(int id, T e)
{
check_overflow();
for (int i = N; i > id; i++) a[i] = a[i - 1];
++N;
a[id] = e;
}
template <typename T> T Vector<T>::del(int id)
{
T tmp = a[id];
check_underflow();
for (int i = id; i < N; i++) a[i] = a[i + 1];
--N;
return tmp;
}
template <typename T> void Vector<T>::print(int st, int end)
{
printf("len : %d\n", end - st);
for (int i = st; i < end; i++) printf("%d : %d\n", i, a[i]);
}
template <typename T> void Vector<T>::check_overflow()
{
if (N + 1 > size)
{
size *= 2;
T* tmp = new T[size];
for (int i = 0; i < N; i++) tmp[i] = a[i];
a = tmp;
}
}
template <typename T> void Vector<T>::check_underflow()
{
if (N - 1 < size / 4)
{
size /= 2;
T* tmp = new T[size];
for (int i = 0; i < N; i++) tmp[i] = a[i];
a = tmp;
}
}
template <typename T> void Vector<T>::reverse()
{
int t = N / 2;
for (int i = 0; i < t; i++)
{
T tmp = a[i];
a[i] = a[N - 1 -i];
a[N - 1 -i] = tmp;
}
}
#endif
2、 List
#ifndef LIST__H__
#define LIST__H__
#include <cstdio>
template <typename T>
struct node
{
T data;
node<T> * pred;
node<T> * succ;
};
template <typename T> class List
{
private:
int N;
node<T> *head;
node<T> *tail;
void init();
public:
List() { init(); }
List(T e) { init(); insertAsLast(e); }
List(T * a, int len);
node<T>* first() { return head->succ; }
bool isEmpty() { return N == 0; }
void insertAsLast(T e);
void insertAsFirst(T e);
void insert(T e) { insertAsLast(e); }
T del() { delFirst(); }
T delLast();
T delFirst();
};
template <typename T> void List<T>::init()
{
N = 0;
head = new node<T>;
tail = new node<T>;
head->pred = NULL;
head->succ = tail;
tail->pred = head;
tail->succ = NULL;
}
template <typename T> List<T>::List(T * a, int len)
{
init();
for (int i = 0; i < len; i++) insertAsLast(a[i]);
}
template <typename T> void List<T>::insertAsFirst(T e)
{
N++;
node<T> *nd = new node<T>;
nd->data = e;
nd->pred = head;
nd->succ = head->succ;
head->succ->pred = nd;
head->succ = nd;
}
template <typename T> void List<T>::insertAsLast(T e)
{
N++;
node<T> *nd = new node<T>;
nd->data = e;
nd->pred = tail->pred;
nd->succ = tail;
tail->pred->succ = nd;
tail->pred = nd;
}
template <typename T> T List<T>::delFirst()
{
if (N)
{
N--;
T tmp = head->succ->data;
head->succ = head->succ->succ;
head->succ->pred = head;
return tmp;
}
else printf("Error! Empty! Cannot delete!");
}
template <typename T> T List<T>::delLast()
{
N--;
T tmp = tail->pred->data;
tail->pred = tail->pred->pred;
tail->pred->succ = tail;
return tmp;
}
#endif
3、Stack
自己在写的时候,由于对c++继承机制掌握不够熟练,陷入编译错误很久,主要在派生类的构造上。派生类的构造需要用初始化列表的方式给出基类的构造。
#ifndef STACK__H__
#define STACK__H__
#include "Vector.h"
template <typename T> class Stack: public Vector<T>
{
public:
Stack(): Vector<T>() { }
Stack(T e): Vector<T>(e) { }
Stack(T *a, int len): Vector<T>(a, len) { }
void push(T e) { this->insert(this->getSize(), e); }
T pop() { return this->del(); }
T top() { return this->a[this->getSize() - 1]; }
};
#endif
4、Queue
#ifndef QUEUE__H__
#define QUEUE__H__
#include "List.h"
template <typename T> class Queue: public List<T>
{
public:
Queue(): List<T>() { }
Queue(T e): List<T>(e) { }
Queue(T *a, int len): List<T>(a, len) {}
void enqueue(T const& e) { this->insertAsLast(e); }
T dequeue() { this->delFirst(); }
};
#endif
三、不足之处
- 这几个数据结构实现了基本的功能,但是API不算丰富,也许不能完全满足需求。由于我现在使用数据结构解决问题的经验很少,对哪些方法比较常用和重要没有直观的和深刻的理解,所以我想以后经验积累了、懂得了需求之后再来不断丰富自己的数据结构库,现在先到这里。
- 有的需求我是切身体会到了的,比如对链表实现遍历的功能,奈何自己能力不够,对c++的语法功能了解不够,尽管做了尝试但是还是没有成功。这个就需要以后自己越来越厉害、积累了知识之后再进行完善了。
- 诸如链表没有析构函数此类的不周到的地方,模板中到底有多少我也不知道。现在只把这些问题记录下来,等以后学了更多东西再来完善吧!
模板中的bug和代码缀余之处,都留给未来的自己好了。略略略。