string及顺序表、链表(C++)

首先，了解下string库函数：
具体参考：http://www.cplusplus.com/reference/string/string/?kw=string
1.constructor

对于7个构造函数依次如下：

2.capacity

注：size( )和length( )都是string大小，推荐使用size( )；
reserve( )是直接扩容；
resize( )是可以扩容可以缩容，并且初始化；（后面有具体代码）
clear( )是在下标为0的位置放’\0’,size置0，但不释放空间；
3.Modifiers


注：replace( )是替换；assign是把对象之前值清理掉赋值为目标值，如果空间不够会扩容；
operator+=和append都是连接字符串，但建议使用operator+=，因为可读性更高。
接下里为用c++写的顺序表和链表：
1.下标的顺序表：

#include<iostream>
#include<string>
#include<assert.h>
using namespace std;
//将字符串转为整数
//int main()
//{
//  string str("     12345");
//  int index = 0;
//  //先处理空格
//  while (index < str.size())
//  {
//      if (str[index] == ' ')
//          index++;
//      else
//          break;
//  }
//  int flag = 1;
//  if (str[index] == '+')
//  {
//      index++;
//      flag = 1;
//  }
//  if (str[index] == '-')
//  {
//      index++;
//      flag = -1;
//  }
//  int value = 0;
//  while (index<str.size())
//  {
//      if (str[index] >= '0'&&str[index] <= '9')
//      {
//          value = value * 10 + (str[index] - '0');
//          index++;
//      }
//      //不合法数值表达式直接返回
//      else
//          return 0;
//  }
//  printf("%d\n", value*flag);
//  system("pause");
//  return 0;
//}
typedef int Datatype;
class Myvector
{
public:
    Myvector(int n)//构造函数
    {
        _a = new Datatype[n];
        _size = 0;
        _capacity = n;
    }
    Myvector(const Myvector& v)//拷贝构造
    {
        _a = new Datatype[v._size];
        memcpy(_a, v._a, sizeof(Datatype)*v._size);
        _size = v._size;
        _capacity = v._capacity;
    }
    Myvector& operator=( Myvector v)//赋值
    {
        //用现代写法
        if (this != &v)
        {
            swap(_a, v._a);
            swap(_size, v._size);
            swap(_capacity, v._capacity);
        }
        return *this;
    }
    void PushBack(const Datatype& x)//尾插,用引用是因为Datatype可能是字符串
    {
        if (_size == _capacity)//扩容
        {
            _capacity *= 2;
            _a = (Datatype*)realloc(_a,sizeof(Datatype)*_capacity);

        }
        _a[_size] = x;
        _size++;
    }
    void PopBack()//尾删
    {
        if (_size > 0)
        {
            _size--;
        }
    }
    void Insert(size_t pos,  const Datatype& x)
    {
        assert(pos >= 0 && pos <= _size);
        if (_size == _capacity)
        {
            _capacity *= 2;
            Datatype* a = new Datatype(_capacity);
            memcpy(a, _a, sizeof(Datatype)*_size);
            _a = a;
            //_a = (Datatype*)realloc(_a, sizeof(Datatype)*_capacity);
        }
        size_t index = _size;
        while (index > pos)
        {
            _a[index] = _a[index - 1];
            index--;
         }
        _a[pos] = x;
        _size++;
    }
    void Erase(size_t pos)
    {
        assert(pos >= 0 && pos < _size);
        int index = pos;
        while (index < _size-1)
        {
            _a[index] = _a[index + 1];
            index++;
        }
        _size--;
    }
    Datatype& operator[](size_t pos)
    {
        return _a[pos];
    }
    ~Myvector()
    {
        if (_a)
        {
            delete[]_a;
            _a = NULL;
            _size = 0;
            _capacity = 0;
        }
    }
    void print()
    {
        for (int index = 0; index < _size; index++)
            printf("%d ", _a[index]);
        printf("\n");
    }
private:
    Datatype* _a;
    size_t _size;
    size_t _capacity;
}

2.指针的顺序表：

#include<iostream>
#include<assert.h>
#include<string>
using namespace std;

typedef int Datatype;
class  Vector
{
public:
    Vector()//构造
        :_first(NULL)
        , _finish(NULL)
        , _endofstorage(NULL)
    {
    }

