动态存储项目练习

动态存储

#include <stdio.h>
#define MAX_ELEMENT 100
#define ELEMENT_SIZE 100
#define MAX_ALPHABET 26

char g_szBuf[10000] = { 0 };
int stat_array[MAX_ALPHABET] = { 0 };

enum Operation { ADD = 1, DEL, MODIFY, QUERY, COUNT, PSTORE, ARRANGE, PALL };
enum QueryOps { QIDX = 1, QKEYSTR };

/* 以ELMENTSIZE为最小元素长度，将字符串以100的长度一一隔开。
   ELEMENTSIZE为99，预留最后一位为'\0'，方便删除函数实现。
*/

int IsStrEqual(char* str1, char* str2)
{
    while (1) {
        // 字符串长度相等，终止
        if (*str1 == '\0' && *str2 == '\0') {
            break;
        }
        // 字符串长度不等，终止
        if ((*str1 == '\0' && *str2 != '\0') ||
            (*str2 == '\0' && *str1 != '\0')) {
            return 0;
        }
        // 当前字符不相等，说明字符串不一致
        if (*str1 != *str2) {
            return 0;
        }
        // 当前字符相等，比较下一个字符
        str1++;
        str2++;
    }
    return 1;
}

void ElementAdd(int index, char* array)
{
    for (int i = 0; i <= ELEMENT_SIZE; i++) {
        if (array[i] == '\0') {
            return;
        }
        g_szBuf[index + i] = array[i];
    }
    return;
}

void Add(char* array)
{
    int i = 0;
    // 遍历100个元素的数组
    while (i < MAX_ELEMENT) {
        // 寻找空闲的元素
        if (g_szBuf[i * ELEMENT_SIZE] == 0) {
            ElementAdd(i * ELEMENT_SIZE, array);
            return;
        }
        i++;
    }
    printf("Full of memory. Fail to add new string.\n");
    return;
}

int QueryIdxByContent(char* str1)
{
    int i = 0;
    // 遍历100个元素的数组
    while (i < MAX_ELEMENT) {
        // 寻找有值的元素
        if (g_szBuf[i * ELEMENT_SIZE] != 0) {
            // 判断字符串是否相等
            if (IsStrEqual(str1, g_szBuf + (i * ELEMENT_SIZE))) {
                return i * ELEMENT_SIZE;
            }
        }
        i++;
    }
    return -1;
}


void ElementDelete(int index)
{
    for (int i = 0; i < ELEMENT_SIZE; i++) {
        g_szBuf[index + i] = 0;
    }
    return;
}

void Delete(char* array)
{
    // 基于字符串内容查询下标
    int index = QueryIdxByContent(array);
    if (index != -1) {
        ElementDelete(index);
    }
    return;
}

void Modify(char* old, char* new)
{
    int index = QueryIdxByContent(old);
    if (index != -1) {
        ElementDelete(index);
        ElementAdd(index, new);
    }
    return;
}

int MyStrLen(char* str1)
{
    int i = 0;
    while (*str1 != '\0') {
        i++;
        str1++;
    }
    return i;
}

int ContainSubString(char* str1, char* key)
{
    int keyLen = MyStrLen(key);
    int strLen = MyStrLen(str1);
    int isAllEqual;
    for (int i = 0; i < strLen; i++) {
        if (str1[i] == *key) {
            isAllEqual = 1;
            for (int j = 1; j < keyLen; j++) {
                if (str1[i + j] != key[j]) {
                    isAllEqual = 0;
                    continue;
                }
            }
            if (isAllEqual) {
                return 1;
            }
        }
    }
    return 0;
}

// 基于索引查找
void QueryByIdx(int index)
{
    if (index >= MAX_ELEMENT) {
        printf("Error: Query index exceeds maximum element size!\n");
        return;
    }
    if (g_szBuf[index * ELEMENT_SIZE] == 0) {
        printf("Empty memory. There is no string stored at this index!\n");
        return;
    }
    printf("%s at index %d\n", &g_szBuf[index * ELEMENT_SIZE], index);
}

void QueryByContent(char* key)
{
    for (int i = 0; i < MAX_ELEMENT; i++) {
        // 如果当前字符串包含key，则匹配成功，打印结果并返回
        if (ContainSubString(&g_szBuf[i * ELEMENT_SIZE], key)) {
            printf("%s at index %d\n", &g_szBuf[i * ELEMENT_SIZE], i);
        }
    }
    return;
}

void GetStatsForElem(int index)
{
    int asciiIndex;
    for (int i = 0; i < ELEMENT_SIZE; i++) {
        // 将字符转为ASCII码
        if (g_szBuf[index + i] >= 'A' && g_szBuf[index + i] <= 'Z') {
            asciiIndex = g_szBuf[index + i] - 'A';
            stat_array[asciiIndex]++;
        }
        if (g_szBuf[index + i] >= 'a' && g_szBuf[index + i] <= 'z') {
            asciiIndex = g_szBuf[index + i] - 'a';
            stat_array[asciiIndex]++;
        }
    }
    return;
}

void GetStats()
{
    // 每次统计前先清空原有数据
    for (int i = 0; i < MAX_ALPHABET; i++) {
        stat_array[i] = 0;
    }
    // 遍历数组，统计每个字符串元素
    for (int i = 0; i < MAX_ELEMENT; i++) {
        if (g_szBuf[i * ELEMENT_SIZE] != 0) {
            GetStatsForElem(i * ELEMENT_SIZE);
        }
    }
    // 打印
    for (int i = 0; i < MAX_ALPHABET; i++) {
        printf("%c, %d\n", i + 'a', stat_array[i]);
    }
    return;
}


