图的广度优先遍历
FirstNeighbor,NextNeighbor,需要用到图Graph,队列Enqueue,Dequeue,数组visit[];
bool visited[MAX_VERTEX_NUM];//标记访问数组
//如果是非连通图需要加上下面这段代码
//1.初始化数组
//2.初始化队列
void BFSTravel(Grapg G){
for(i=0;i<G.vexnum;++i){
visited[i]=FALSE;
}//for
InitQueue(Q);
for(i=0;i<G.vexnum;++i){
if(!visited[i])
BFS(G,i);
}//for
}
//广度优先遍历
void BFS(Graph G,int v){
visit(v);
visited[v]=TRUE;
Enqueue(Q,v);
while(!isEmpty(Q)){
Dequeue(Q,v);
for(w=FirstNeighbor(G,v);w>=0;w=NextNeighbor(G,v,w){
if(!visited[w]){
visit(w);
visted[w]=TRUE;
EnQueue(Q,w);
}//if
}//for
}while
}
图的深度优先遍历
需要数组visited[],图Graph;
bool viste[MAX_VERTEX_NUM];
void DFSTravel(Graph G){
for(v=0;v<G.vexnum;++v)
visited[v]=FALSE;
for(v=0;v<G.vexnum;++v){
if(!visited[v])
DFS(G,v);
}
}
void DFS(Grapg G,int v){
visit(v);
visited[v]=TRUE;
for(w=FirstNeighbor;w>=0;w=NextNeighbor(G,v,w){
if(!visited[w])
DFS(G,W);
}//for
}
DAY1
算法思想:让p指针从第一个元素开始遍历整个数据,用指针q标记值为x的结点并删除。
tips:删除某结点要按照后前的顺序修改指针,遍历链表按照前后的顺序修改指针,且pre一开始是指向头结点的,p指向第一个元素。
bool Delete_X(SeqList &L,int x){
//遍历指针p
//标记指针q
//p的前指针pre
LNODE *p=L->next, *q,*pre=L;
while(p!=NULL){
if(p->data==x){
q=p;
p=p->next;
pre->next=p;
free(p);
L->Length--;
}else{
pre=p;
p=p->next;
}
}
}
DAY 2
算法思想:将顺序表A中元素依次和B表中元素比较,把比较小的那个元素放入C表,指针各加一后再依次遍历,直至一个表为空,把另一个表中的剩余元素都加入C表即可。
bool Merge(SqList &A,SqList &B,SqList &C){
if(A.length+B.length>C.Maxsize) return false;//忘了判断条件
int i=0,j=0,k=0;
while(i<A.length&&j<B.Length){
if(A.data[i]<B.data[j]){
C.data[k]=A.data[i];
k++;
i++;
}else{
C.data[k]=B.data[jJ;
k++;
j++;
}
}
while(i<A.length){//忘了剩下的元素
C.data[k]=A.data[i];
k++;
i++;
}
while(j<B.length){
C.data[k]=B.data[j];
k++;
j++;
}
C.length=k;//忘了长度
return ture;
}
DAY3
算法思想1:依次交换第一个元素和最后一个元素;
算法思想2:用递归实现;
tips:数组元素从0——n,长度为L.length=n+1,n=L.length-1
方法一:
void Reverse(SqList &L){
int temp=0;
for(int i=0;i<(L.length-1)/2;i++){
temp=L.data[i];
L.data[i]=L.data[n-i];
L.data[n-i]=temp;
}
}
方法二:
void Reverse(int low,int hign,int *A){
while(low<high){
Swap(A[low],A[high]
}
}
DAY4
算法思想:设置一个定时器k,遍历整个顺序表,若当前元素值为k,则k+1,后面元素向前移动k+1个单位。
void Delete_X (SqList &L,int x){
int k=0;
for(int i=0;i<=L.length-1;i++){
if(L.data[i]==x){
k++;
else
L.data[i-k]=L.data[i];
}
}
L.length=L.length-k;
return true;
}
DAY5
算法思想一:设置一个计数器K,从头遍历顺序表,若当前元素在s和t之间,则k加1,其他不满足条件的元素向前移动k个位置,
算法思想2:将顺序表有序排列,再从头遍历。
bool Delete(SqList &L,int s,int t){
if(s<=t) return false;
if(L.length<=0) return false;
int k=0; //计数器
for(int i=0;i<=L.length-1;i++){
if(L.data[i]<=t&&L.data[i]>=s){
k++;
}
L.data[i-k]=L.data[i];
}
L.length=L.length-k;
return true;
}
DAY6
算法思想:从第二个元素开始遍历,若前后两个元素相等则不保留,不相等则保留。
bool Delete_Same(SqList %L){
int i=1;//第一个元素不会重复,所有从下标1开始
int j=i+1;
int k=0;//计数器
for(i=0;i<=L,length-1;i++){
if(L.data[i]!=L.data[j]{
i++;j++;
}else{
j++;
k++;
}
}
L。length=L.length-k;
return true;
}
DAY7
bool Reverse(SqList &A,int low,int high){
//这个函数传入的参数为
/*要逆置的数组
*要逆置这个数组那一段的开始下标from
*要逆置那一段的结束下标to
*/
int temp;
for(i=0;i<(high-low+1)/2;i++){
temp=L.data[low+i];
L.data[low+i]=L.data[high-i];
L.data[high-1]=temp;
}
return true
}
void Exchange(SqList &A,int n,int m){
Reverse(A,0,m-1);
Reverse(A,m,m+n-1);
Reverse(A,0,m+n-1);
}
DAY8
void Reverse(int R[],int from,int to){
int temp;
for(i=0;i<=(to-from+1)/2;i++){
temp=R.data[from+i];
R.data[from+i]=R.data[to-i];
R.data[to-i]=temp;
}
}
void Exchange(int R[],int m,int n){
Reverse(R,0,p-1);
Reverse(R,p,n-1);
Reverse(R,0,n-1);
}
DAY9
最小值指针min,假设第一个最小,p指针遍历,找到最小的,找到后把pre的next指向min的下一个
void Delete_Min(LinkList &L){
LNode *p=L->next;
LNode *pre=L;
LNode *min=p;
LNode *minpre=L;
while(p!=NULL){
if(p->next->data>min->data){
pre=p;
p=p->next;
}else{
min=p;
minpre=pre;
pre=p;
p=p->next;
}
}
minpre->next=min->next;
free(min);
}
DAY10
传入一个头结点,头指针,新建一个结点s,头插入头结点后面
LinkList Create_Head(LinkList &L){
LNode *s;
int x;
L=(LinkList)malloc(sizeof(LNode));
L->next=NULL;
x=scanf("%d",&x);
while(x!=-1){
s=(LNode *)malloc(sizeof(LNode));
s->data=x;
s->next=L->next;
L->next=s;
}
return L;
}
DAY11
LinkList Create_Head(LinkList &L){
LNode *s,*p=L;//p为末尾指针
int x;
L=(LinkList)malloc(sizeof(LNode));
L->next=NULL;
x=scanf("%d",&x);
while(x!=-1){
s=(LNode *)malloc(sizeof(LNode));
s->data=x;
s->next=p->next;
p->next=s;
p=s;
p->next=NULL;
}
return L;
}
DAY12
LinkList Reverse(LinkList &L){
LNode *p=L->next;
LNode *q;
while(p!=NULL){
p=p->next;
if(p->next==NULL){
q=L->next;
L->next=q->next;
q->next=p->next;
p->next=q;
p=q;
}
}
return L;
}
DAY13
LinkList Delete(LinkList &L,ElemType s,ElemType t){
LNode *p=L->next;
LNode *pre=L;
while(p!=NULL){
if(p->data>=s&&p->data<=t){
pre->next=p->next;
free(p);
p=pre->next;//这句自己写的时候忘记了,要纠错!!
}
pre=p;
p=p->next;
}
}
DAY14![在这里插入图片描述](https://i-blog.csdnimg.cn/blog_migrate/40243b193c3f4f34d272f03046847a12.png)
方法一:暴力法(p指针不动,让q指针多次遍历)
LinkList Find_Same(LinkList &LA,LinkList &LB){
LNode *p = LA->next;
LNode *q = LB->next;
while(p!=NULL){
while(q!=NULL){
if(q!=p){
q=q->next;
}
}
p=p->next;
q=LB->next;//这句忘了,要纠错!!
}
return p;
}
方法二:有共同结点的两个链表,一定会有共同的表尾结点。所以让两个链表的指针在长度一样的地方同时出发,看表尾结点是否相同(默认表长已知)新思路记下来
LinkList Find_Same(LinkList &LA,LinkList &LB){
LNode *p=LA->next;
LNode *q=LB->next;
int lenA=length(LA);
int lenB=length(LB);
if(lenA>lenB){ //让p始终指向较长的单链表
int k=lenA-lenB;
p=LA->next;
q=LB->next;
}else{
int k=lenB-lenA;
q=LA->next;
p=LB->next;
}
while(k--){//让p指针后移(先走)K个单位,这个很牛!要记下来!
p=p->next;
}
while(p!=NULL){
if(p=q){
return p;
}else{
p=p->next;
q=q->next;
}
}
}
DAY15
算法思想:注意奇偶性指的是序号,不是元素,
LinkList Creat(LinkList &A){
int i=0;
LNode *LB=(LNode *)malloc(sizeof(LNode));
LB->next=NULL;
LNode *rb=LB;
LNode *ra=LA;
LNode *p=LA->next;
LA->next=NULL;
while(p!=NULL){
i++;
if(i%2==0){
rb->next=p;
rb=p;
}else{
ra->next=p;
ra=p
}
p=p->next;
}
ra->next=NULL;
rb->next=NULL;
return B;
}
DAY16
算法思想:A表尾插,B表头插
LinkList Create(LinkList &hc){
LNode *LA=(LNode *)malloc(sizeof(LNode));
LNode *LB=(LNode *)malloc(sizeof(LNode));
LA->next=NULL;
LB->next=NULL;
LNode *ra=LA;
LNode *q;
LNode *p=hc->next;
hc->next=NULL;
while(p!=NULL){
i++;
if(i%2!=0){
ra->next=p;
ra=p;
}else{
q=p;
q->next=LB->next;
LB->next=q;
}
p=p->next;
}
ra->next=NULL;
}
DAY17
LinkList Delete_Sane(LinkList &A){
LNode *p=L->next;
LNode *pre=L;
while(p!=NULL){
if(pre->data==p->data){
pre->next=p->next;
free(p);
p=pre->next;
}else{
pre=p;
p=p->next;
}
}
return A;
}
DAY18
算法思想:依次比较两个单链表A、B中元素的大小,把较小的元素头插入链表A,最后判断是否有剩余的元素,依次头插入A即可
LinkList Creat(LinkList &A,LinkList &B){
LNode *p=LA->next;
LNode *q=LB->next;
LNode *ra,*rb;
while(p&&q){
if(q->data<=p->data){
rb=q->next;
q->next=LA->next;
LA->next=q;
q=rb;
}else{
ra=p->next;
p->next=LA->next;
LA->next=p;
p=ra;
}
}
if(p){
ra=p->next;
p->next=LA->next;
LA->next=p;
p=ra;
}
if(q){
rb=q->next;
q->next=LB->next;
LB->next=q;
q=rb;
}
free(B)
return A;
}
DAY19
算法思想:先找到公共结点,再给A、B的尾指针置空,C表的头结点指向公共结点。
LinkList Create(LinkList &A,LinkList &B){
int lenA=Len(A);
int lenB=Len(B);
LNode *p=LA->next;
LNode *q=LB->next;
LNode *preA=LA;
LNode *preB=LB;
if(lenA>lenB)
i=lenA-lenB;
while(i--){
preA=p;
p=p->next;
}
else
i=lenB-lenA;
while(i--){
preB=q;
q=q->next;
}
while(p!=q){
pre
}
}
DAY25
Locate(L,x){
DNode *p=L->next;
DNode *q;
while(p!=NULL){
if(p->data==x){
p->freq++;
q=p->pred;
//指针q从p往前寻找,找打大于p的freq或者走到表头,就把p插入后面
if(q->freq>p->freq||q==L){
//把p从表中取下
p->pred->next=p->next;
p->next->pred=p->pred;
//再把p插入到q后面
p-next=q->next;
q->next->pred=p;
p->pred=q;
q->next=p;}
}else{
p=p->next;
}
}
DAY26
(1)算法思想:查找倒数第K个结点,也就是正数第length-K+1个结点,从第一个结点往后遍历,找到第length-K+1个结点后,返回结点值和1,若查找失败则返回0。
(2)算法思想:设置两个指针pq,让p先走k个单位,然后pq一起移动,知道p指向空结点,则q即为所求结点。
方法一:
int Find_K(LinkList &L,int k){
int k;
LNode *p=list;
LNode *q;
int count=0;
int length=0;
int Length(L){//求链表长度
while(p!=NULL){
p=p->next;
length++;
}
return length;
}
if(L->length<k) return 0;//如果链表长度小于k,则查找失败
p=list->next;
while(p!=NULL){//判断是否是倒数第k个元素
if(count==L->length-k+1){
return p->data;
}else{
p=p->next;
count++;
} //if
}//while
return 1;
}//int
方法二:
int Find_K(LinkList &L,int k){
LNode *p=list;
LNode *q=list;
while(k>1){//让p先走k个单位
p=p->next;
k--;
}//while
while(p!=NULL){
p=p->next;
q=q->next;
}
printf("倒数第k个元素的值为"%d"",q->data);
return 1;
}
DAY27
算法思想:先求出两个单链表的长度差k,让较长的链表的遍历指针先走k个单位后,再一起移动指针,直到两个指针的next域指向同一个结点并返回该节点。
LNode Find_Common(LinkList &LA,LinkList &LB){
LNode *str1=LA;
LNode *str2=LB;
int lenA=length(LA,str1);
int lenB=length(LB,str2);
int length=1;
int i;//长度差
int length(L,p){
while(p!=NULL){
length++;
p-p->next;
}
}
if(lenA>lenB){
i=lenA-lenB;
str1=LA->next;
str2=LB->next;
}else{
i=lenB-lenA;
str1=LB->next;
str2=LA->next;
}//if
while(str1!=NULL){
if(i>0)
i--;
str1=str1->next;
}//while
while(str1->next!=str2->next){
str1=str1->next;
str2=str2->next;
}//while
return str1->next;
}