堆串

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>

typedef struct
{
    char* ch;
    int len;
}HString;

void Assign(HString* A, const char* a);//赋值串
void Put(HString* A);
void Insert(HString* A, int pos, const HString B);
void Delete(HString* A, int pos, int len);
void Cat(HString* A, const HString B);
void Sub(HString* A, int pos, int len, HString* B);

int main(void)
{
    int pos;//插入位置
    int len;
    HString A = { NULL, 0 };
    HString B = { NULL, 0 };
    char a[] = "hello world!";
    char b[] = "hi!";

    Assign(&A, a);
    Assign(&B, b);
    Put(&A);
    Put(&B);

    printf("请输入要插入的位置\n");
    scanf("%d", &pos);
    Insert(&A, pos, B);
    Put(&A);

    printf("\n请输入要删除的位置和长度(逗号分隔)\n");
    scanf("%d,%d", &pos, &len);
    Delete(&A, pos, len);
    Put(&A);

    printf("\n正在连接A和B\n");
    Cat(&A, B);
    Put(&A);
    
    printf("\n请输入子串在主串的位置和长度(逗号分隔)\n");
    scanf("%d,%d", &pos, &len);
    Sub(&A, pos, len, &B);
    Put(&B);

    system("pause");
    return 0;
}

void Assign(HString* A, const char* a)
{
    int i = 0;
    while (a[i] != '\0')
    {
        i++;
    }
    A->len = i;//串A的长度等于串a的长度
    if (A->len != 0)
    {
        if (A->ch != NULL)
        {
            free(A->ch);
        }
        if (NULL == (A->ch = (char*)calloc(A->len, sizeof(char))))//空间开辟失败
        {
            printf("\nclear and allocation fail !\n");
                exit(-1);
        }
        for (i = 0; i < A->len; i++)
        {
            A->ch[i] = a[i];
        }
    }
    else//当串A长度为0时，串A为空串
    {
        A->ch = NULL;
    }
}

void Put(HString* A)
{
    int i;
    printf("串值为:");
    for (i = 0; i < A->len; i++)
    {
        printf("%c", A->ch[i]);
    }
    printf("\n");
}

void Insert(HString* A, int pos, const HString B)
{
    int i;
    char* temp;
    if (pos < 0 || pos > A->len + 1)
    {
        printf("\n插入位置不合法!\n");
        exit(-1);
    }
    pos = pos - 1;//数组下标从0开始
    if (NULL == (temp = (char*)calloc(A->len + B.len, sizeof(char))))
    {
        printf("\nclean and callocation fail !\n");
        exit(-1);
    }
    for (i = 0; i < pos; i++)//把A串pos之前的字符赋给temp
    {
        temp[i] = A->ch[i];
    }
    for (i = pos; i < pos + B.len; i++)//把temp之间部分赋成串B的内容
    {
        temp[i] = B.ch[i - pos];
    }
    for (i = pos + B.len; i < A->len + B.len; i++)//把原pos之后的内容连接
    {
        temp[i] = A->ch[i - B.len];
    }
    free(A->ch);
    A->ch = temp;
    A->len = A->len + B.len;
}

void Delete(HString* A, int pos, int len)
{
    int i;
    char* temp;
    if (pos < 1 || pos > A->len || len < 1 || len > (A->len - pos + 1))
    {
        printf("%d", len);
        printf("\n删除参数不合法!\n");
        exit(-1);
    }
    pos = pos - 1;
    if (NULL == (temp = (char*)calloc(A->len - len, sizeof(char*))))
    {
        printf("\nclean and callocation fail !\n");
        exit(-1);
    }
    for (i = 0; i < pos; i++)//把A串pos之前的字符复制给temp
    {
        temp[i] = A->ch[i];
    }
    for (i = pos; i < A->len - len; i++)//把A串删除部分字符后，剩余部分字符复制给temp
    {
        temp[i] = A->ch[i + len];
    }
    free(A->ch);
    A->ch = temp;
    A->len = A->len - len;
}

void Cat(HString* A, const HString B)
{
    int i;
    if (NULL == (A->ch = (char*)realloc(A->ch, (A->len + B.len) * sizeof(char))))//函数realloc保留了串A原有的字符内容
    {
        printf("\nreset allocation fail !\n");
        exit(-1);
    }
    for (i = A->len; i < A->len + B.len; i++)
    {
        A->ch[i] = B.ch[i - A->len];
    }
    A->len = A->len + B.len;
}

void Sub(HString* A, int pos, int len, HString* B)
{
    int i;
    if (pos < 1 || pos > A->len + 1 || len < 1 || len > A->len - pos + 1)
    {
        printf("\n求子串参数不合法!\n");
        exit(-1);
    }
    pos = pos - 1;
    B->len = 0;
    if (B->ch != NULL)//清空子串
    {
        free(B->ch);
    }
    if (NULL == (B->ch = (char*)calloc(len, sizeof(char))))
    {
        printf("\nclean and allocation fail !\n");
        exit(-1);
    }
    for (i = pos; i < pos + len; i++)
    {
        B->ch[i - pos] = A->ch[i];
    }
    B->len = len;
}