编程题 编写一个函数，输入参数为三个：主字符串，子字符

#include<iostream>
using namespace std;
/*
不使用内置函数：
两个指针，一个指向主字符串，另一个指向子字符串
分隔符另外考虑
## 完全参考答案模板
*/
bool subString(const char *sstr ,const char *substr,const char split){
    const char *p1 = sstr;
    char split_flag = 0;
    const char *p2 = substr;

    if(!p1 || !p2 ||!p1[0] || !p2[0]){
        return false;
    }
    while(p1[0] && p2[0]){
        if((p1[0]==p2[0])&& (p2 != substr || !split_flag || split_flag == split)){
            //当前字符匹配 且（子字符串还没检查完 || 还没有遇到间隔符  || 当前匹配的字符是间隔符<子字符串也由多个字符串组成的情况>）
            p2++;  //继续检查匹配
        }else{
            p2 = substr;
        }

        if(!p2[0]){   //子字符串已经匹配完成了
            if(!p1[1] || p1[1] == split)
                return true;
            else    
                p2 = substr;
        }
        split_flag = p1[0];
        p1++;
    }
    return false;
}

int main(){
    cout<<subString("1,bv,443s,9s9s","9s9s",',')<<endl;
    system("pause");
    return 0;
}

static int f(String str,String substr,char spilt){
        for (int i = 0,j=0; i < str.length(); i++) {
            if(j==substr.length()){
                return i-1;//子串是空串返回-1，找到子串返回主串的下标
            }else if(str.charAt(i)==spilt||str.charAt(i)!=substr.charAt(j)){
                j=0;
            }else {
                j++;
            }
        }
        return -1;//返回-1，
    }

public class SolutionSubString {
	public static void main(String[] args) {
		System.out.println(subString("1,bv,443s,9s9s","9s9s",","));
	}
	public static boolean subString(String str,String subString,String split) {
		if(isBlank(str)||isBlank(subString)||isBlank(split)) return false;
		String[] strs = str.split(split);
		for(String s : strs) {
			if(subString.equals(s)) return true;
		}
		return false;
	}
	public static boolean isBlank(String str) {
		if(str.isEmpty()||str.length()<=0||str==null) return true;
		return false;
	}
}

bool List(const char * p1 , const char * p2 , const char c1)
{
	//p3保留住p2的初始位置，方便复原p2的位置
	const char *p3 = p2;
	while (*p1)
	{
		if(*p2 == '\0') 
		{
			break;
		}
		else if(*p1 == c1 || *p2 != *p1) 
		{
			//重置p2
			p2 = p3;
		}
		else if(*p1 == *p2) 
		{
			//移动p2
			p2++;
		}	
		//移动p1
		p1++;
	}
	if (*p2 != '\0') 
	{
		return false;	
	}
	else
	{
		return true;
	}
}

public static  boolean isSubString(String  FStr, String SStr,char f){
            boolean flag=false;
            //遍历父串指针
            int i=0;
            //遍历子串指针
            int j=0;
            while (i< FStr.length()){
               if(FStr.charAt(i)!=f&&SStr.charAt(j)==FStr.charAt(i)){
                   if (j==SStr.length()-1){//字串遍历完成
                       if (FStr.charAt(i+1)==f){//下一位是分隔符
                           flag=true;
                           break;
                       }
                       break ;}
                   i++;
                   j++;
               }else{
                   i++;
                   j=0;
               }
            }
            return flag;
        }

public boolean subString(String str, String subStr, String split) {
    if(isBlank(str) || isBlank(subStr) || isBlank(split)) {
        return false;
    }
    String[] strs = str.split(split);
    for(int i = 0; i < strs.length; i++) {
        if(subStr.equals(strs[i])) {
            return true;
        }
    }
    return false;
}

public boolean isBlank(String string) {
    if(string.length() == 0 || string == null) {
        return true;
    }
    return false;
}

public Class Test{
        public static boolean isExist(String str,String target){
        if (str == null || target == null ||str.length() <= 0 || target.length() <= 0 ) return false;
        if(target.length() > str.length()) return false;//子串比源串长，直接返回
        int tIndex = 0;//子串索引位置
        int count = 0;//匹配子串的字符个数
        for(int i = 0 ; i < str.length(); i++){//遍历字符串
            System.out.println(i);
            int temp = i;//保存字符串遍历位置
            while (tIndex < target.length()) {
                boolean flag = (target.charAt(tIndex++)) == (str.charAt(i));//匹配标志
                if (flag) i++;//匹配子串成功，继续匹配下一个字符
                else i = temp;//匹配子串失败，恢复遍历位置
                System.out.println("flag = " + flag);
                if (flag) count ++;//统计匹配子串字符的个数
            }
            if(count == target.length()){//如果匹配统计等于子串长度，说明匹配成功，返回，不再后续匹配
                return true;
            }
            tIndex = 0;//恢复子串索引位置
            count = 0;//恢复统计个数
        }
        return false;
    }
    public static boolean isExist(String str,String target,String symbol){
        if (str == null) return false;
        String[] group = null;
        if (str.contains(",")){
            group = str.split(",");//分组
        }
        if (group == null) return isExist(str,target);
        else {
            boolean flag;//匹配成功标志
            for (String s : group) {
                System.out.println("group =" + s);//每组源串
                flag = isExist(s, target);
                if (flag) return true;//匹配成功，返回
            }
            return false;
        }
    }
    public static void main(String[] args) {
        System.out.println("测试匹配结果：" + isExist("abc,dec,fg", "de", ","));
        System.out.println("测试不匹配结果：" + isExist("abc,dec,fg", "def", ","));
    }
}

    public static boolean panduan(String str1, String str2, char c){
        int index = 0;
        boolean n1 = true;
        for(int i = 0; i < str2.length(); i++){
            if(str1.charAt(i) != str2.charAt(i)){
                n1 = false;
            }
        }
        if(n1 && str1.charAt(str2.length()) == c){
            return true;
        }

        boolean n2 =true;
        int num = str2.length() - 1;
        for(int i = str1.length() - 1; i >= str1.length() - str2.length(); i--){
            if(str1.charAt(i) != str2.charAt(num)){
                n2 = false;
            }
            num--;
        }
        if(n2 && str1.charAt(str1.length() - str2.length() - 1) == c){
            return true;
        }
        for(int i = 0; i < str1.length(); i++){
            if(str1.charAt(i) == str2.charAt(index)){
                index++;
                if(index == str2.length() ){
                    if(str1.charAt(i + 1) == c && str1.charAt(i - str2.length()) == c){
                        return true;
                    }
                }
            } else{
                index = 0;
            }
        }
        return false;
    }

     private static boolean isStringExsits(String mainStr,String subStr,char spl) {
        char [] ch =mainStr.toCharArray();
        List <String> list = new ArrayList<>();
        String newStr="";
        for (int i = 0; i < ch.length; i++) {

            if (ch[i]!=spl){
                newStr += ch[i];
            }else {
                list.add(newStr);
                newStr ="";
            }
            if (i==ch.length-1){
                list.add(newStr);
                newStr ="";
            }
        }
        for (String str : list) {
            if (str.equals(subStr)){
                return true;
            }
        }
        return false;
    }