数据结构基础算法

光荣之梦||

已于 2023-03-20 19:00:10 修改

阅读量76

点赞数 1

文章标签： c++ 算法数据结构

于 2023-03-17 20:49:27 首次发布

本文链接：https://blog.csdn.net/m0_73830679/article/details/129626745

版权

本文展示了四种常见的排序算法（埃氏筛法、欧拉筛法、归并排序和快速排序）以及二叉树的基本操作，同时探讨了图的构建、深度优先搜索、广度优先搜索、拓扑排序以及最短路径和最长路径的计算方法。这些是计算机科学中的基础概念，对理解和解决算法问题至关重要。

摘要由CSDN通过智能技术生成

埃氏筛法

#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
bool tr[N];
int g[N], cnt;
int find_prime(int n)
{
    for (int i = 2; i <= n; i++)
    {
        if (!tr[i])
        {
            g[cnt++] = i;
            for (int j = 2 * i; j <= n; j = j + i)
            {
                tr[j] = true;
            }
        }
    }
    return cnt;
}
int main()
{
    int n, m;
    cin >> n;
    m = find_prime(n);
    for (int i = 0; i < m; i++)
        cout << g[i] << " ";
}

欧拉筛法（线性筛）

#include<bits/stdc++.h>
using namespace std;

const int N=1e5+10;
bool tr[N];
int prime[N],cnt;
int get_prime(int n)
{
    for(int i=2;i<=n;i++)
    {
       if(!tr[i]) prime[cnt++]=i;
       for(int j=0;prime[j]<=n/i;j++)
       {
         tr[prime[j]*i]=true;
         if(i%prime[j]==0) break;
       }
    }
    return cnt;
}
int main()
{
   int n,m;
   cin>>n;
   m=get_prime(n);
    for (int i = 0; i < m; i++)
     cout << prime[i] << " ";
}

归并排序

#include<bits/stdc++.h>
using namespace std;

const int N=1e5+10;
int s[N],q[N],n;

void and_sort(int s[],int l,int r)
{
    if(l>=r)return;
    int mid=(l+r)/2;
    and_sort(s,l,mid);
    and_sort(s,mid+1,r);
    int i=l,j=mid+1,t=0;
     while(i<=mid&&j<=r)
     {
        if(s[i]<=s[j]) q[t++]=s[i++];
        else q[t++]=s[j++];
     }
     while(i<=mid)q[t++]=s[i++];
     while(j<=r)q[t++]=s[j++];
     for(int i=0,j=l;j<=r;i++,j++)
      s[j]=q[i];
 }
int main()
{
  cin>>n;
  for(int i=0;i<n;i++)
  cin>>s[i];
  and_sort(s,0,n-1);
    for(int i=0;i<n;i++)
  cout<<s[i]<<" ";
}

快排

#include<bits/stdc++.h>
using namespace std;

const int N=1e5+10;
int s[N],q[N],n;
void quick_sort(int s[],int l,int r)
{
   if(l==r)return ;
   int mid=s[(l+r)/2];
   int i=l-1,j=r+1;
   while(i<j)
   {
    do i++;while(s[i]<mid);
    do j--;while(s[j]>mid);
    if(i<j)swap(s[i],s[j]);
   }
   quick_sort(s,l,j);
   quick_sort(s,j+1,r);
}
int main()
{
  cin>>n;
  for(int i=0;i<n;i++)
  cin>>s[i];
  quick_sort(s,0,n-1);
   for(int i=0;i<n;i++)
    cout<<s[i]<<" ";
}

二叉树

#include<bits/stdc++.h>
using namespace std;

const int N=1e5+10;
int idx,tot,sum;
int deep[N];
string s;
struct node
{
  char data;
  int l,r;
}m[N];
int build()
{
    if(s[idx]==',')
    {
        idx++;
        return 0;
    }
    m[++tot].data=s[idx++];
    int now=tot;
    m[now].l=build();
    m[now].r=build();
    return now;
}
void pre(int u)
{
    if(!u)return;
    cout<<m[u].data<<" ";
    pre(m[u].l);
    pre(m[u].r);
}
void mid(int u)
{
    if(!u)return ;
    mid(m[u].l);
    cout<<m[u].data<<" ";
    mid(m[u].r);
}
void next(int u)
{
    if(!u)return ;
    next(m[u].l);
    next(m[u].r);
    cout<<m[u].data<<" ";
}
void yezi(int u)
{
    if(!u)return;
    if(!m[u].l&&!m[u].r)
    {
        sum++;
        cout<<m[u].data<<" ";
    }
    yezi(m[u].l);
    yezi(m[u].r);
}
int height(int u)
{
    if(!u)return 0;
    int len1,len2;
    len1=height(m[u].l);
    len2=height(m[u].r);
    return max(len1,len2)+1;
}
void bfs(int u)
{
	queue<int> q;
	q.push(u);
	while(q.size())
	{
		int x=q.front();
		q.pop();
		if(m[x].l) q.push(m[x].l);
		if(m[x].r) q.push(m[x].r);
		cout<<x<<endl; 
	}
}
int main()
{
    while(cin>>s)
    {
        int root;
        root=build();
        pre(root);puts("");
        mid(root);puts("");
        next(root);puts("");
        yezi(root);cout<<sum<<endl;
        cout<<height(root)<<endl;
        bfs(root);
    }

}