void GetStoreInfo()
{
    for (int i = 0; i < MAX_ELEMENT; i++) {
        (g_szBuf[i * ELEMENT_SIZE] == 0) ? printf("F") : printf("U");
    }
    printf("\n");
    return;
}

// 基于当前索引，寻找下一个不为空的内存的索引
int GetNextNonEmptyMemoryIdx(int index)
{
    for (int i = index + 1; i < MAX_ELEMENT; i++) {
        if (g_szBuf[i * ELEMENT_SIZE] != 0) {
            return i;
        }
    }
    return -1;
}

void ArrangeMemory()
{
    int nonEmptyMemIdx;
    // 遍历数组，终止条件为遍历到倒数第二个元素为止，不需要检查最后一个元素
    for (int i = 0; i < MAX_ELEMENT - 1; i++) {
        // 判断当前内存是否为空，如果为空，则从之后的内存获取不为空的移过来
        if (g_szBuf[i * ELEMENT_SIZE] == 0) {
            // 获取下一个不为空内存的索引
            nonEmptyMemIdx = GetNextNonEmptyMemoryIdx(i);
            // 之后没有不为空的内存了，不需要继续整理，直接返回
            if (nonEmptyMemIdx == -1) {
                return;
            }
            // 有不为空的内存，将该内存复制到当前空的内存块
            ElementAdd(i * ELEMENT_SIZE, &g_szBuf[nonEmptyMemIdx * ELEMENT_SIZE]);
            // 删除原先不为空的内存记录
            ElementDelete(nonEmptyMemIdx * ELEMENT_SIZE);
        }
    }
    return;
}

int main()
{
    char input1[MAX_ELEMENT];
    char input2[MAX_ELEMENT];
    int operation;
    int queryChoice;
    int queryIdx;
    while (1) {
        printf("请输入功能对应数字\n");
        printf("1.增加\n");
        printf("2.删除\n");
        printf("3.修改\n");
        printf("4.查询\n");
        printf("5.统计\n");
        printf("6.打印存储信息\n");
        printf("7.整理内存\n");
        printf("8.打印当前数组\n");
        scanf("%d", &operation);
        for (int i = 0; i < MAX_ELEMENT; i++) {
            input1[i] = 0;
            input2[i] = 0;
        }
        switch (operation) {
        case ADD: {
            printf("请输入想添加的字符串：");
            scanf("%s", input1);
            Add(input1);
            break;
        }
        case DEL: {
            printf("请输入想删除的字符串：");
            scanf("%s", input1);
            Delete(input1);
            break;
        }
        case MODIFY: {
            printf("请输入原始字符串：");
            scanf("%s", input1);
            printf("请输入修改后的字符串：");
            scanf("%s", input2);
            Modify(input1, input2);
            break;
        }
        case QUERY: {
            printf("请选择查询方式，1.基于索引查询，2.模糊查询：");
            scanf("%d", &queryChoice);
            if (queryChoice == QIDX) {
                printf("请输入索引：");
                scanf("%d", &queryIdx);
                QueryByIdx(queryIdx);
            }
            else if (queryChoice == QKEYSTR) {
                printf("请输入关键字：");
                scanf("%s", input1);
                QueryByContent(input1);
            }
            break;
        }
        case COUNT: {
            GetStats();
            break;
        }
        case PSTORE: {
            GetStoreInfo();
            break;
        }
        case ARRANGE: {
            ArrangeMemory();
            break;
        }
        case PALL: {
            for (int i = 0; i < MAX_ELEMENT - 1; i++) {
                if (g_szBuf[i * ELEMENT_SIZE] == 0) {
                    printf("NULL, ");
                }
                else {
                    printf("%s, ", &g_szBuf[i * ELEMENT_SIZE]);
                }
            }
            if (g_szBuf[(MAX_ELEMENT - 1) * ELEMENT_SIZE] == 0) {
                printf("NULL\n");
            }
            else {
                printf("%s\n", &g_szBuf[(MAX_ELEMENT - 1) * ELEMENT_SIZE]);
            }
        }
        default: {
           
            break;
        }
        }
    }


    // char* str1 = "HA";
    // char* str2 = "world";
    // char* str3 = "happy";
    // char* str4 = "ppy";

    // Add(str1);
    // Add(str2);
    // Add(str3);
    // Add(str3);
    // Add(str3);
    // Add(str3);
    // Add(str3);
    // Add(str3);
    // Add(str3);

    // // Modify(str1, str3);
    // Delete(str2);
    // Delete(str3);
    // Delete(str3);
    // Delete(str3);
    // Delete(str3);
    // Delete(str3);

    // for (int i = 0; i < MAXELEMENT; i++) {
    //     printf("%s,", &g_array[i * ELEMENTSIZE]);
    // }
    // printf("\n");
    // // GetStats();
    // GetStoreInfo();
    // // ArrangeMemory();
    // // GetStoreInfo();
    // QueryByContent(str4);
    // QueryByIdx(8);

    // // printf("%d\n", IsStrEqual(str1, str4));
    // // printf("%s\n", g_array+100);
    return 0;
}