零散知识点

Posted 2021-01-08 zyx20171346065

结构体数组

bool cmp(const Arr &a, const Arr &b)  

 { return a.a < b.a;}

Sort（a,a+n,cmp);

;%Java_Home%libdt.jar

结构数组指针依次输出

for(p=stu;p<stu+3;p++)

cout << p->num << " " << p->name << " " << p->sex << " " << p->score<<endl;

 

动态内存分配

#include<malloc.h>

char *a,*b;

a = (char *)malloc(10 * sizeof(char));

free(a);

 

静态链表

struct student s1 = { "alan" };

struct student s2 = { "ben" };

struct student s3 = { "cici"};

struct student s4 = { "david" };

s1.next = &s2;

s2.next = &s3;

s3.next = &s4;

struct student *p;

p = &s1;

while (1) {

if (p->next != NULL) {

cout << p->name<<endl;

p = p->next;

}

else { cout << p->name<<endl; break; }

 

动态链表

#include<iostream>

#include<string.h>

#include<malloc.h>

using namespace std;

struct student {

char name[10];

struct student *next;

};

struct student * create()

{

struct student *head,*current,*next;

char str[10];

char flag;

cout << "please input name" << endl;

cin >> str;

 

getchar();

head = (struct student *)malloc(sizeof(struct student));

strcpy_s( head->name, str);

 

current = head;

 

cout << "是否继续输入：" << endl;

cin >> flag;

while (flag != ‘n‘) {

cout << "please input name" << endl;

cin >> str;

getchar();

next = (struct student *)malloc(sizeof(struct student));

strcpy_s(next->name, str);

//上一个元素的指针指向下一个元素

current->next = next;

//当前指针指向下一个元素

current = next;

cout << "是否继续输入：" << endl;

cin >> flag;

}

 

 

return head;

 

}

int main()

{

struct student *p;

p = create();

while (1) {

if (p->next != NULL) {

cout << p->name << endl;

p = p->next;

}

else { cout << p->name << endl; break; }

}

system("pause");

}

p=p->next;让p指向p的下一个地址

 

p = head->next 时，p是指向head->next的，可以说与head的链表是没有“干扰作用”的；而当head->next = p时就不同了，这就改变了原来链表指向的方向了。所以，一般来说，p = head->next 用于显示链表，而head->next = p；多用于插入节点。

 

q->next=p;p->next=null;q=p;
这个里面的q指向的永远是是要在当前节点添加下一个节点的哪个节点
假设 q现在指的是1节点,执行q->next=p,就是在1节点后面添加了个节点2
p->next=null,就是把2节点的next域设置为null;
q=p 就是把2节点地址给q,现在q就是指的是2节点了;如果把它这3个语句放在个循环里面就能构造个单链表了

 

q->next = p;的意思是将p存放入q所指向的结点的指针域
q = p;q就指向了p所指的

 

 

Vector<int>n

Bool empty()const; 如果空向量，返回true  v1.empty()

Vector &operator=（const vector&v);赋值

vector.pop_back(); 从vector尾部移除一个元素v

vector.clear(); 清空vector中的元素

Vector.size() 获取vector中元素个数

Vector.capacity（） 获取vector中容量大小

访问所有元素

法一：for(vector::iterator it=vector.begin();it!=vector.end();it++)

cout<<*it<<endl;

法二：for(int i=0;i<V.size();i++)cout<<v[i]<<” “;

Vector<int>v(n,val) v中有n个val

Void push_back(const T&val)尾部添加一个元素，若容量小，则容量扩大一倍

V.push_back(c+i); str.push_back(c+i);

Void pop_back(_) 删除最后一个元素，当前长度减一

T&front（） 返回向量第一个元素的引用

T&back（） 返回最后一个元素

Unsigne size()const 返回当前元素个数

Unsigned capacity（）const返回最多可容纳元素个数

Void reserve（int n）改变容量为n

Void <int>::iterator vecIter=v.begin();

vector <int>::iterator it1=v.begin();

Vector <char>::iterator iter=str.begin();

 

Vector的减法中有常数时，减法其实少减一

vector<char> V;

int c = 97;

for (int i = 0; i < 4; i++){

V.push_back(c + i);cout<<V[i]<<" ";}cout<<endl;

vector<char>::iterator it1 = V.begin(), it2 = V.end();

cout << *it1 << " " << *(it2-1) << endl; //需要输出时减法需要减一

it1 += 3;

it2 -= 2; //减一个已知数，其实少减一位

cout << *it1 << " " << *(it2-1) << endl;

it1--;

it2++;

if (it1 == it2)cout << *it1 << endl;

else cout << *it1 << " " << *it2 << endl;

cout << it1[1] << " "<<it1[-1] << endl;

system("pause");

 

Iterator insert(iterator pos,const T&x)在pos指定的元素 前x

V.insert(iter+2,’x’)  v.insert(iter2++,*iter1);