#include<bits/stdc++.h>
using namespace std;
string s1,s2;
const int N=1e6+5;
int m,n;
struct node{
	char date = '@';
	int l,r;
}tr[N];
int ct;
int mid[N];
int build(int prel,int prer,int midl,int midr)
{
	int val=s1[prel];
	int pos=mid[val];
	int L=-1,R=-1;
	if(midl<pos) L=build(prel+1,prel+pos-midl,midl,pos-1);
	if(midr>pos) R=build(prel+pos-midl+1,prer,pos+1,midr);
	ct++; tr[ct].date=s1[prel];
	if(L!=-1) tr[ct].l=L;
	if(R!=-1) tr[ct].r=R;
	return ct;
}
void nex(int root)
{
	if(tr[root].date == '@') return;
	nex(tr[root].l);	
	nex(tr[root].r);
	cout<<tr[root].date;
}
int main()
{
	int root;
 	cin>>s1>>s2;
 	m=s1.size();
 	for(int i=0;i<m;i++)
 	{
 	  mid[s2[i]]=i;	
	}
	ct=0;
 	root=build(0,m-1,0,m-1);
 	nex(root);
 	return 0;
}

图

1.建立图

#include<bits/stdc++.h>
using namespace std;

const int N=1e5+10;
int ne[N],h[N],idx,w[N],e[N];

void build(int a,int b)
{
    e[idx]=b;
    ne[idx]=h[a];
    h[a]=idx++;
}
void hit()
{
idx=0;
memset(h,-1,sizeof(h));
}

2.深搜图

int dfs(int u)
{
  tr[u]=true;
  for(int i=h[u];i!=-1;i=ne[i])
  {
    int j=e[i];
    if(!tr[j]) dfs(j);
  }
}

3.宽搜

void bfs()
{
    queue<int>q;
    tr[1]=true;
    q.push(1);
    while(q.size())
    {
    int t=q.front();
    q.pop();
    for(int i=h[t];i!=-1;i=ne[i])
    {
        int j=e[i];
        if(!tr[j])
        {
            q.push(j);
        }
    }
    }
}

4.拓扑排序

#include <bits/stdc++.h>
using namespace std;
vector<int> e[15];
int d[15];
int main()
{
    int n, m;
    while (cin >> n >> m)
    {
        for (int i = 1; i <= n; i++)
        {
            e[i].clear();
            d[i] = 0;
        }
        for (int i = 1; i <= m; i++)
        {
            int u, v;
            cin >> u >> v;
            e[u].push_back(v);
            d[v]++;
        }
        queue<int> q;
        for (int i = 1; i <= n; i++)
        {
            if (d[i] == 0)
                q.push(i);
        }
        int sum = 0;
        while (q.size())
        {
            int u = q.front();
            q.pop();
            sum++;
            for (int v : e[u])
            {
                if (--d[v] == 0)
                    q.push(v);
            }
        }
        if (sum == n)
            printf("YES\n");
        else
            printf("NO\n");
    }
    return 0;
}

5.最短路

typedef pair<int, int> PII;
int n;      // 点的数量
int dist[N];        // 存储所有点到1号点的距离
bool st[N];     // 存储每个点的最短距离是否已确定
int dijkstra()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    priority_queue<PII, vector<PII>, greater<PII>> heap;
    heap.push({0, 1});      // first存储距离，second存储节点编号

    while (heap.size())
    {
        auto t = heap.top();
        heap.pop();

        int ver = t.second, distance = t.first;

        if (st[ver]) continue;
        st[ver] = true;
        for (int i = h[ver]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > distance + w[i])
            {
                dist[j] = distance + w[i];
                heap.push({dist[j], j});
            }
        }
    }

    if (dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
}

int n;      // 总点数
int h[N], w[N], e[N], ne[N], idx;       // 邻接表存储所有边
int dist[N], cnt[N];        // dist[x]存储1号点到x的最短距离，cnt[x]存储1到x的最短路中经过的点数
bool st[N];     // 存储每个点是否在队列中

// 如果存在负环，则返回true，否则返回false。
bool spfa()
{
    // 不需要初始化dist数组
    // 原理：如果某条最短路径上有n个点（除了自己），那么加上自己之后一共有n+1个点，由抽屉原理一定有两个点相同，所以存在环。

    queue<int> q;
    for (int i = 1; i <= n; i ++ )
    {
        q.push(i);
        st[i] = true;
    }

    while (q.size())
    {
        auto t = q.front();
        q.pop();
        st[t] = false;
        for (int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > dist[t] + w[i])
            {
                dist[j] = dist[t] + w[i];
                cnt[j] = cnt[t] + 1;
                if (cnt[j] >= n) return true;       // 如果从1号点到x的最短路中包含至少n个点（不包括自己），则说明存在环
                if (!st[j])
                {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }

    return false;
}

6.最长路

#include <bits/stdc++.h>
using namespace std;
const int N = 5e4+9;
int n,m;
int e[N],v[N],h[N],ne[N],idx;
void add(int a,int b,int c)
{
    e[idx] = b;
    v[idx] = c;
    ne[idx] = h[a];
    h[a] = idx++;
}
int dist[N];
bool st[N];// 存储每个点是否在队列中
int spfa()
{
    memset(dist,0x3f,sizeof dist);
    dist[1] = 0;
    queue<int> q;
    q.push(1);
    while(!q.empty())
    {
        int t = q.front();
        q.pop();
        st[t] = 0;
        for(int i = h[t];i!=-1;i = ne[i])
        {
            int j = e[i];
            if(dist[j]>dist[t] + v[i])
            {
                dist[j] = dist[t] + v[i];
                if(!st[j])
                {
                    q.push(j);
                    st[j] = 1;
                }
            }
        }
    }
    if(dist[n] == 0x3f3f3f3f)
    return 1;
    else
    return dist[n];
}
int main()
{
    cin>>n>>m;
    memset(h,-1,sizeof h);
    for(int i = 1;i<=m;i++)
    {
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,-c);
    }
    int ans = spfa();
    cout<<-1*ans<<endl;
}