TZOJ 数据结构期末历年题目

A.数据结构练习题――线性表操作

线性表的基本操作

1.在某个位置p插入val，复杂度O（p）

2.在某个位置p删除val，复杂度O（p）

3.查找某个位置p的值，复杂度O（p）

4.清除链表，复杂度O（链表长）

 #include<iostream>
 #include<string>
 #include<list>
 using namespace std;
 int main()
 {
     int n,p,x;
     string s;
     list<int>li;
     list<int>::iterator it;
     while(cin>>s)
     {
         if(s=="exit")break;
         else if(s=="clear")li.clear();
         else if(s=="insert")
         {
             cin>>n;
             for(int i=;i<n;i++)
             {
                 cin>>p>>x;
                 it=li.begin();
                 while(--p)it++;
                 li.insert(it,x);
             }
         }
         else
         {
             cin>>p;
             it=li.begin();
             while(--p)it++;
             cout<<*it<<endl;
             if(s=="delete")li.erase(it);
         }
     }
     return ;
 }

 B.数据结构练习题――合并表

线性表的基本操作

先把第一排每个数放入链表，然后把b中的每个数插入链表，复杂度O（n+m）

 #include<iostream>
 #include<list>
 using namespace std;
 int main()
 {
     int t,n,m;
     list<int>li;
     list<int>::iterator it;
     cin>>t;
     while(t--)
     {
         li.clear();
         cin>>n;
         for(int i=,a;i<n;i++)cin>>a,li.push_back(a);
         cin>>m;
         it=li.begin();
         for(int i=,b;i<m;i++)
         {
             cin>>b;
             while(it!=li.end()&&*it<=b)it++;
             li.insert(it,b);
         }
         cout<<n+m;
         for(auto X:li)
             cout<<" "<<X;
         cout<<endl;
     }
     return ;
 }

C.数据结构―线性表插入删除

线性表的基本操作

1.在第pos个位置前插入连续m个数，由于是插入在前面，所以找到第pos个位置的地址it，然后不断插入，复杂度O（m）

2.删除第pos个位置开始连续m个数，若到表尾则删除到结尾，这里erase第pos个位置的地址it后，需要讲，复杂度O（m）

 #include<stdio.h>
 #include<list>
 using namespace std;
 int main()
 {
     int t,n,p,pos,m,x;
     char s[];
     scanf("%d",&t);
     while(t--)
     {
         list<int>l;
         list<int>::iterator it;
         scanf("%d",&n);
         for(int i=;i<n;i++)
             scanf("%d",&x),l.push_back(x);
         scanf("%d",&p);
         for(int i=;i<p;i++)
         {
             scanf("%s",s);
             if(s[]=='i')
             {
                 scanf("%d%d",&pos,&m);
                 it=l.begin();
                 while(--pos>)it++;//这里>0考虑到pos=0的情况
                 while(m--)
                     scanf("%d",&x),l.insert(it,x);
             }
             if(s[]=='d')
             {
                 scanf("%d%d",&pos,&m);
                 it=l.begin();
                 while(--pos)it++;
                 while(m--&&it!=l.end())l.erase(it++);
             }
         }
         int k=;
         for(it=l.begin();it!=l.end();it++)
         {
             if(k++)printf(" ");
             printf("%d",*it);
         }
         printf("\n");
     }
     return ;
 }

E.数据结构练习题――栈

栈的基本操作

1.把元素val压入栈，复杂度O（1）

2.弹出栈顶元素，若栈为空输出None，否则输出栈顶元素val，复杂度O（1）

3.输出栈顶元素，若栈为空输出None，否则输出栈顶元素val，复杂度O（1）

4.清空栈，复杂度O（栈中元素数）

 #include<iostream>
 #include<string>
 #include<stack>
 using namespace std;
 int main()
 {
     int a;
     string s;
     stack<int>st;
     while(cin>>s)
     {
         if(s=="exit")break;
         if(s=="push")cin>>a,st.push(a);
         if(s=="top")
         {
             if(st.empty())cout<<"None"<<endl;
             else cout<<st.top()<<endl;
         }
         if(s=="pop")
         {
             if(st.empty())cout<<"None"<<endl;
             else cout<<st.top()<<endl,st.pop();
         }
         if(s=="clear")
             while(!st.empty())st.pop();
     }
     return ;
 }

F.数据结构练习题----队列的基本操作

队列基本操作

1.值val入队，复杂度O（1）

2.出队，若队列为空，输出None，否则输出队头元素val，复杂度O（1）

