数据结构与算法---复习：字符串（顺序表）

数据结构与算法—复习：字符串（顺序表）

/**
 * 程序说明：顺序表实现字符串
 * 1.创建一个空的字符串
 * 1.3. 判断字符串是否为空
 * 2.创建一个
 * 3.删除指定下标的字符
 * 4.在指定下标插入字符
 * 5.NULL
 * 6.返回指定下标的字符
 * 7.拼接字符串
 * 8.返回某字符串在主字符串中第一次出现的位置
 */
#include 
#include 

/**
 * 字符串类型的定义，与顺序表一致，替换了其中DataType
 */
struct SeqString{
    int MAXNUM;  //字符串最大长度
    int n;  //当前字符串长度
    char* c;  //字符串内容数组
};
typedef struct SeqString* PSeqString;

/**
 * 1.创建一个空的字符串
 * @param m
 * @return
 */
PSeqString createNullStr_seq(int m){
    PSeqString pstr = (PSeqString)malloc(sizeof(struct SeqString));
    if(pstr != NULL){
        pstr->c = (char*)malloc(sizeof(char)*m);
        if(pstr->c){
            pstr->MAXNUM = m;
            pstr->n = 0;
            return pstr;
        }else{
            free(pstr);
        }
    }
    printf("字符串头指针分配空间出错\n");
    return NULL;
}



/**
 * 1.2 初始化字符串数据
 * @param pstr
 * @param data
 */
void initString(PSeqString pstr,char data[],int size){
    if(pstr == NULL){
        printf("字符串为空，无法初始化\n");
        return;
    }
    for(int i = 0; i < size ;i++){
        pstr->c[i] = data[i];
        pstr->n++;
    }
    printf("初始化完成\n");
}

/**
 * 1.3 打印字符串
 * @param pstr
 */
void printString(PSeqString pstr){
    if(pstr == NULL){
        printf("字符串为空，无法打印\n");
        return;
    }
    for(int i=0;i<pstr->n;i++)
    {
        printf("%c",pstr->c[i]);
    }
    printf("\n");
}

/**
 * 1.3.判断字符串是否为空
 * @param pstr
 * @return
 */
int isNullString_seq(PSeqString pstr){
    if(pstr->n == 0)
        return 1;
    else
        return 0;
}

/**
 * 2.求子串 从第i个字符开始的后续j个
 * abcdef 中 a就是第一个（不按照下标考虑，按照考虑）
 * @param pstr
 * @param i
 * @param j
 * @return
 */
PSeqString subStr_seq(PSeqString pstr,int i,int j){
    if(pstr == NULL || isNullString_seq(pstr)){
        printf("字符串不存在或为空，无法执行求子串操作\n");
        return NULL;
    }
    /*求从s所指的顺序串第i个字符开始连续的j个字符所构成的子串*/
    PSeqString pstr_son;
    int k;
    pstr_son = createNullStr_seq(j);
    if(pstr_son == NULL) return NULL;
    if(i>0 && i<=pstr->n && j>0){
        if(pstr->n < i+j-1)
            j = pstr->n -i + 1;
        for(k=0;k<j;k++){
            pstr_son->c[k] = pstr->c[i+k-1];
        }
        pstr_son->n = j;
    }
    return pstr_son;
}
/**
 * 3.删除指定下标的字符
 * @param pstr
 * @param p
 * @return
 */
int deleteP_SeqString(PSeqString pstr,int p){
    if(pstr == NULL || isNullString_seq(pstr)){
        printf("字符串不存在或为空，无法执行删除操作\n");
        return -1;
    }
    if(p<0 || p>pstr->n){
        printf("所给下标超出字符串范围\n");
        return -1;
    }
    for(int i=p;i<pstr->n;i++){
        if(i+1 != pstr->n)
            pstr->c[i] = pstr->c[i+1];
    }
    pstr->n--;
}

/**
 * 4.在指定的下标插入字符
 * @param pstr
 * @param p
 * @param c
 * @return
 */
