精华内容
下载资源
问答
  • 基本概念

    千次阅读 2020-03-23 09:02:20
    1.基本概念 字符(String):是由零个或多个字符组成的有限序列,记为:S = ′a1 a2 … an′( n ≥ 0 ) ai∈V字符集合,每个 ai( 1 ≤ i≤ n)可以是字母、数字或其他字符。 也是一种特定的线性表,的逻辑...
    1.串的基本概念

    字符串(String):是由零个或多个字符组成的有限序列,记为:S = ′a1 a2 … an′( n ≥ 0 )
    ai∈V字符集合,每个 ai( 1 ≤ i≤ n)可以是字母、数字或其他字符。
    串也是一种特定的线性表,串的逻辑结构和线性表极为相似,其特定性仅在于串的数据对象限定为字符集。

    1. 串的名字:S
    2. 串的值:用单引号括起来的字符序列
    3. 串的长度:n 是串中字符的个数
    4. 空串( Null String):n=0 时的串
    5. 空格串:一个或多个空格组成的串,其长度为空格个数。
    6. 串相等:当且仅当两个串的值相等时,称这两个串是相等的。即只有当两个串的长度相等,并且每个对应位置的字符都相等时才相等。

    需要特别指出的是,串值必须用一对单引号括起来( C 语言中是双引号),但单引号是界限符,它不属于串,其作用是避免与变量名或常量混淆。

    1. 子串:串中任意个连续的字符组成的子序列称为该串的子串。
    2. 主串:包含子串的串相应地称为主串。可见,子串是主串的一部分。
    3. 求子串:sub(主串,起始位置,长度)
      例:sub(‘china’,2,2)=‘in’
    4. 模式串在主串种的位置(串的模式匹配)
      从主串起始位置起,模式串在主串种首次出现的位置序号
      例:主串‘chinachina’模式串‘in’
      如起始位置为0,则模式串第一个字符在主串种的位置为2
      如起始位置为3,则模式串第一个字符在主串种的位置为7
    2.串的抽象数据类型定义

    ADT String {
    数据对象: D={ ai | ai∈ CharacterSet,记为 V,i=1 ,2 ,…, n,n≥ 0 }
    结构关系: R={< ai,ai + 1 >| ai,ai + 1 ∈ V,i=1 ,…, n-1 ; n-1 ≥ 0 }
    基本操作:
    ( 1 ) StrAsign( S,chars)
    操作前提: chars 是字符串常量。
    操作结果:生成一个值等于 chars 的串 S。
    ( 2 ) StrInsert( S,pos,T)
    操作前提:串 S 存在,1 ≤ pos≤ StrLength( S)+ 1 。
    操作结果:在串 S 的第 pos 个字符之前插入串 T。
    ( 3 ) StrDelete( S,pos,len)
    操作前提:串 S 存在,1 ≤ pos≤ StrLength( S)+ 1 。
    操作结果:从串 S 中删除第 pos 个字符起长度为 len 的子串。
    ( 4 ) StrCopy( S,T)
    操作前提:串 S 存在。
    操作结果:由串 T 复制得串 S。
    ( 5 ) StrEmpty( S)
    操作前提:串 S 存在。
    操作结果:若串 S 为空串,则返回 TRUE,否则返回 FALSE。
    ( 6 ) StrCompare( S,T)
    操作前提:串 S 和 T 存在。
    操作结果:若 S>T,则返回值>0 ;如 S=T,则返回值=0 ;若 S<T,则返回值<0 。
    ( 7 ) StrLength( S)
    操作前提:串 S 存在。
    操作结果:返回串 S 的长度,即串 S 中的字符个数。
    ( 8 ) StrClear( S)
    操作前提:串 S 存在。
    操作结果:将 S 清为空串。
    ( 9 ) StrCat( S,T)
    操作前提:串 S 和 T 存在。
    操作结果:将串 T 的值连接在串 S 的后面。
    ( 10 ) SubString( Sub,S,pos,len)
    操作前提:串 S 存在,1 ≤ pos≤ StrLength( S)且 1 ≤ len≤ StrLength( S)-
    pos+1 。
    操作结果:用 Sub 返回串 S 的第 pos 个字符起长度为 len 的子串。
    ( 11 ) StrIndex( S,pos,T)
    操作前提:串 S 和 T 存在,T 是非空串,1 ≤ pos≤ StrLength( S)。
    操作结果:若串 S 中存在和串 T 相同的子串,则返回它在串 S 中第 pos 个字符

    后第一次出现的位置;否则返回 0 。
    ( 12 ) StrReplace( S,T,V)
    操作前提:串 S、 T 和 V 存在且 T 是非空串。
    操作结果:用 V 替换串 S 中出现的所有与 T 相等的不重叠的子串。
    ( 13 ) StrDestroy( S)
    操作前提:串 S 存在。
    操作结果:销毁串 S。
    }ADT string

    展开全文
  • 基本概念和顺序

    千次阅读 2018-03-05 19:01:21
    一、 基本概念串(或字符),是由零个或多个字符组成的有穷序列。含零个字符的称为空串,用Ф表示。中所含字符的个数称为该的长度(或长)。通常将一个表示成“a1a2…an”的形式。其中最外边的双...

    一、 串的基本概念

    串(或字符串),是由零个或多个字符组成的有穷序列。

    含零个字符的串称为空串,用Ф表示。串中所含字符的个数称为该串的长度(或串长)。

    通常将一个串表示成“a1a2…an”的形式。其中最外边的双引号本身不是串的内容,它们是串的标志,以便将串与标识符(如变量名等)加以区别。每个ai(1≤i≤n)代表一个字符。

    当且仅当两个串的长度相等并且各个对应位置上的字符都相同时,这两个串才是相等的。

    一个串中任意个连续字符组成的子序列(含空串)称为该串的子串。例如,“a”、“ab”、“abc”和“abcd”等都是“abcde”的子串(真子串是指不包含自身的所有子串)。

    二、串的顺序存储及其基本操作实现      

    在顺序串中,串中的字符被依次存放在一组连续的存储单元里。一般来说,一个字节(8位)可以表示一个字符(即该字符的ASCII码)。

    因此,一个内存单元可以存储多个字符。例如,一个32位的内存单元可以存储4个字符(即4个字符的ASCII码)。 

    串的顺序存储有两种方法:一种是每个单元只存一个字符,这称为非紧缩格式(其存储密度小);另一种是每个单元存放多个字符,这称为紧缩格式(其存储密度大)。 

    对于非紧缩格式的顺序串,其类型定义如下: 

    #define MaxSize 100
    typedef struct
    {  char data[MaxSize];
       int length;

    } SqString;

    顺序串中实现串的基本运算如下:

    (1)StrAssign(s,cstr)

    将一个字符串常量赋给串s,即生成一个其值等于cstr的串s。

    void StrAssign(SqString &s,char cstr[])//s为引用型参数
    {  int i;
       for (i=0;cstr[i]!='\0';i++)
    s.data[i]=cstr[i];
       s.length=i;

    }

    (2)StrCopy(s,t)

    将串t复制给串s。

    void StrCopy(SqString &s,SqString t)//s为引用型参数
    {  int i;
       for (i=0;i<t.length;i++)
    s.data[i]=t.data[i];
       s.length=t.length;

    }

    (3)StrEqual(s,t)

     判串相等:若两个串s与t相等返回真(1);否则返回假(0)。

    bool StrEqual(SqString s,SqString t)
    {  bool same=true;
       int i;
       if (s.length!=t.length) //长度不相等时返回0
    same=false;
       else 
    for (i=0;i<s.length;i++)
      if (s.data[i]!=t.data[i])
      {   same=false;
    break;
      }
       return same;

    }

    (4)StrLength(s)

    求串长:返回串s中字符个数。

    int StrLength(SqString s)
    {
       return s.length;

    }

    (5)Concat(s,t)

    串连接:返回由两个串s和t连接在一起形成的新串。

    SqString Concat(SqString s,SqString t)
    {  SqString str;
       int i;
       str.length=s.length+t.length;
       for (i=0;i<s.length;i++) //s.data[0..s.length-1]str
    str.data[i]=s.data[i];
       for (i=0;i<t.length;i++) //t.data[0..t.length-1]str
    str.data[s.length+i]=t.data[i];
       return str;

    }

    (6)SubStr(s,i,j)

     求子串:返回串s中从第i(1≤i≤StrLength(s))个字符开始的、由连续j个字符组成的子串。参数不正确时返回一个空串。

    SqString SubStr(SqString s,int i,int j)
    {  SqString str;
       int k;
       str.length=0;
       if (i<=0 || i>s.length || j<0 || i+j-1>s.length)
    return str; //参数不正确时返回空串
       for (k=i-1;k<i+j-1;k++) //s.data[i..i+j]str
    str.data[k-i+1]=s.data[k];
       str.length=j;
       return str;

    (7)InsStr(s1,i,s2)

    将串s2插入到串s1的第i(1≤i≤StrLength(s)+1)个字符中,即将s2的第一个字符作为s1的第i个字符,并返回产生的新串。参数不正确时返回一个空串。

    SqString InsStr(SqString s1,int i,SqString s2)
    {  int j;  SqString str;
       str.length=0;
       if (i<=0 || i>s1.length+1)  //参数不正确时返回空串
    return str;
       for (j=0;j<i-1;j++)        //将s1.data[0..i-2]str
    str.data[j]=s1.data[j];
       for (j=0;j<s2.length;j++)        //s2.data[0..s2.length-1]str
    str.data[i+j-1]=s2.data[j];
       for (j=i-1;j<s1.length;j++)    //s1.data[i-1..s1.length-1]str
    str.data[s2.length+j]=s1.data[j];
       str.length=s1.length+s2.length;
       return str;

    }

    (8)DelStr(s,i,j)

    从串s中删去第i(1≤i≤StrLength(s))个字符开始的长度为j的子串,并返回产生的新串。参数不正确时返回一个空串。

    SqString DelStr(SqString s,int i,int j)
    {  int k; SqString str;
       str.length=0;
       if (i<=0 || i>s.length || i+j>s.length+1) return str;        //参数不正确时返回空串
       for (k=0;k<i-1;k++) //s.data[0..i-2]str
    str.data[k]=s.data[k];
       for (k=i+j-1;k<s.length;k++)  //s.data[i+j-1..s.length-1]str
    str.data[k-j]=s.data[k];
       str.length=s.length-j;
       return str;

    }

    (9)RepStr(s,i,j,t) 

    在串s中,将第i(1≤i≤StrLength(s))个字符开始的j个字符构成的子串用串t替换,并返回产生的新串。参数不正确时返回一个空串。

    SqString RepStr(SqString s,int i,int j,SqString t)
    {  int k; SqString str; str.length=0;
       if (i<=0 || i>s.length || i+j-1>s.length)       
          return str; //参数不正确时返回空串
       for (k=0;k<i-1;k++) //s.data[0..i-2]str
    str.data[k]=s.data[k];
       for (k=0;k<t.length;k++)     //t.data[0..t.length-1]str
    str.data[i+k-1]=t.data[k];
       for (k=i+j-1;k<s.length;k++) //s.data[i+j-1..s.length-1]str
    str.data[t.length+k-j]=s.data[k];
       str.length=s.length-j+t.length;
       return str;

    }

    (10)DispStr(s)

    输出串s的所有元素值。

    void DispStr(SqString s)
    {  int i;
       if (s.length>0)
       {  for (i=0;i<s.length;i++)
       printf("%c",s.data[i]);
    printf("\n");
       }
    }

    展开全文
  • 基本概念

    千次阅读 2018-07-06 13:03:31
    当中的字符数目n称为是的长度,零个字符的可以称为是空串,需要注意的是这个空串和空格是不同的,空格是只包含空格的,空格是有长度的,可以不止有一个空格 子串与主中任意个数的连续字符...

    对于数据结构的这些方面其实主要是为了做个总结,记录知识点

    串的定义:是由零个或多个字符组成的有限序列,也称为字符串

    串当中的字符数目n称为是串的长度,零个字符的串可以称为是空串,需要注意的是这个空串和空格串是不同的,空格串是只包含空格的串,空格串是有长度的,可以不止有一个空格

    子串与主串,串中任意个数的连续字符组成的子序列称为该串的子串,相应地,包含子串的串称为主串,子串在主串中的位置就是子串的第一个字符在主串中的序号

    对于串的比较其实是通过组成串的字符之间的编码来进行的,而字符的编码指的是字符在对应字符集中的序号

    只有在串中对应的每个字符都相等情况下,两个字符串才会相等

    如果是一个字符串会小于另外一个字符串,可能出现的情况如下所示

    给定两个串:s=”a1a2……an”,t=”b1b2……bm”,当满足以下条件之一时,s < t

    • 1.n < m,且ai=bi(i=1,2,……,n),其中n代表s字符串的长度,s代表t字符串的长度,前面字符串都相同,但是s字符串的长度比t字符串小也就说明s字符串小于t字符串
    • 2.存在某个k≤min(m,n)这是k>1的时候,使得ai=bi(i=1,2,……,k-1),ak < bk,如果两个字符串从第一个字符就开始不相等也就是说a1 != b1的话就直接只比较a1和b1的大小

    其实我们的英语词典就是按照字符串大小的顺序来进行排列的,所以我们查找单词的时候其实也就是在比较字符串的大小

    关于串的抽象数据结构如下所示

    ADT 串(string)
    Data
        串中元素仅由一个字符组成,相邻元素具有前驱和后继关系。
    Operation
        StrAssign(T, *chars):        生成一个其值等于字符串常量chars的串T
        StrCopy(T, S):               串S存在,由串S复制得串T
        ClearString(S):              串S存在,将串清空。
        StringEmpty(S):              若串S为空,返回true,否则返回false。
        StrLength(S):                返回串S的元素个数,即串的长度。
        StrCompare(S, T):            若S>T,返回值>0,若S=T,返回0,若S<T,返回值<0。
        Concat(T, S1, S2):           用T返回由S1和S2联接而成的新串。
        SubString(Sub, S, pos, len): 串S存在,1≤pos≤StrLength(S),
                                     且0≤len≤StrLength(S)-pos+1,用Sub返
                                     回串S的第pos个字符起长度为len的子串。
        Index(S, T, pos):            串S和T存在,T是非空串,1≤pos≤StrLength(S)。
                                     若主串S中存在和串T值相同的子串,则返回它在主串S中
                                     第pos个字符之后第一次出现的位置,否则返回0。
        Replace(S, T, V):            串S、T和V存在,T是非空串。用V替换主串S中出现的所有

    关于串的抽象数据类型的定义其实主要为的就是将我们生活中可能用到的一些算法给集合在一起体现程序设计当中问题的分解,在串当中抽象数据结构的定义更加关注的是怎么去查找子串的位置,怎么得到指定位置的子串、替换子串等,其实就是为了处理我们现实生活中可能遇到的问题所设计的

    串的存储结构分为两种,一种是顺序存储结构还有一种是链式存储结构,串的顺序存储结构是用一组地址连续的存储单元来存储串,我们会为串去分配一个固定长度的存储区,一般是用定长的数组来定义的

    我们在C语言当中定义一个字符数组的时候我们需要多加一个长度,因为编译器会自动的帮我们添加一个’\0’,这样方便去确定其的字符串的长度,下面字符数组当中只有两个字符但是我们定义的字符数组的长度为3

    char s[3] = {'a','c'};

    这里写图片描述

    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #include <math.h>
    #include <time.h>
    #include <stdio.h>
    
    
    #define OK 1
    #define ERROR 0
    #define TRUE 1
    #define FALSE 0
    
    #define MAXSIZE 40
    
    typedef int Status;
    typedef int ElemType;
    /*
     typedef char String[MAXSIZE + 1]; 定义了一种类型,类型的名字叫String,这种类型的结构是长度为MAXSIZE+1的char数组。
     所以,String s1,s2;就是定义了s1,s2是两个char数组,等同于以下定义:
     char s1[MAXSIZE+1];
     char s2[MAXSIZE+1];
     */
    //0号存储单元存放的是串的长度
    typedef char String[MAXSIZE+1];
    
    //生成一个其值为chars的字符串T
    Status StrAssign(String T,char *chars)
    {
        int i;
        if (strlen(chars)>MAXSIZE) {
            return ERROR;
        }else
        {
            T[0]=strlen(chars);
            for (i=1;i<=T[0];i++) {
                T[i]=*(chars+i-1);
            }
              return OK;
        }
    }
    //通过S串复制得到T串
    Status StrCopy(String T,String S)
    {
        int i;
        for (i=0;i<=S[0];i++) {
            T[i]=S[i];
        }
        return OK;
    }
    /*若S为空串,则返回TRUE,否则返回FALSE*/
    Status StrEmpty(String S)
    {
        if(S[0]==0)
            return TRUE;
        else
            return FALSE;
    }
    //若串S和T都存在的话,若S>T的话返回值就大于0,若S=T,则返回值=0,若S<T,则返回值小于0
    int StrCompare(String S,String T)
    {
        int i;
        for (i=1;i<=S[0]&&i<=T[0];++i) {
            if (S[i]!=T[i]) {
                return S[i]-T[i];
            }
        }
        return S[0]-T[0];
    }
    //返回串的元素长度
    int StrLength(String S)
    {
        return S[0];
    }
    //串S存在,操作结果就是S清为空串
    Status ClearString(String S)
    {
        //将串的长度设置为零
        S[0]=0;
        return OK;
    }
    /* 用T返回S1和S2联接而成的新串。若未截断,则返回TRUE,否则FALSE */
    Status Concat(String T,String S1,String S2)
    {
        int i = 0;
        //如果两个串的长度加在一起小于MAXSIZE,直接拼接就好了
        if (S1[0]+S2[0]<=MAXSIZE) {
    
            for (i=1;i<=S1[0];i++) {
                T[i]=S1[i];
            }
            for (i=1;i<=S2[0];i++) {
                T[S1[0]+i]=S2[i];
            }
            T[0]=S1[0]+S2[0];
            return TRUE;
        }else
        {
            for (i=1;i<S1[0];i++) {
                T[i]=S1[i];
            }
            for (i=1;i<=MAXSIZE-S1[0];i++) {
                T[S1[0]+i]=S2[i];
            }
            T[0]=MAXSIZE;
            return FALSE;
        }
    }
    //用Sub返回串S的第pos个字符起长度为len的子串
    Status SubString(String Sub,String S,int pos,int len)
    {
        int i;
        //如果pos小于1或者大于串的长度或者len小于0,或者len比从pos个字符起的长度大
        if (pos<1 || pos>S[0] ||len<0 || len>S[0]-pos+1) {
            return ERROR;
        }
        for (i=1;i<=len;i++) {
            Sub[i]=S[pos+i-1];
        }
        Sub[0]=len;
        return OK;
    }
    //返回子串T在主串S中第pos个字符之后的位置。若不存在,则函数返回值为0
    int Index(String S,String T,int pos)
    {
        /* i用于主串S中当前位置下标值,若pos不为1,则从pos位置开始匹配 */
        int i = pos;
        /* j用于子串T中当前位置下标值 */
        int j = 1;
        while (i<=S[0]&&j<=T[0]) {
            //如果两个字母相等的话继续比较
            if (S[i]==T[j]) {
                ++i;
                ++j;
            }
            else  /* 指针后退重新开始匹配 */
            {
                i=i-j+2; /* i退回到上次匹配首位的下一位 */
                j=1;     /* j退回到子串T的首位 */
            }
        }
        //这就说明已经成功匹配完成
        if (j > T[0]) {
            return i-T[0];
        }
        else
        {
            return 0;
        }
    }
    //如果主串S中第pos个字符之后存在与T相等的子串,则返回第一个这样的子串在S中的位置,否则返回0 */
    int Index2(String S,String T,int pos)
    {
        int n,m,i;
    
        String sub;
    
        if (pos>0) {
            //获取S串的长度
            n=StrLength(S);
            m=StrLength(T);
            i=pos;
            while (i<=n-m+1) {
                //取S主串当中第i个位置长度为m的子串
                SubString(sub, S, i, m);
                //进行比较,如果两个串不相等
                if (StrCompare(sub,T)!=0) {
                    ++i;
                }
                else
                    return i;
            }
        }
        //表示没有子串和T相等,所以返回0
        return 0;
    }
    /*  初始条件: 串S和T存在,1pos≤StrLength(S)+1 */
    /*  操作结果: 在串S的第pos个字符之前插入串T。完全插入返回TRUE,部分插入指的是MAXSIZE是小于S[0]和T[0]的大小了,只插入T[0]的部分,返回FALSE */
    Status StrInsert(String S,int pos,String T)
    {
        int i;
        if (pos<1 || pos>S[0]+1) {
            return ERROR;
        }
        //如果两个字符串的长度加在一起是小于等于最大长度的话就是完全插入的
        if (S[0]+T[0]<=MAXSIZE) {
            //pos后面的给移动到i+T[0]这边
            for (i=S[0];i>=pos;i--) {
                S[i+T[0]]=S[i];
            }
            for (i=pos;i<pos+T[0];i++) {
                S[i]=T[i-pos+1];
            }
            S[0]=S[0]+T[0];
            return TRUE;
        }
        else
        {
            int len = MAXSIZE-S[0];
    
            for (i=MAXSIZE;i>=pos; i--) {
                S[i]=S[i-len];
            }
            for (i=pos; i<pos+len; i++) {
                S[i]=T[i-pos+1];
            }
            S[0]=MAXSIZE;
            return FALSE;
        }
    }
    //从串S中删除第pos个字符起长度为len的子串
    Status StrDelete(String S,int pos,int len)
    {
        int i;
        //这里的pos>S[0]-len+1,S[0]是30,len如果是10的话,那么pos可以是从21开始正好到30是为10个字符
        if (pos<1 || pos>S[0]-len+1 || len<0) {
            return ERROR;
        }
        for (i=pos+len; i<=S[0];i++) {
            S[i-len]=S[i];
        }
        S[0]-=len;
        return OK;
    }
    //用V替换主串S中出现的所有与T相等的不重叠的子串
    Status Replace(String S,String T,String V)
    {
        //从串S的第一个字符开始去查找串T
        int i=1;
        if (StrEmpty(T)) {
            return ERROR;
        }
        do {
    
            //如果Index函数的返回值为0的就说明没有早点
            i = Index(S, T, i); /*  结果i为从上一个i之后找到的子串T的位置 */
    
            if (i) /*  串S中存在串T */
            {
                //删除该串T
                StrDelete(S, i, StrLength(T));
                //在原串T的位置插入串V
                StrInsert(S, i,V);
                //在插入的串V后面继续查找串T
                i+=StrLength(V);
    
            }
    
        } while (i);
        return OK;
    }
    //输出字符串T
    void StrPrint(String T)
    {
        int i;
        for (i=1; i<=T[0]; i++) {
            printf("%c",T[i]);
        }
        printf("\n");
    }

    对于串的链式存储,一个结点可以存储一个字符,当然也可以存储多个字符,这会影响串的处理的效率,我们需要去根据实际情况去做出选择

    展开全文
  • 数据结构之(上)——基本概念与存储结构 1.什么是 (1)我们先来看一下基本的关系: 数据结构是指两个集合:a.有特定关系的元素的集合(元素集) b.这些元素之间的关系的集合(关系集) 元素之间的关系有...

    数据结构之串(上)——串的基本概念与存储结构

    1.什么是串

    (1)我们先来看一下基本的关系:

    数据结构是指两个集合:a.有特定关系的元素的集合(元素集)
                        b.这些元素之间的关系的集合(关系集)
    元素之间的关系有: a.线性关系
                      b.非线性关系
    在各种各样的数据结构中,如果其中的元素是线性关系,我们就称呼这个数据结构为线性表;
    如果线性表中的元素集是字符集(即元素类型均为字符型),我们就称这种线性表为串。
    

    (2)必须知道的关于串的基本概念:

    串的长度:串中所包含的字符个数称为该串的长度。
    空串:长度为零,即不包含任何字符
    子串:串中任意个连续字符组成的子序列称为该串的子串,嘿嘿,主串是什么就不用我解释了吧
    空格串(空白串):顾名思义,所有字符都是空格
    

    2.串的存储方式

    (1)字符数组法(顺序存储结构):

    a.将串定义为字符数组,利用串名可以直接访问串值 b.呜呜呜,数组要先分配好存储空间啊,存储空间就固定了啊 c.代码:#define m=100//用户能在100以内定义最大串长 typedef char Sstring[m+1];//0号单元存放串的长度,字符从1号单元存放 Sstring S;//S的类型为Sstring

    (2)字符序列法(堆分配存储结构):

    a.用一组地址连续的存储单元依次存储串中的序列
    b.程序运行时根据串的实际长度动态分配存储空间
    c.代码:typedef struct { char *ch;//ch是地址,ch[i]或*ch是元素,我们可以用s.ch[i]来访问字符串s中第i个元素 int length;//s的长度L等于s.length }Hstring;

    (3)链式存储

    代码:#define m=10//一个地址可存10个字符 typedef struct snode { char ch[m]; struct node*next;//地址 }snode;

    展开全文
  • 基本概念 是一种特殊的线性表,他的数据对象是字符集和,它的每个元素都是一个字符一系列相连的字符就组成了一个字符,简称 的描述:s = "a1a2a3..........an" (n >= 0);(n称为的长度) 的存储...
  • 概念及存储方式

    千次阅读 2020-04-06 16:20:09
    一、基本概念 1.定义 是由零个或多个字符组成的有限序列。一 般记为 s= “a1a2a3…an” 其中,s是的名, 用双引号括起来的字符序列是的值;an可以是字母、 数字或其他字符;中字符的数目n称为的长度。...
  • Hbase原理、基本概念、基本架构

    万次阅读 多人点赞 2013-12-26 16:36:37
    Hbase基本概念 RowKey:是Byte array,是表中每条记录的“主键”,方便快速查找,Rowkey的设计非常重要。 Column Family:列族,拥有一个名称(string),包含一个或者多个相关列 Column:属于某一个columnfamily...
  • 面向对象基本概念

    万次阅读 多人点赞 2019-02-06 21:56:15
    面向对象就是:把数据及对数据的操作方法放在一起,作为一个相互依存的整体...对象即为人对各种具体物体抽象后的一个概念,人们每天都要接触各种各样的对象,如手机就是一个对象。 面向对象编程(OOP:object-orie...
  • Java字符与字符集的基本概念

    万次阅读 2009-12-26 06:57:00
    本作品采用知识共享署名-非商业性使用-相同方式共享 2.5 中国大陆许可协议进行许可。... Java字符的内部编码String类内部管理着一个char类型的数组,Java API是这样描述char基本类型的:char 数据
  • 网站基本概念

    千次阅读 2020-09-11 22:18:06
    文章目录 网站基本概念 网站 服务器 IP 域名 DNS 端口 静态网站 动态网站
  • 基本概念和术语

    千次阅读 2019-12-17 18:00:02
    文章目录概要数据(data)数据元素(data element)数据项(data item)...本篇文章将讲解数据结构的基本概念和术语,这种概念性的东西往往是催人入睡的,当然了,没有谁能把概念讲出花来,概念就是枯燥的。 由于专栏的...
  • 【Kubernetes】浅析基本概念和原理

    万次阅读 2021-05-30 12:44:12
    摘要:本文从 Kubernetes (K8S) 的几个核心概念入手,对 K8S 的整体架构设计进行了概括性分析,进而对 K8S 的认证、授权、准入控制的相关内容进行了介绍。 1 核心概念和架构设计 1.1 概念与层级关系 Image 镜像的...
  • 第六天:串口通信概念、原理

    千次阅读 2016-07-23 21:39:19
    串口通信的基本概念   通信过程其实分为三个步骤: 发送方先按照信息编码方式编码, 通过传输介质传输 收到编码信息,根据事先的编码方式解码得到原信息     电子通信概念1:  同步通信 和 异步...
  • 编译原理学习基本概念汇总

    千次阅读 多人点赞 2015-07-22 14:04:10
    对于计算机专业的学生来说,肯定听说过或者上过一门课,叫做——编译原理,被称为计算机专业的天书,反正不管是学习这门课的时候,...现在我把大学时整理的编译原理最基本概念分享出来。 第一章-绪论 1. 翻译,是指
  • RabbitMQ01-基本概念和基本使用

    万次阅读 2020-10-06 20:19:54
    本文主要讲解 RabbitMQ的相关概念,以及一些基本操作,还有和JAVA整合的代码操作,SpringBoot和RabbitMQ的整合
  • 串口通信的基本知识

    万次阅读 多人点赞 2014-07-02 14:41:03
    [编辑简介]:本文介绍了串口通讯的基本概念、数据格式、通讯方式、典型的串口通讯标准等内容。 [关键词]:串口通讯,RS232,RS485,停止位,奇校验,偶校验 1 串口通讯 串口通讯(Serial Communication),是指外设和...
  • 在Foundation框架中,提供了NNString类,用于处理字符对象。在C语言中字符在一对引号中表示。 OC是C语言的一种延展,换句话说,OC语言是建立在C语言的基础之上(C的基础之上添加了面向对象的内容,smalltalk语言)。...
  • 蓝牙基本概念

    千次阅读 2014-12-22 14:23:28
    之前查看过蓝牙协议分析_基本概念对蓝牙有了一个整体的概念,最近闲暇无事稍稍看了下蓝牙协议规范,对蓝牙相关的概率有了一定的了解。接下来的文章都是对自己的学习内容的整理,由于自己的水平有限,错误也在所难免...
  • java基本概念

    千次阅读 2016-12-22 15:48:04
    此外,Java 又不同于诸如 C++ 语言提供的各种各样的方法,它只提供了基本的方法,这样就减少了编程的复杂性,例如去掉了头文件、指针变量、结构、运算符重载、多重继承等复杂特性。Java 语言虽然简单,却很高效,它...
  • Lucene基本概念

    千次阅读 2015-02-28 22:11:07
    Lucene基本概念: 1、 Index:索引库,文档的集合组成索引。和一般的数据库不一样,Lucene不支持定义主键,在Lucene中不存在一个叫做Index的类,通过IndexWriter来写索引,通过IndexReader来读索引。索引库在物理...
  • 视频压缩基本概念

    万次阅读 多人点赞 2018-08-21 09:28:09
    视频压缩基本概念 为什么需要压缩视频 首先回答why这个问题。 假设一个2小时未压缩的高清视频,1920×1080p的电影,我们来计算一下他的存储容量。先介绍一下帧率(frame rate或者是 FPS)概念,也就是每秒传输图片的...
  • MongoDB - 基本概念和数据类型

    千次阅读 2018-07-29 15:05:00
    一、MongoDB基本概念 1、数据库 1)、一个MongoDB中可以建立多个数据库(这点与关系型数据库一致),数据会存储在MongoDB配置中指定的data位置。并且基于MongoDB的shell(MongDB一大特性),会将数据库赋值给全局...
  • 命题逻辑基本概念

    千次阅读 2015-04-14 07:46:00
    由于简单命题是真值唯一确定的命题逻辑中最基本的研究单位,所以也称简单命题为命题常项或命题常元。从本节开始对命题进一步抽象,首先称真值可以变化的陈述句为命题变项或命题变元,也用p,q,r,…表示命题变项。当p,...
  • MySQL数据库基本概念介绍

    千次阅读 2020-01-03 10:11:11
    文章目录一、数据库的基本概念二、主流数据库介绍SQL Server(微软公司产品)Oracle(甲骨文公司产品)DB2(IBM公司产品)MySQL(甲骨文公司收购)三、数据库存储类型关系型数据库非关系型数据库(统称为NOSQL)四、...
  • PID调节的一些基本概念

    千次阅读 2015-04-21 10:05:54
    为了能够掌握并运用PID,我们非常有必要学习下基本概念来武装自己,部分概念后面我会配上实际工程中常用的表示方法,以“实:”开头。 1、被调量:反映被调对象的实际波动的量值。被调量是经常变化的。  实:常用...
  • 【数据结构】基本操作和实现

    千次阅读 多人点赞 2019-05-27 23:07:49
    文章目录的基本操作和实现基本概念串的基本操作项目实现源码项目实现结果 基本概念 (String)是由零个或多个字符组成的有限序列,又称字符。 长度:中字符的个数,称为的长度。 空串:长度为零的...
  • JavaScript基本概念之变量与数据类型

    千次阅读 2016-09-30 16:44:15
    名字空间的概念 局部作用域 常量 数据类型 基本数据类型 Undefined类型 Null类型 Number类型 Number类型的NaN 字符类型 引用类型 Object类型 Array类型 Date类型 RegExp类型 Function类型 基本包装类型变量变量...
  • 区块链的基本概念和工作原理

    万次阅读 多人点赞 2018-06-26 17:14:43
    区块链的基本概念和工作原理1、基本概念区块链是分布式数据存储、点对点传输、共识机制、加密算法等计算机技术的新型应用模式。所谓共识机制是区块链系统中实现不同节点之间建立信任、获取权益的数学算法。区块链...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 424,430
精华内容 169,772
关键字:

串的基本概念