3.输出队列中所有元素，若队列为空，输出None，否则输出所有元素，需要借助一个临时队列p用于存输出前的队列，复杂度O（原队列长）

 #include<iostream>
 #include<queue>
 #include<string>
 using namespace std;
 int main()
 {
     int a;
     string s;
     queue<int>q,p;
     while(cin>>s)
     {
         if(s=="exit")break;
         if(s=="enq")cin>>a,q.push(a);
         if(s=="printq")
         {
             if(q.empty()){cout<<"None"<<endl;continue;}
             int k=;
             p=q;
             while(!q.empty())
             {
                 if(k++)cout<<" ";
                 cout<<q.front(),q.pop();
             }
             cout<<endl;
             q=p;
         }
         if(s=="deq")
         {
             if(q.empty())cout<<"None"<<endl;
             else cout<<q.front()<<endl,q.pop();
         }
     }
     return ;
 }

 G.简单排序

给你n个数让你排个序，复杂度O（nlogn）

 #include<iostream>
 #include<algorithm>
 using namespace std;
 int main()
 {
     int t,n,a[];
     cin>>t;
     while(t--)
     {
         cin>>n;
         for(int i=;i<n;i++)cin>>a[i];
         sort(a,a+n);
         for(int i=;i<n;i++)cout<<a[i]<<(i==n-?"\n":" ");
     }
     return ;
 }

H.快速排序

给你n个数让你排序，注意用C++提交，复杂度O（nlogn）

 #include<stdio.h>
 #include<algorithm>
 using namespace std;
 int main()
 {
     int t,n,a[];
     while(scanf("%d",&n)!=EOF)
     {
         for(int i=;i<n;i++)scanf("%d",&a[i]);
         sort(a,a+n);
         for(int i=;i<n;i++)printf("%d%c",a[i],i==n-?'\n':' ');
     }
     return ;
 }

 I.二分查找

二分查找，注意C++提交，复杂度O（logn）

lowber_bound(a,a+n,x);

函数的作用是返回>=x的第一个位置，若没有返回最后一个位置

第一个为二分开始的位置，第二个为二分结束的位置，注意左闭右开，第三个为查找的值val

 #include<stdio.h>
 #include<algorithm>
 using namespace std;
 int a[];
 int main()
 {
     int n,m;
     while(scanf("%d",&n)!=EOF)
     {
         for(int i=;i<n;i++)scanf("%d",&a[i]);
         scanf("%d",&m);
         int pos=lower_bound(a,a+n,m)-a;
         if(pos==n||a[pos]!=m)printf("None\n");
         else printf("%d\n",pos+);
     }
     return ;
 }

J.图的遍历

图的深度优先和图的广度优先，需要有一个基本的认识，复杂度O（2n）

 #include<stdio.h>
 #include<string.h>
 #include<queue>
 using namespace std;
 int n,m,vis[],G[][];
 void dfs(int u)
 {
     if(vis[u])return;
     printf("%d ",u);
     vis[u]=;
     for(int i=;i<=n;i++)if(!vis[i]&&G[u][i])dfs(i);
 }
 void bfs(int u)
 {
     queue<int>q;
     q.push(u);
     while(!q.empty())
     {
         u=q.front();q.pop();
         if(vis[u])continue;
         printf("%d ",u);
         vis[u]=;
         for(int i=;i<=n;i++)if(!vis[i]&&G[u][i])q.push(i);
     }
 }
 int main()
 {
     while(scanf("%d%d",&n,&m)!=EOF)
     {
         memset(G,,sizeof(G));
         for(int i=,u,v;i<m;i++)
         {
             scanf("%d%d",&u,&v);
             G[u][v]=G[v][u]=;
         }
         memset(vis,,sizeof(vis));
         for(int i=;i<=n;i++)if(!vis[i])dfs(i);
         printf("\n");
         memset(vis,,sizeof(vis));
         for(int i=;i<=n;i++)if(!vis[i])bfs(i);
         printf("\n");
     }
     return ;
 }

K.二叉树遍历

这题给你的是层序，而且只有1000个节点，我们知道2^10-1=1024，所以最多10层，我们可以用数组建树

然后你需要知道如何先序中序后序，复杂度O（3*k），k为节点数

 #include<stdio.h>
 int a[],k;
 void P(int u,int flag)
 {
     if(u>k||a[u]==)return;
     if(flag==)printf(" %d",a[u]);//先序
     P(u*,flag);//左儿子
     if(flag==)printf(" %d",a[u]);//中序
     P(u*+,flag);//右儿子
     if(flag==)printf(" %d",a[u]);//后序
 }
 int main()
 {
     int t,x;
     scanf("%d",&t);
     while(t--)
     {
         k=;
         while(scanf("%d",&x),x!=-)a[k++]=x;
         for(int i=;i<=;i++)
             P(,i),printf("\n");
     }
     return ;
 }