    ~Vector()//析构
    {
        if (_first)
        {
            delete[] _first;
            _first = NULL;
            _finish = NULL;
            _endofstorage = NULL;
        }

    }
    Vector(const Vector& v)//拷贝构造
    {
        _first = new Datatype[v.Size()];
        _finish = _first + v.Size();
        _endofstorage = _first + v.Size();
        memcpy(_first, v._first, sizeof(Datatype)*v.Size());
    }
    Vector& operator=(Vector v)
    {
        //现代写法
        swap(_first, v._first);
        swap(_finish, v._finish);
        swap(_endofstorage, v._endofstorage);
        return *this;
    }
    size_t Size() const
    {
        return _finish - _first;
    }
    size_t Capacity() const
    {
        return _endofstorage - _first;
    }
    void Reverse(size_t n) //单纯扩容
    {
        if (n > Capacity())
        {
            Expand(n);
        }
    }
    void Resize(size_t n,Datatype value)//扩容并且初始化 
    {
        if (n < Size())//缩容
        {
            _finish = _first + n;
        }
        else
        {
            if (n > Capacity())//先扩容
            {
                Expand(n);
            }
            Datatype* end = _first + n;
            while (_finish < end)
            {
                *_finish = value;
                ++_finish;
            }
        }
    }
    void PushBack(Datatype x)//尾插
    {
        /*if (_finish == _endofstorage)
        {
            if (Capacity() == 0)
                Expand(3);
            else
                Expand(Capacity() * 2);
        }
        *_finish = x;
        ++_finish;*/
        Insert(_finish, x);
    }    
    void PopBack()//尾删
    {
        /*if (_finish != _first)
        {
            _finish--;
        }*/
        Erase(_finish - 1);
    }
    Datatype *Find(Datatype x)   
    {
        Datatype *cur = _first;
        while (cur != _finish)
        {
            if (*cur == x)
                return cur;
            else
                cur++;
        }
        return NULL;
    }
    void Insert(Datatype *pos, Datatype x)//在pos前插入元素
    {
        int num = pos - _first;
        if (_finish == _endofstorage)//需要扩容
        {
            if (_finish == NULL)
                Expand(3);//一个元素都没有，可以先开3个空间
            else
                Expand(Capacity() * 2);
                pos = _first + num;//注意pos发生变化
        }
        Datatype *tmp = _finish;
        while (tmp > pos)
        {
            *tmp = *(tmp - 1);
            tmp--;
        }
        *pos = x;
        _finish++;
    }
    void Erase(Datatype *pos)//在pos位置删除元素
    {
        assert(_first <= pos&&pos < _finish);
        while (pos < (_finish - 1))
        {
            *pos = *(pos + 1);
            pos++;
         }
        _finish--;
    }
    Datatype& operator[](size_t n)
    {
        return _first[n];
    }
    void Print()
    {
        Datatype *cur = _first;
        while (cur!=_finish)
        {
            printf("%d ", *cur);
            cur++;
        }
        printf("\n");
    }
private:
    void Expand(size_t n)
    {
        if (n > Capacity())
        {
            size_t size = Size();//需要先保存起来
            Datatype *tmp = new Datatype[n];
            memcpy(tmp, _first, sizeof(Datatype)*size);
            delete[] _first;
            _first = tmp;
            _finish = _first + size;
            _endofstorage = _first + n;
        }
    }
private:
    Datatype *_first;//相当于_a
    Datatype *_finish;//相当于_size
    Datatype *_endofstorage;//相当于_capacity
};

3.链表（带头双向）