Void insert（iterator pos，int n,const T&x)在pos指定元素前插入n个x

V.insert(iter+2,3,’z’) 在iter+2的位置插三个z

在pos指定元素前插入由first和last确定的序列

Template<typename InIter>

void insert(iterator pos,InIter first,InIter last)

Iterator erase(iterator pos)删除pos指定元素

Iterator erase（iterator first，iterator last）删除first到last-1的所

有元素v1.erase(iter1);

 

构造二维向量

Vector<vector<int> >vv(3,vector<int>(4));

阶梯型

Vector<vector<int> >vv;

For(int c=1;c<=3;c++)vv.push_back(vector<int>(c,0));

 

vector<vector<int> > vector_2D_1;

vector<vector<int> > vector_2D_2(n);//仅指定第一维大小

vector<vector<int> > vector_2D_3(n,vector<int>(m));//指定维度为n*m

vector<vector<int> > vector_2D_4(n,vector<int>(m,x));//指定维度为n*m并初始化初值为x

vector<vector<int> > vector_2D_5(n,vector_1D_3);//使用已知向量来初始化，第二维大小和vector_1D_3一样

 

 

矩阵类Matrix

Martix(int r,int c,T* initval); 构造函数

Int Rowsize()const  行长

Int colsize()const  列长

T&operator=（const Matrix<T>&） 矩阵赋值

Matrix<T>operator +()const; 一元加

Matrix<T>operator +(const Matrix<T>& ) 二元加

Matrix<T>operator *(const Matrix<T>& ) 乘法

Matrix<T>transpose() 转置

 

 

字符串

Int strlen(const char* p)求p的长度

Char * strcpy(char *p,const char *q) 把q复制到p上

Char *strcat(char*p,const char *q)将q附加到p上

Int strcmp(const char *p,const char *q)比较p和q

Char * strstr(char *p,const char* q)从p中寻找第一个q

String s(char ARRAY,n)构造字符串s用ARRAY的前n个元素

输入输出操作符

S=val 赋值操作，val可以是一个串，一个字符数组

S+=val 将val添加到s之后

s.append(str) 用str给s赋值，返回s

s.assign(str,pos,n)将str中从pos位置开始后n个字符赋给s

s.compare(str) 根据s小于、等于、大于str返回一个负值，0，正值

s.compare(pos,n,str)s中从pos位置开始的n个字符组成的子串与str比较

s.insert(pos,str)在s位置插入str;

s.insert(pos1,str,pos2,n)将str中从pos2开始n个字符插到s中pos1处

s.insert(pos,chararray,n)将chararray的前n个字符插入s位置中pos处

s.replace（pos1，n1，str）用str替换pos1开始n1个字符串组成子串

s.replace（pos1，n1,str,pos2,n2)str从pos2开始的n2个字符代替s从pos1开始n1个字符

s.substr(pos,n)从pos开始n个字符串组成的子串

s.empty（）如果s空串返回true，else return false

s.find(str,pos)在s中从位置pos寻找串str若成功，返回str首次位置

s.rfind(str,pos)在s的前pos+str.size()个字符中查找，返回最后一次位置

 

 

KMP算法

void cal_next(char *str, int *next, int len)

{ //ababaca

next[0] = -1;//next[0]初始化为-1，-1表示不存在相同的最大前缀和最大后缀

int k = -1;//k初始化为-1

for (int q = 1; q <= len - 1; q++)

{

while (k > -1 && str[k + 1] != str[q])//如果下一个不同，那么k就变成next[k]，注意next[k]是小于k的，无论k取任何值。

{

k = next[k];//往前回溯

}

if (str[k + 1] == str[q])//如果相同，k++

{

k = k + 1;

}

next[q] = k;//这个是把算的k的值（就是相同的最大前缀和最大后缀长）赋给next[q]

}

}

int KMP(char *str, int slen, char *ptr, int plen)

{

int *next = new int[plen];

cal_next(ptr, next, plen);//计算next数组

int k = -1;

for (int i = 0; i < slen; i++)

{

while (k >-1 && ptr[k + 1] != str[i])//ptr和str不匹配，且k>-1（表示ptr和str有部分匹配）

k = next[k];//往前回溯

if (ptr[k + 1] == str[i])

k = k + 1;

if (k == plen - 1)//说明k移动到ptr的最末端

{

cout << "在位置" << i-plen+1<< endl;

k = -1;//重新初始化，寻找下一个

i = i - plen + 1;//i定位到该位置，外层for循环i++可以继续找下一个（这里默认存在两个匹配字符串可以部分重叠），感谢评论中同学指出错误。

 

}

}

return -1;

}

 

 

函数模板比较大小

template<typename T>//函数模板

T Max(T a,T b)

{

cout<<typeid(T).name()<<endl;//进行参数的推演，并输出参数

return a > b ? a : b;

}

cout<<"Max = "<<Max<int>(5.55,4)<<endl;