字符串--
文章目录
- 替换空格
- 回文数索引
- 125. 验证回文串
- WY18 统计回文
- 151.翻转单词序列
- 字符串逆序
-
- 左旋字符串中的k个字符:
- 判断一个字符串是否为另外一个字符串旋转之后的字符串。
- 917. 仅仅反转字母
- 344
- 541
- HJ71 字符串通配符
- 查找两个字符串a,b中的最长公共子串
- HJ75 公共子串计算
- 69385--字符串中找出连续最长的数字串
- 删除公共字符
- 387. 字符串中的第一个唯一字符
- HJ1 字符串最后一个单词的长度
- 415. 字符串相加
- 23292-字符串转成整数
- 扑克牌大小
char a[]=”abc";char b[]={‘a','b','c'};
char *c=”abc”;char *d=”abc”;
d与c指向同一个地址,c的内容修改后，指向发生改变，d的内容不更改
getchar----输入缓冲区------键盘，:
字符:#abc,字母A-Z
有符号、无符号只限于整形，
scanf函数返回成功读入的数据项数，读入数据时遇到了“文件结束”则返回EOF：
while (EOF != scanf("%d %d", &a, &b))
{
printf("%d %d\n", a, b);
}
int a=0,b=0;
printf("%d %d\n", scanf("%d %d", &a, &b));
函数返回值为int型。如果a和b都被成功读入，那么scanf的返回值就是2；
如果只有a被成功读入，返回值为1；如果a和b都未被成功读入，返回值为0；
如果遇到错误或遇到end of file，返回值为EOF=-1。end of file为Ctrl+z 或者Ctrl+d。
字符0=‘0’是48；’\0’:数值上就是0，在类型上，字符；空格的ASCII码值=32；
对于字符串数组或字符串指针变量，由于数组名可以转换为数组和指针变量名本身就是地址，因此使用scanf()函数时，不需要在它们前面加上"&“操作符。
scanf中要求给出变量地址，如给出变量名则会出错,如
scanf(”%d",a);是非法的，应改为scanf(“%d”,&a);才是合法的
C编译在碰到空格，TAB，回车或非法数据(如对“%d”输入“12A”时，A即为非法数据)时即认为该数据结束。
判断是否为字母
int ch =0;
//输入
while ( (ch=getchar () !=EOE)//多组输入
{
if((ch>='a' && ch<='z”)||(ch>='A'&& ch<='8'))
printf ("YES\n");
else
printf ("NO\n");
getchar ();//消耗掉\n}
return 0;
getchar()输入的一串字符，可以将其单个分开存储；getline：一行信息。
int main(){
printf ( " code addr: %p\n" , main);
char *str = "hello bit! ";
printf( " read only addr: %pln" , str);//字符常量区的地址，hello bit!在字符常量区
printf( " read only addr: %pln" , &str);//str的地址,str在栈
}
char a[1000] = {0};
int i=0;
for(i=0; i<1000; i++)
{
a[i] = -1-i;
}
printf("%d",strlen(a));
a是字符型数组，考虑到a[i]其实是字符型，如果要为0，则需要-1-i的低八位要是全0，也就是问题简化成了“寻找当-1-i的结果第一次出现低八位全部为0的情况时，i的值”（因为字符数组下标为i时第一次出现了尾零，则字符串长度就是i）。只看低八位的话，此时-1相当于255，所以i==255的时候，-1-i（255-255）的低八位全部都是0，也就是当i为255的时候，a[i]第一次为0，所以a[i]的长度就是255
char msg[64] = "hello bit ! \n" ;
memcpy(msg+1，msg,strlen(msg)-1) ;
//结果=hhello bit!
char msg[64] = "hello bit! \n" ;char buffer[64];
mymemcpy (msg+1，msg,strlen (msg));//msg拷给msg+1
printf("%s \n", msg) ;//结果=hhhhhhhhhhhh，内存区间重叠的问题，从高地址到低地址方向拷贝才不会发生错误，dst地址 >src地址 && dst < src + len
char arr[]={'a','b'};
strlen (arr):随机值，但至少是2
strlen：获取字符串的有效长度的，结尾标记"0’不包含在内，从前往后依次检测,直到遇到\0是就终止检测。函数，
sizeof会将空字符\0计算在内。操作符（关键字）,
char dog[=“wang\0miao”;那么sizeof(dog)与strien(dog)分别是10,4
替换空格
添加链接描述
解
回文数索引
添加链接描述
从两侧进行统计，如果不同，则删除任意一个，在判定是否是回文，如果是，下标就是删除数据的下标，如果不是，就 是另一个元素的下标
#include acbba,第2次检测时，c不等于b，删除b，检测是否是回文，否，则要删除的一定是c
125. 验证回文串
class Solution {
public:
bool isLetter(char ch) {
if((ch>='0'&&ch<='9')
||(ch>='A'&&ch<='Z')||(ch>='a'&&ch<='z'))
{return true;}return false;}
bool isPalindrome(string s) {
for (auto& e : s)//s里每个元素赋值给e,使用引用，这样s改变元素，则e也会改变
{
if (e >= 'A'&& e <= 'Z')
e += 32;//全转为小写字母
}
int left = 0, right = s.size() - 1;
while (left < right)
{
while (left < right && !isLetter(s[left])){
++left;
}
while (left < right && !isLetter(s[right]))
{--right;}
if (s[left] != s[right])
return false;//不是回文
++left;
--right;
}
return true;
}};
WY18 统计回文
添加链接描述
#includestr1 ：aba；str2: b；str：baba abba abba abab
151.翻转单词序列
添加链接描述
题
void Reverse(string &str, int start, int end)
{ while (start < end)
{ char temp = str[start]; str[start] = str[end]; str[end] = temp; start++; end--;
} }
string ReverseSentence(string str) {
//先局部逆置，再整体逆置
if(str.size() == 0)
{ return str; }
int i = 0; int j = i;
int len = str.size();
while(i < len)
{
while( i < len && !isspace(str[i]))
i++; //让i一直往后走，碰到第一个空格
Reverse(str, j, i-1); //逆置当前有效子串，闭区间
while( i < len && isspace(str[i]))
i++; //越过所有空格，指向下一个有效子串的开始
j = i;
//保存起始位置
}//走到这里，一定是 i == str.size()了，但是最后一个有效子串并没有被逆置,逆置之。i：最后一个元素的下一个位置，已经越界，j:最后1个单词的起始位置
Reverse(str, j, i-1);i-1：最后1个单词的下标：len-1
Reverse(str, 0, i-1); //最后在整体逆置
return str;
}
字符串逆序
方法1：
static void Swap (char *p,char *q)
{assert (p) ;
assert(q) ;
*p=*p^*q;
*q=*p^*q;*p=*p^*q;//形参指向实参
}
void ReverseString(char *s){
assert(s);
char *start =s,
char *end = s + strlen(s) - 1;//-1的原因：如果不-1，则交换后把放在最前面，什么都打印不出来
while (start<end){
Swap(start,end) ;start++;
end--;}}
int main(){
//char *str ="abcd1234";字符常量区保存:"abcd1234，不可以修改
char str[] ="abcd1234";//数组 栈
printf ("before: %s \n", str);
ReverseString(str) ;
printf("after : %s \n", str) ;}
方法2：
#include 
用另一个字符串存储进行逆序输出，cin>>s接收输入，遇到空格就结束了，自然就分割开了每个单词，其次将每次接收到的单词拼接到之前串的前面就逆置过来了
方法3：
#include 左旋字符串中的k个字符:
添加链接描述
void ReverseString(char *start,char *end){
assert(start) ;
assert(end) ;
while (start < end)
{char temp = *start;*start =*end;
*end = temp;start++，end--;}}
void LeftMove(char str[]，int len,int num)
{assert(str) ;
num %= len;
// abcd1234 换4个 abcd 1234
// dcba 4321 1234abcd，局部逆置，再整体逆置
ReverseString(str，str + num - 1) ;
ReverseString(str +num,str + len - 1) ;//-1即减去\0
ReverseString(str，str + len - 1) ;}
int main(){
char str[] = "abcd1234";int num = 3;
LeftMove(str,strlen(str)， num) ;
printf("after: %s \n", str) ;//d1234abc
system("pause") ;
return 0;}
//方法2，构建双倍串
void LeftMove(char str[]，int len,int num)
{assert(str) ;
num %= len;
char *p = malloc(sizeof(char)*len*2+1);
if (NULL== p){
return;}
strcpy(p,str); //"abcd1234"
strcat(p,str) ; //"abcd1234""abcd1234"
strncpy (str，p+num，len) ;
free(p);}
添加链接描述
void ReverseString(string &str, int start, int end)
{ while(start < end)
{ char temp = str[start]; str[start] = str[end]; str[end] = temp; start++, end--; }
}
string LeftRotateString(string str, int n)
{ if(n == 0 || str.empty())
{ return str; }
n %= str.size(); //去除重复移动
ReverseString(str, 0, n-1); //前半部分逆置
ReverseString(str, n, str.size()-1); //后半部分逆置
ReverseString(str, 0, str.size()-1); //整体逆置
return str; }
判断一个字符串是否为另外一个字符串旋转之后的字符串。
给定s1 =AABCD和s2 = BCDAA，返回1,给定s1=abcd和s2=ACBD，返回0
int CheckString(char *s1,char *s2){
assert(s1);
assert(s2) ;
int len1 = strlen(s1) ;int len2 = strlen(s2);
if (len1 == len2){
while (len1){
if (strcmp(s1，s2) == 0){
return 1;}
LeftMove(s2，len2,1);len1--;
}
}return 0;
}
int main(){
char str1[] = "abcd1234";
char str2[] = "1234abcd";
int result = CheckString(str1, str2) ;
printf("result %d\n", result) ; }
char p1[15]="abcd" ,*p2= “ABCD",
str[50]= “xyz"";
strcpy(str+2,strcat(p1+2,p2+1));
printf(""%s" ,str);//xycdBCD
917. 仅仅反转字母
给定一个字符串 S，返回 “反转后的” 字符串，其中不是字母的字符都保留在原地，而所有字母的位置发生反转。输入："ab-cd!"输出：“dc-ba!”
class Solution {
public:
bool isLetter(char ch){
if (ch >= 'a' && ch <= 'z')
return true;
if (ch >= 'A'&& ch <= 'Z')
return true;
return false;
}
string reverseOnlyLetters(string S){
if (S.empty())
return S;//如果是空，S.size() - 1为-1，即最大值，越界
size_t begin = 0, end = S.size() - 1;
while (begin < end)
{
while (begin < end && !isLetter(S[begin]))
++begin;//不是字符则不交换，遇到字符才交换
while (begin < end && !isLetter(S[end]))
--end;
swap(S[begin], S[end]);
++begin;//交换之后继续往后检查迭代，继续往后走1步
--end;
}
return S;
}};
344
添加链接描述
541
添加链接描述
HJ71 字符串通配符
递归的终止条件：通配符或者字符串遇到’\0’。当他们同时结束
#include 查找两个字符串a,b中的最长公共子串
子串:cdefg
子序列:adgk
字符串：abcdefghijk
#include
HJ75 公共子串计算
#include69385–字符串中找出连续最长的数字串
添加链接描述
cur去记录连续的数字串，如果遇到不是数字字符，则表示一个连续的数字串结束了，则将数字串跟之前的数字串比较，如果更长，则更新更长的数字串更新到res。
#include删除公共字符
删除公共字符
#include387. 字符串中的第一个唯一字符
给定一个字符串，找到它的第一个不重复的字符（小写=26个），要求时间复杂度优化到0(N)，并返回它的索引。如果不存在，则返回 -1。s = "leetcode"返回 0
//计数排序思想;a（ASCII码是97）映射位置0:相对位置；
//0(N)=0(2N)=0(N)【计算字符出现的次数，计数，要遍历1次】+0(1)【找第1次出现时的下标，映射关系，拿每个字符找其次数】
class Solution {
public:
int firstUniqChar(string s) {
int count[26] = { 0 };
for (auto ch : s){//等价于for (char e : s)//O(N)
count[ch-'a']++;//统计次数
}初始化为0,以哈希方式相对映射
for (int i = 0; i < s.size(); ++i){//O(N)
if (count[s[i] - 'a'] == 1)
//找字符出现的次数,找第1次出现时，//O(1)//[]的不一样意义：最内层[]:函数调用，外层[]:数组解引用
return i;
}
return -1;
}};
#includeHJ1 字符串最后一个单词的长度
字符串最后一个单词的长度，单词以空格隔开，字符串长度小于5000。
（注：字符串末尾不以空格为结尾）输入：hello nowcoder输出：8
#include415. 字符串相加
给定两个字符串形式的非负整数 num1 和num2 ，计算它们的和并同样以字符串形式返回。你不能使用任何內建的用于处理大整数的库（比如 BigInteger）， 也不能直接将输入的字符串转换为整数形式。输入：num1 = “11”, num2 = "123"输出：“134”
class Solution {
public:
string addStrings(string num1, string num2) {
string ret;
int end1 = num1.size() - 1,
end2 = num2.size() - 1;
char next = 0;//进位
while (end1 >= 0 || end2 >= 0)//2个数字都结束，才结束
{
char x1 = 0,x2 = 0;
if (end1 >= 0)
{
x1 = num1[end1] - '0'; --end1;
}
if (end2 >= 0)
{
x2 = num2[end2] - '0'; --end2;
}char retch = x1 + x2 + next;
if (retch >= 10)
{
retch -= 10; next = 1;
}
else{
next = 0;
}
ret += (retch + '0');
}
if (next == 1)
ret += '1';
reverse(ret.begin(), ret.end());//如果使用头插，需要挪动数字，O（N*N）；尾插O（N）+逆置O（N）=O（2N）
return ret;
}};
23292-字符串转成整数
添加链接描述
class Solution 方法1：
{
public: int StrToInt(string str) {
if (str.empty()) return 0;
int symbol = 1;
if (str[0] == '-') //处理负号
{
symbol = -1; str[0] = '0'; //这里是字符'0',不是0
}
else if(str[0] == '+') //处理正号
{
symbol = 1; str[0] = '0';
}
int sum = 0;
for(int i=0;i<str.size();++i) {
if(str[i] < '0' || str[i] > '9')
{
sum = 0; break;
}
sum = sum *10 + str[i] - '0';
}
return symbol * sum;
}
};
方法2：
int my_atoi(const char *str)//字符串转整数
{
assert(str);
const char *p = str;
int flag = 1;
//去掉前缀其他非法字符
while (*p && !isdigit(*p))
{
if (*p == '-'){ break; }
p++;
}
if (*p == '-'){
flag = -flag; p++;
}
if (!isdigit(*p)){
errno = 1;//非法字符串
return 0;
}
long long res = 0; //8字节，只使用4字节
while (isdigit(*p) && *p){
res = res * 10 + flag*(*p - '0’) ;
if (res > INT_MAX || res < INT_MIN){
errno = 2;
return res;
}
p++;
}
return (int)res;
}
int main()
{const char *str = "abc-$ : -12349999" ;
int x = my_atoi(str) ;
if (errno == 0){
printf("%d\n", x);}
else{
printf("error: %d ! \n", errno) ;
}}
扑克牌大小
1 有王joker JOKER，直接赢
2 分开2者牌，同类型牌
3 2者类型不同，判断是否有炸弹
4 错误ERROR
#include