STL综合

最新推荐文章于 2022-11-20 20:25:24 发布

不为谁而写的代码

最新推荐文章于 2022-11-20 20:25:24 发布

阅读量177

点赞数

分类专栏：杂记文章标签： c++ 链表字符串

本文链接：https://blog.csdn.net/weixin_45881513/article/details/104612308

版权

杂记专栏收录该内容

4 篇文章 0 订阅

订阅专栏

最大公约数

（输入时默认a<b）

int gcd(int a, int b)
{
    return b ? gcd(b, a % b) : a;
}

getchar()可以读入回车有时需要吸收
scanf("%s")不能读入空格这时可用gets() 或者getline(cin,s); 此时s的类型是string而不是char型
s.replace 不会用的时候可以逐一替换字符串中的字符可以设置一个用不到的字符输出时if一下是该符号则不输出
len=(int )s.size(）//计算s长度
s.push_back();//向s的尾端插入元素
循环数组的实现：把最后一个数取出赋值给t；s[i]=s[i-1];s[0]=t;若循环k次则while(k–){ }在循环内每次移动一个位置
万能头文件：#include<bits/stdc++.h>
考场上不写isPrime函数的话可以用素数数组

prime[20]={0,1,1,1,0,1,0,1,0,0,0,1,0,1,0,0,0,1,0,1}

当prime[i]==1;时，说明i为素数（此处i代表1开始到19的自然数）
10. 全排列：


#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
int main(){
       int n,m;
       while(cin>>n>>m){
              int a[2000];
              for(int i=0;i<n;i++){
                     a[i]=i+1;
              }
              int p;
              p=0;
              do{
                p++;
                if(p==m){
                     for(int i=0;i<n-1;i++){
                           cout<<a[i]<<" "；
                   }
                     cout<<a[n-1]<<endl;
                     break;
              }
              }while(next_permutation(a,a+n));
       }
       return 0;
}

在这里插入图片描述

 for(int i=1;i<=10;i++){
  maxnum=max(maxnum,num[i].sum);
  minnum=min(minnum,num[i].sum);
 }//循环找到最大最小值

在这里插入图片描述
9. 输入字符串中有空格的话就用getline();读入
10. stack记得加头文件#include<stack> 初始化：stack<char >st;



/*
3
olleh !dlrow
m'I morf .udh
I ekil .mca
*/

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <stack>
#include <string>
using namespace std;

int main(){
       string s;
       int t;
       cin>>t;
       getchar();
       while(t--){
              stack<char>st;
              getline(cin,s);
              int len;
              len=(int)s.size();
              for(int i=0;i<len;i++){
                     if(s[i]!=' '){
                            st.push(s[i]);
                     }
                     if(s[i]==' '||i==len-1){
                            while(!st.empty()){
                                printf("%c",st.top());
                                st.pop();
                            }
                            if(s[i]==' '){
                                   cout<<" ";
                            }
                     }
              }
              cout<<endl;
       }
       return 0;
}

链表排序

for(i=h->next;i->next;i=i->next){ //在链表上直接排序 
	k=i;
	for(j=i->next;j;j=j->next){
		if(k->num<j->num){
			k=j;
  		}
  	}
	if(k!=i){
		swap(i->num,k->num);
	}
}

Vector

Vector综合

end操作返回的迭代器vector的“末端元素”的下一个。超出末端迭代器。表明它指向了一个不存在的元素。如果vector为空，begin返回的迭代器与end返回的迭代器相同
由end操作返回的迭代器并不指向vector中任何实际的元素。相反，他只是起一个哨兵的作用，表示我们已经处理完vector中所有元素。
解引用操作符返回迭代器当前所指向的元素。假设 iter 指向 vector 对象 ivec 的第一元素，那么 *iter 和 ivec[0] 就是指向同一个元素。`*iter=0;效果就是把这个元素的值赋为 0。
如果 iter 指向第一个元素，则 ++iter 指向第二个元素。由于 end 操作返回的迭代器不指向任何元素，因此不能对它进行解引用或自增操作。
假设已声明了一个 vector 型的 ivec 变量，要把它所有元素值重置为 0，可以用下标操作来完成

Memset

Memset 用来对一段内存空间全部设置为某个字符，一般用在对定义的字符串进行初始化为‘ ’或‘/0’；
例:char a[100];memset(a, '/0', sizeof(a));
memset可以方便的清空一个结构类型的变量或数组。如：

struct sample_struct
{
	char csName[16];
	int iSeq;
	int iType;
};

对于变量：struct sample_strcut stTest; 一般情况下，清空stTest的方法

stTest.csName[0]='/0';

stTest.iSeq=0;

stTest.iType=0;

用memset就非常方便：

memset(&stTest,0,sizeof(struct sample_struct));

如果是数组：struct sample_struct TEST[10];则：

memset(TEST,0,sizeof(struct sample_struct)*10);

for (vector<int>::size_type ix = 0; ix != ivec.size(); ++ix) {
       ivec[ix] = 0; 
}

更典型的做法是用迭代器来编写循环：

for(vector<int >::iterator iter=ivec.begin();iter !=ivec.end();++iter){
	*iter=0;
}

如果text是vector<string>类型，想要遍历他，输出每个元素，可以这样编写程序：

for(vector<string >::const_iterator iter=text.begin();iter!=text.end();++iter){
	cout<<*iter<<endl;
}

由于这里只需要借助迭代器进行读，不需要写，这里把iter定义为const_iterator类型。

模板：`template < typename T>`

1.因为T是一个模版实例化时才知道的类型，所以编译器更对T不知所云，为了通知编译器T是一个合法的类型，使用typename语句可以避免编译器报错。
2.template < typename var_name > class class_name; 表示var_name是一个类型，在模版实例化时可以替换任意类型，不仅包括内置类型（int等），也包括自定义类型class。换句话说，在template和template中，
typename和class的意义完全一样。

malloc和new对比：

malloc函数
如下是分配长度为100个字节的内存块，返回值为void* ，表示未确定类型的指针。因此往往需要加上强制转换，如下所示，malloc和free一起使用。

char *p;

p=(char *)malloc(100); //分配成功则返回分配后内存空间的首地址，不成功则返回空指针null

malloc函数实现原理：

1）malloc 函数的实质是它有一个将可用的内存块连接为一个长长的列表的所谓空闲链表。

2）调用 malloc（n）函数时，它沿着连接表寻找一个大到足以满足用户请求所需要的内存块。然后，将该内存块一分为二（一块的大小与用户申请的大小相等，另一块的大小就是剩下来的字节）。接下来，将分配给用户的那块内存存储区域传给用户，并将剩下的那块（如果有的话）返回到连接表上。

3）调用 free 函数时，它将用户释放的内存块连接到空闲链表上。

4）到最后，空闲链会被切成很多的小内存片段，如果这时用户申请一个大的内存片段，那么空闲链表上可能没有可以满足用户要求的片段了。于是，malloc（）函数请求延时，并开始在空闲链表上检查各内存片段，对它们进行内存整理，将相邻的小空闲块合并成较大的内存块。

new函数

和上述一样也是动态分配堆内存，new和/delete一起使用：

  //开辟单地址空间   
  int *p = new int; //开辟大小为sizeof(int)空间    
  int *q = new int(5); //开辟大小为sizeof(int)的空间，并初始化为5。    
  //开辟数组空间       
  int *a = new int[100]{0};	//开辟大小为100的整型数组空间，并初始化为0。   
  int (*a)[6] = new int[5][6];       //二维    
  int (*a)[5][6] = new int[3][5][6]	//三维

delete函数

    //释放单个int空间    
    int *a = new int;    
    delete a;    
    //释放int数组空间    
    int *b = new int[5];

new和malloc区别

new和malloc的区别是C/C++一道经典的面试题，我也遇到过几次，回答的都不是很好，今天特意整理了一下。

属性
new/delete是C++关键字，需要编译器支持。malloc/free是库函数，需要头文件支持。
参数
使用new操作符申请内存分配时无须指定内存块的大小，编译器会根据类型信息自行计算。而malloc则需要显式地指出所需内存的尺寸。
返回类型
new操作符内存分配成功时，返回的是对象类型的指针，类型严格与对象匹配，无须进行类型转换，故new是符合类型安全性的操作符。而malloc内存分配成功则是返回void * ，需要通过强制类型转换将void*指针转换成我们需要的类型。
分配失败
new内存分配失败时，会抛出bac_alloc异常。malloc分配内存失败时返回NULL。
自定义类型
new会先调用operator new函数，申请足够的内存（通常底层使用malloc实现）。然后调用类型的构造函数，初始化成员变量，最后返回自定义类型指针。delete先调用析构函数，然后调用operator delete函数释放内存（通常底层使用free实现）。
malloc/free是库函数，只能动态的申请和释放内存，无法强制要求其做自定义类型对象构造和析构工作。
重载
C++允许重载new/delete操作符，特别的，布局new的就不需要为对象分配内存，而是指定了一个地址作为内存起始区域，new在这段内存上为对象调用构造函数完成初始化工作，并返回此地址。而malloc不允许重载。
内存区域
new操作符从自由存储区（free store）上为对象动态分配内存空间，而malloc函数从堆上动态分配内存。自由存储区是C++基于new操作符的一个抽象概念，凡是通过new操作符进行内存申请，该内存即为自由存储区。而堆是操作系统中的术语，是操作系统所维护的一块特殊内存，用于程序的内存动态分配，C语言使用malloc从堆上分配内存，使用free释放已分配的对应内存。自由存储区不等于堆，如上所述，布局new就可以不位于堆中。
————————————————
版权声明：本文为CSDN博主「Datou_Nie」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/nie19940803/article/details/76358673

冒泡代码

for(i=0;i<n-1;i++){
  for(int j=n-1;j>i;j--){
   if(student[j].sum>student[j-1].sum){
    swap(student[j],student[j-1]);
   }
  }
 }

cin.getline();gets();getline()

cin.getline:
此函数一次读取多个字符(包括空白字符），直到读满N-1个，或者遇到指定的结束符为止(默认的是以’\n’结束)。其语法为:cin.getline(字符指针(char*),字符个数N(int),结束符(char));

#include<iostream>
using namespace std;
 
int main(){
	char a[10];
	cin.getline(a,10);
	for(int i=0;i<10;i++)
		cout<<a[i]<<" ";
	return 0;
}

输入:1234567890123
输出:1 2 3 4 5 6 7 8 9 _ （第10位存放字符串结束符’\0’）
注意：cin.getline()函数缺省的第三个参数为’\n’，如果把cin.getline(a,10)改为cin.getline(a,10,’#’)

#include<iostream>
using namespace std;
int main(){
	char a[10];
	cin.getline(a,10,'#');
	cout<<a<<endl;
	return 0;
}
输入：

1234#567890
输出：1234

getline:
注意：与cin.getline功能类似，但是参数不一样，也属于两个不同的流，是两个不一样的函数。getline接受的字符串长度不受限制

#include<string>//getline包含在string头文件里
#include<iostream>
using namespace std;
int main()
{
    string str;
    getline(cin,str,'#');
    char c=getchar();
    cout<<str<<' '<<c<<endl;
    return 0;
}

输入为：aa#b
输出为：aa b

gets:
C中的函数。可以无限读取，不会判断上限，以回车结束读取，所以程序员应该确保buffer的空间足够大，以便在执行读操作时不发生溢出
与getline函数功能相似，但是不能自定义结束符，只能换行符结束
#include “stdio.h” //这个头文件包含gets()函数

int main(void)
{
    char str1[5];
    gets(str1);
    printf("%s\n", str1);
    return 0;
}

输入：ab c
输出：ab c
————————————————
版权声明：本文为CSDN博主「砳燚」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/ysf13579/article/details/23447945