数据结构与算法：实验一线性表（字符串分类统计）

【问题描述】

l 定义和声明一个线性表ADT

l 基于顺序表或者链表实现线性表ADT（具体采用顺序表或者哪种链表可自行选择）

l 输入一行字符，存入线性表中，要求编写测试程序，能统计出其中英文字母、数字、其他字符的个数，并输出删除所有数字后得到的新的字符串。

【输入形式】

从标准输入读入数据     

第一行输入一行字符

【输出形式】

输出到标准输出  

包含两行：

第一行：统计值，包括英文字母、数字、其他字符的个数，依次输出，数据和数据之间使用空格隔开

第二行：输出删除数字后的新字符串

【样例输入】

 aklsjflj123sadf918u324asdf91u32oasdf/.;123

【样例输出】

 23 16 3

 aklsjfljsadfuasdf1uoasdf/.;

【样例说明】

         英文字母、数字、其他字符的个数，依次为23,16和3

         第二行是删除数字后的字符串

【测试样例的规模】

        输入的字符串的长度小于等于XXX

【代码提交及评分要求】

   源代码请提交工程压缩包，压缩包内至少包含以下三个文件：

1）XXX．h：线性表ADT的定义和声明

2）XXX．h：线性表ADT的实现

3）XXXXX．cpp：主程序

（要求基于ADT实现，否则计0分。）

list.h

#ifndef LIST
#define LIST
template <typename T>
class List
{
private:
    int max_size;
    int list_size;
    int curr; //当前元素的位置
    T *list_array;

public:
    // 构造函数
    List() {}
    // 析构函数
    virtual ~List() {}
    // 清空List
    virtual void clear() = 0;
    // 在index位置插入元素val
    virtual void insert(int index, T &val) = 0;
    // 在结尾处val
    virtual void append(T &val) = 0;
    // 删除索引index处的元素
    virtual void remove(int index) = 0;
    // 删除结尾元素并返回值
    virtual T pop() = 0;
    // 返回索引index处的元素
    virtual T get_value(int index) = 0;
    // 输出数组
    virtual void print_list() = 0;
    // 获取长度
    virtual int length() = 0;
};
#endif

AList.h

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

template <typename T>
class AList : public List<T>
{
private:
    int max_size;
    int list_size;
    T *list_array;

public:
    // 构造函数
    AList(int size = 100)
    {
        max_size = size;
        list_size = 0;
        list_array = new T[max_size];
    }
    ~AList()
    {
        delete[] list_array;
    }
    void clear()
    {
        delete[] list_array;
        list_size = 0;
        list_array = new T[max_size]; //新建空数组
    }
    void insert(int index, T &val)
    {
        assert(list_size < max_size);
        for (int i = list_size; i >= 0; i--)
        {
            if (i == index)
            {
                list_size++;
                list_array[i] = val;
                return;
            }
            list_array[i] = list_array[i - 1];
        }
    }
    void append(T &val)
    {
        assert(list_size < max_size);
        list_array[list_size++] = val;
    }
    void remove(int index)
    {
        for (int i = index; i < list_size - 1; i++)
        {
            list_array[i] = list_array[i + 1];
        }
        --list_size;
    }
    T pop()
    {
        return list_array[--list_size];
    }
    T get_value(int index)
    {
        return list_array[index];
    }
    void print_list()
    {
        for (int i = 0; i < list_size; i++)
        {
            cout << list_array[i];
        }
    }
    int length()
    {
        return list_size;
    }
};

AListTest.cpp

// #include <bits/stdc++.h>
#include "list.h"
#include "AList.h"
#include <iostream>
using namespace std;

int main()
{
    AList<char> l(1000);
    char s;
    s = cin.get();
    while (s != '\n')
    {
        l.append(s);
        s = cin.get();
    }
    int len = l.length();
    if (len == 0)
        return 0;
    int dig_num = 0, letter_num = 0, other_num = 0;
    for (int i = 0; i < len;)
    {
        if ((l.get_value(i) >= 'a' && l.get_value(i) <= 'z') || (l.get_value(i) >= 'A' && l.get_value(i) <= 'Z'))
        {
            letter_num++;
            i++;
        }
        else if (l.get_value(i) >= '0' && l.get_value(i) <= '9')
        {
            dig_num++;
            l.remove(i);
            len--;
        }
        else
        {
            other_num++;
            i++;
        }
    }
    cout << letter_num << ' ' << dig_num << ' ' << other_num << endl;
    l.print_list();
    return 0;
}