链表，冒泡，并查集

昨天进行的一阵脑补，对链表有了新的认识，补上昨天的链表

链表就像是，杂乱无章，但又有序号顺序的类似数组一样，但是比数组灵活，以下是我脑补的代码，和我自己写的代码：

自己写的代码：

#include<stdio.h>

#include<stdlib.h>

struct ac

{

    char name[20];

    ac *next;

};

int main()

{

    ac *head,*b,*c;

    head=new ac;

    c=head;

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

    {

        b=new ac;

        scanf("%s",b->name);

        c->next=b;

        c=b;

    }

    c->next=NULL;

    for(;head->next!=NULL;head=head->next)

    {

        printf("%s\n",head->next->name);

    }

}

 

脑补的代码：

#include<stdio.h>

#include<stdlib.h>

struct stu

{

    int num;

    stu *next;

};

int main()

{

    int i;

    stu *head,*b,*c;

    head=(stu*)malloc(sizeof(stu));

    c=head;

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

    {

        b=(stu*)malloc(sizeof(stu));

        scanf("%d",&b->num);

        c->next=b;

        c=b;

    }

    c->next=NULL;

    for(;head->next!=NULL;head=head->next)

    {

        printf("%d",head->next->num);

    }

    return 0;

}

 

 

 

 

链表感觉差不多，以下是今天的笔记：

冒泡，就像是鱼缸冒泡一样，最大的数往最后面来，虽然复杂度是n的平方，但是，对今后学习具有指导性意义；

        0

      0

    0

  0

0

就像这样，冒泡；

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

{

for(intj=0;j<n-i-1;i++)

{

       if(a[j]>a[j+1])

{

  int temp=a[j];

  a[j]=a[j+1];

  a[j+1]=temp;

}

}
}

 

 

 

还有筛选法求素数，刚开始我感觉不如i*i快，但是F神来这里一阵秀之后，发现，这个假想是错误的，筛选法快！

#include<stdio.h>

#defineN 300000

int a[N];

void f()

{

    for(int i=2;i<=N;i++)

    {

        if(!a[i])

        {

            for(intj=i+i;j<=N;j+=i)

            {

                a[i]=1;

            }

        }

    }

}

int main()

{

   

    for(int i=2;i<=N;i++){

        for(int j=2;j*j<=i;j++){

            if(i%j==0)break;

        }

    }

    printf("2\n");

    f();

    printf("1\n");

   

   

}

筛选法和正常法的比较！！

用flag[]数组标记每个数字的情况

int flag[N];

memset(flag,1,sizeof(flag));

然后

   for(int i=2;i<=N;i++)

    {

        if(flag[i])

        {

            for(intj=i+i;j<=N;j+=i)

            {

                a[i]=0;

            }

        }

}

这样一个表就出来了；

 

并查集

 

int pre[1000 ];

int find(int x)   //查找根节点

{ 

    int r=x;

    while ( pre[r ] != r )  //返回根节点 r

          r=pre[r ];

 

    int i=x , j ;

    while( i != r )   //路径压缩

    {

         j = pre[ i ]; // 在改变上级之前用临时变量  j 记录下他的值 

         pre[ i ]= r ; //把上级改为根节点

         i=j;

    }

    return r ;

}

 

 

void join(int x,int y)  //判断x y是否连通//如果已经连通，就不用管了 //如果不连通，就把它们所在的连通分支合并起,

{

    int fx=find(x),fy=find(y);

    if(fx!=fy)

        pre[fx ]=fy;

}

 

只要不等于他本身，就一直往上找，找到为止。