文章目录
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
125. 验证回文串
给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。说明：本题中，我们将空字符串定义为有效的回文串。输入: "A man, a plan, a canal: Panama"输出: true解释：“amanaplanacanalpanama” 是回文串
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 统计回文
#include<iostream>
#include<string>
using namespace std; // 判断是否是回文
bool IsCircleText(const string& s)
{
size_t begin = 0;
size_t end = s.size()-1;
while(begin < end)
{
if(s[begin] != s[end])
return false;
++begin;
--end;
}return true;
}
int main() {
std::string str1, str2;
getline(cin, str1);
getline(cin, str2);
size_t count = 0;
for (size_t i = 0;i <= str1.size(); ++i)
{ // 将字符串2插入到字符串1的每个位置，再判断是否是回文
string str = str1;
str.insert(i, str2);
if(IsCircleText(str))
++count;
}
cout<<count<<endl;
return 0;
}
str1 ：aba；str2: b；str：baba abba abba abab
字符串逆序
方法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 <iostream>
#include <string>
#include <algorithm>
using namespace std;
int main()
{
string s; // 注意这里要使用getline，cin>>s遇到空格就接收结束了
getline(cin, s);
reverse(s.begin(), s.end()); // 翻转整个句子
auto start = s.begin();
while (start != s.end())
{
auto end = start;
while (end != s.end() && *end != ' ')
end++;
reverse(start, end); // 翻转单词，start end区间就是一个单词
if (end != s.end())
start = end + 1;
else
start = end;
}
cout << s << endl;
return 0;
}
用另一个字符串存储进行逆序输出，cin>>s接收输入，遇到空格就结束了，自然就分割开了每个单词，其次将每次接收到的单词拼接到之前串的前面就逆置过来了
方法3：
#include <iostream>
#include <string>
using namespace std;
int main()
{
string s1, s2;
cin >> s2;
while (cin >> s1)
s2 = s1 + " " + s2;
cout << s2 << endl;
return 0;
}
左旋字符串中的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);}
判断一个字符串是否为另外一个字符串旋转之后的字符串。
给定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;
}};
69385–字符串中找出连续最长的数字串
添加链接描述
cur去记录连续的数字串，如果遇到不是数字字符，则表示一个连续的数字串结束了，则将数字串跟之前的数字串比较，如果更长，则更新更长的数字串更新到res。
#include<iostream>
#include<string>
using namespace std;
int main() { string str,res,cur;
cin>>str;
for(int i=0;i<=str.length();i++)
{
// 数字+=到cur
if(str[i]>='0' && str[i]<='9')
{ //字符0和数字0不一样，i走到字符串的\0时，不会进入这里面
cur+=str[i];
}
else {
// 找出更长的字符串，则更新字符串
if(res.size() < cur.size())
res=cur;
else
cur.clear();
}
}
cout << res;
return 0;
}
删除公共字符
#include<iostream>
#include<string>
using namespace std;
int main()// oj中IO输入字符串最好使用getline
{ string str1,str2;
getline(cin, str1); getline(cin, str2); // 使用哈希映射思想先str2统计字符出现的次数
int hashtable[256] = {0};
for(size_t i = 0; i < str2.size(); ++i)
{
hashtable[str2[i]]++;
}//不要str1.erases(i) 边遍历，边erase，容易出错。
string ret;
for(size_t i = 0; i < str1.size(); ++i)
{
if (hashtable[str1[i]] == 0) ;ret += str1[i];
}cout << ret << endl; return 0;
}
387. 字符串中的第一个唯一字符
给定一个字符串，找到它的第一个不重复的字符（小写=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)
count[ch-'a']++;//统计次数
}
for (int i = 0; i < s.size(); ++i){
if (count[s[i] - 'a'] == 1)//找字符出现的次数,找第1次出现时
return i;
}
return -1;
}};
HJ1 字符串最后一个单词的长度
字符串最后一个单词的长度，单词以空格隔开，字符串长度小于5000。
（注：字符串末尾不以空格为结尾）输入：hello nowcoder输出：8
#include<iostream>
#include<string>
using namespace std;
int main()
{ string s;
//cin>>s;//不使用cin输入，cin把空格当成输入的分隔，如输入：ABS T,输出：3，把T消失
getline(cin,s);//得到1行，含空格则使用getline
size_t pos = s.rfind(' ');//找空格
if (pos == string::npos){
cout << s.size()<<endl;//没有找到空格
}
else{
cout << s.size() - pos - 1 << endl;//-1是减去空格长度
} }
415. 字符串相加
给定两个字符串形式的非负整数 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) ;
}}