int insertChar(PSeqString pstr,int p,char c){
    if(pstr == NULL || isNullString_seq(pstr)){
        printf("字符串不存在或为空，无法执行插入操作\n");
        return -1;
    }
    if(p<0 || p>pstr->n){
        printf("所给下标超出字符串范围\n");
        return -1;
    }
    pstr->n++;
    for(int i = pstr->n - 1;i > p; i--){
        pstr->c[i] = pstr->c[i-1];
    }
    pstr->c[p] = c;
    return 1;
}

/**
 * 6.返回指定下标的字符
 * @param pstr
 * @param postion
 * @return
 */
char charAt(PSeqString pstr,int postion){
    if(pstr == NULL || isNullString_seq(pstr)){
        printf("字符串不存在或字符串长度为空\n");
        return '!';
    }
    return pstr->c[postion - 1];
}

/**
 * 7.拼接两个字符串
 * @param s1
 * @param s2
 * @return
 */
PSeqString concat(PSeqString s1,PSeqString s2){
    int len = s1->n+s2->n;
    int flag = 0;
    PSeqString s = createNullStr_seq(len);
    for(int i=0;i<len;i++)
    {
        if(i>=s1->n){
            s->c[i] = s2->c[flag];
            s->n++;
            flag++;
        }else{
            s->c[i] = s1->c[i];
            s->n++;
        }
    }
    return s;
}

/**
 * 8.找出子串第一次出现在主串的位置
 * @param s1
 * @param s2
 * @return
 */
int Index(PSeqString s1,PSeqString s2){
    if(s1 == NULL || isNullString_seq(s1)){
        printf("主串不存在或为空，无法执行操作\n");
        return -1;
    }
    if(s2 == NULL || isNullString_seq(s2))
        return -1;
    int p = 0;
    int mark = 1;
    for(int i=0;i<=s1->n;i++){
        if(p == s2->n){
            return (i - p);
        }
        if(s1->c[i] != s2->c[p]){
            //如果不匹配，指针回溯
            i = mark - 1;
            mark++;
            p = 0;
        }else{
            p++;
        }
    }
    return -1;
}
int main(){
    //测试：1.创建空的字符串
    printf("测试：1.创建空的字符串\n");
    PSeqString pstr = createNullStr_seq(100);
    if(pstr)
        printf("创建成功\n");
    //初始化字符串数据
    char data[] = {'a','b','c','d','e','f'};
    int size = (sizeof(data) / sizeof(char));
    printf("%d\n",size);
    initString(pstr,data,size);
    printString(pstr);
    printf("==================================\n");
    //测试：2.截取子串
    printf("测试：2.截取子串\n");
    PSeqString pstr_son = subStr_seq(pstr,1,3);
    printString(pstr_son);
    printf("==================================\n");
    //测试：3.删除指定下标的字符
    printf("测试：3.删除指定下标的字符,删除下标1\n");
    printString(pstr);
    deleteP_SeqString(pstr,1);
    printString(pstr);
    printf("==================================\n");
    //测试：4.在指定下标插入字符
    printf("测试：4.在指定下标插入字符:b\n");
    printString(pstr);
    insertChar(pstr,1,'b');
    printString(pstr);
    printf("==================================\n");
    //测试：5.判断字符串是否为空
    printf("测试：5.判断字符串是否为空：%d\n",isNullString_seq(pstr));
    printf("==================================\n");
    //测试：6.返回字符串指定下标的字符
    printf("测试：6.返回字符串指定下标的字符:\n");
    printf("字符串的第%d个字符是：%c\n",1,charAt(pstr,1));
    printf("==================================\n");
    //测试：7.拼接字符串
    printf("测试：7.拼接下面两个字符串:\n");
    printString(pstr);
    printString(pstr_son);
    printString(concat(pstr,pstr_son));
    //测试：8.寻找子串第一次出现的位置
    printf("测试：8.寻找子串第一次出现的位置:\n");
    printString(pstr);
    PSeqString test = createNullStr_seq(100);
    //初始化字符串数据
    char t[] = {' '};
    int size2 = (sizeof(t) / sizeof(char));
    printf("%d\n",size2);
    initString(test,t,size2);
    printString(test);
    printf("是否找到：%d\n",Index(pstr,test));
}