#include<iostream>
#include<string>
#include<assert.h>
using namespace std;
//带头双向链表
typedef int DataListtype;
typedef struct ListNode
{
    DataListtype _data;
    struct ListNode  *_next;
    struct ListNode *_prev;
    struct ListNode (const DataListtype& x)
        :_data(x)
        ,_next(NULL)
        ,_prev(NULL)
    {
    }
}Node;
class Mylist
{
public:
    Mylist()//构造函数
    {
        _head = new Node(DataListtype());//为Node类型，且初始化
        _head = (Node*)malloc(sizeof(Node));
        _head->_next = _head;
        _head->_prev = _head;
    }
    Mylist(const Mylist& l)//拷贝构造
    {
        _head = new Node(DataListtype());//初始化DataListtype()，可能是string类型，匿名对象
        _head->_next = _head;
        _head->_prev = _head;
        Node *cur = l._head->_next;
        while (cur != l._head)
        {
            /*Node*tail = _head->_prev;
            Node* Newnode = new Node(cur->_data);
            tail->_next = Newnode;
            Newnode->_prev = tail;
            Newnode->_next = _head;
            _head->_prev = Newnode;
            cur = cur->_next;*/
            PushBack(cur->_data);
            cur = cur->_next;
        }
    }
    Mylist& operator=( Mylist l)//赋值
    {
        现代写法
        swap(_head, l._head);
        return *this;
    }
    void PushBack(const DataListtype&x)//尾插
    {
        /*Node* tail = _head->_prev;
        Node* newnode = new Node(x);
        tail->_next = newnode;
        newnode->_prev = tail;
        newnode->_next = _head;
        _head->_prev = newnode;*/
        Insert(_head, x);
    }
    void PushFront(const DataListtype&x)//前插
    {
        /*Node* newnode = new Node(x);
        Node* next = _head->_next;
        newnode->_next = next;
        next->_prev = newnode;
        _head->_next = newnode;
        newnode->_prev = _head;*/
        Insert(_head->_next, x);
    }
    Node* Find(const DataListtype&x)//查找
    {
        Node* cur = _head->_next;
        while (cur != _head && cur->_data != x)
        {
            cur = cur->_next;
        }
        if (cur == _head)
            return NULL;
        return cur;
    }
    void Insert(Node *pos, const DataListtype&x)//插入
    { 
        prev newnode pos
        Node* prev = pos->_prev;
        Node* newnode = new Node(x);
        prev->_next = newnode;
        newnode->_prev = prev;
        newnode->_next = pos;
        pos->_prev = newnode;
    }
    void PopFront()//前删
    {
        assert(_head->_next != _head);
        //_head  next  next->_next
        Node* next = _head->_next;
        _head->_next = next->_next;
        next->_next->_prev = _head;
        delete next;
        next = NULL;
        Erase(_head->_next);
    }
    void PopBack()//尾删
    {
        /*assert(_head->_next != _head);
        Node* tail = _head->_prev;
        _head->_prev = tail->_prev;
        tail->_prev->_next = _head;
        delete tail;
        tail = NULL;*/
        Erase(_head->_prev);
    }
    void Erase(Node* pos)
    {
        prev   pos  next
        assert(pos!= _head);
        Node* prev = pos->_prev;
        Node* next = pos->_next;
        prev->_next = next;
        next->_prev = prev;
        delete pos;
        pos = NULL;
    }
    void print()
    {
        Node*cur = _head->_next;
        while (cur != _head)
        {
            cout << cur->_data << "->";
            cur = cur->_next;
        }
        printf("NULL\n");
    }
    size_t Size()//大小
    {
        size_t size = 0;
        Node* cur = _head->_next;
        while (cur != _head)
        {
            size++;
            cur = cur->_next;
        }
        return size;
    }
    bool empty()//判空
    {
        return _head->_next == _head;
    }
    ~Mylist()
    {
        Node *cur = _head->_next;
        while (cur != _head)
        {
            Node *next = cur->_next;
            delete cur;
            cur = next;
        }
        delete _head;//现在把头释放
        _head = NULL;
    }
private :
    Node* _head;
};
int main()
{
    Mylist l1;
    l1.PushBack(1);
    l1.PushFront(2);
    l1.print();
    Mylist l2(l1);
    Mylist l3;
    l3 = l2;
    l3.print();
    l2.print();
    l1.Insert(l1.Find(2), 3);
    l1.Insert(l1.Find(3)->_prev, 7);
    l1.print();
    l1.PopFront();
    l1.print();
    l1.PopBack();
    l1.print();
    l1.Erase(l1.Find(1));
    l1.PushBack(10);
    l1.PushFront(11);
    l1.print();
    printf("%d\n", l1.Size());
    l1.PopBack();
    l1.PopFront();
    l1.print();
    system("pause");
    return 0;
}

c++和c区别：
c++是自动调构造函数，自动调析构进行清理，面向对象
c面向过程，需要自己写初始化销毁函数等。