数据结构-串的堆分配存储

串的堆分配存储表示的特点是，仍以一组地址连续的存储单元存放串值字符序列，但它们的存储空间是在程序执行过程中动态分配的。使用动态分配函数malloc()和函数free()来管理存储空间的大小。

串的堆分配存储方法具有顺序存储的特点，又弥补了定长存储的大小限制，多以多被采用。

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

typedef int Status;
#define OK 1
#define ERROR 0
#define OVERFLOW -2

typedef struct{
    char *ch;    //若是非空串，则按串长度分配存储区域，否则ch为NULL
    int length;    //串的长度
}String;

/*生成一个其值等于等于串常量chars的串T*/
Status StrAssign(String &T, char *chars){
    if(T.ch)
        free(T.ch);    //若串存储空间不为NULl 释放原有空间
    int i = strlen(chars);    //获取chars长度
    if(!i){
        T.ch = NULL;    //串常量chars长度为0时串为空串长度0存储区间指向NULL
        T.length = 0;
    }
    else{
        T.ch = (char *)malloc(i * sizeof(char));    //申请空间
        if(!T.ch)
            exit(OVERFLOW);
        for(int j = 0; j < i; j++)
            T.ch[j] = chars[j];        //写入chars串
        T.length = i;
    }
    return OK;
}

/*由串S复制得到T*/
Status StrCopy(String &T, String S){
    if(T.ch)
        free(T.ch);
    T.ch = (char*)malloc(S.length * sizeof(char));
    if(!T.ch)
        exit(OVERFLOW);
    for(int j = 0; j < S.length; j++)
        T.ch[j] = S.ch[j];    
    T.length = S.length;
    return OK;
}

/*如果串S为空串则返回true否则返回false*/
bool StrEmpty(String S){
    if(S.length == 0)
        return true;
    else
        return false;
}

/*若S>T，则返回值>0；若S=T,则返回值=0；若S<T，则返回值<0*/
int StrCompare(String T, String S){
    for(int i = 0; i < S.length && i < T.length; i++)
        if(S.ch[i] != T.ch[i])
            return S.ch[i] - T.ch[i];
    return S.length - T.length;
}

/*返回串的长度*/
int StrLength(String S){
    return S.length;
}

/*清空串*/
Status ClearString(String &S){
    if(S.ch){
        free(S.ch);
        S.ch =  NULL;
    }
    S.length = 0;
    return OK;
}

/*用T返回S1和S2两个串的连接串*/
Status Concat(String &T, String S1, String S2){
    T.length = S1.length + S2.length;
    if(T.ch)
        free(T.ch);
    T.ch = (char*)malloc(T.length * sizeof(char));
    if(!T.ch)
        exit(OVERFLOW);
   for(int i=0; i < S1.length; i++)
     T.ch[i] = S1.ch[i];
   for(int i=0; i < S2.length;i++)
     T.ch[S1.length+i] = S2.ch[i];
    return OK;
}

/*用Sub返回串S的第pos位置起的长度len的子串*/
Status SubString(String &Sub, String S, int pos, int len){
    if(pos<1 || pos>S.length || len<0 || len>S.length-pos+1)
        return ERROR;
    if(Sub.ch)
        free(Sub.ch);
    if(!len){
        Sub.ch = NULL;
        Sub.length = 0;
    }
    else{
        Sub.ch = (char*)malloc(len*sizeof(char));
        if(!Sub.ch)
            exit(OVERFLOW);
        for(int i = 0; i < len-1; i++)
            Sub.ch[i] = S.ch[pos-1+i];
        Sub.length = len;
    }
    return OK;
}


Status Index(String S, String T, int pos){
    /*Index函数有两种写法，一种是调用串函数实现一个个字符匹配；另一种是模式串匹配法，详细写法与
        定长表示法的写法基本一样，可以去参考另一篇定长表示串的函数
    */
   return ERROR;
}

/*在串S的第pos个字符之前插入串T*/
Status StrInsert(String S,int pos,String T)
 {
   if(pos<1 || pos>S.length+1)
     return ERROR;
   if(T.length){
     S.ch = (char*)realloc(S.ch,(S.length+T.length)*sizeof(char));
     if(!S.ch)
       exit(OVERFLOW);
     for(int i = S.length-1; i >= pos-1; --i)
       S.ch[i+T.length] = S.ch[i];
     for(int i = 0; i < T.length; i++)
       S.ch[pos-1+i] = T.ch[i];
     S.length += T.length;
   }
   return OK;
 }

/* 从串S中删除第pos个字符起长度为len的子串 */
 Status StrDelete(String S,int pos,int len)
 { 
   if(S.length < pos+len-1)
     exit(ERROR);
   for(int i = pos-1; i <= S.length-len; i++)
     S.ch[i] = S.ch[i+len];
   S.length -= len;
   S.ch = (char*)realloc(S.ch,S.length*sizeof(char));
   return OK;
 }
 /*用V替换主串S中出现的所有与T相等的不重叠的子串 */
 Status Replace(String &S,String T,String V)
 {
   int i=1;
   if(StrEmpty(T))
     return ERROR;
   do{
     i=Index(S,T,i);
     if(i)
     {
       StrDelete(S,i,StrLength(T)); 
       StrInsert(S,i,V); 
       i += StrLength(V);
     }
   }while(i);
   return OK;
 }