devbox
笔触狂放9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

SCAU期末笔记 - 数据结构（STL版）_8579链式线性表的基本操作scau

作者：笔触狂放9 | 2024-06-25 17:51:37

赞

踩

8579链式线性表的基本操作scau

在完结了算法之后 我又来写数据结构啦！真的很讨厌校OJ数据结构的题，输出提示词太捞了，每一题都是超级缝合怪，像个小课设一样。

值得一提的是，虽然数据结构课上要求是用C语言实现这些功能，但是因为频繁用到引用，所以考试可以直接提交C++，再加上机试没有填空题，所以我们完全可以直接使用C++的STL，本文也是直接使用STL实现的。

但是！这并不代表数据结构实现的原理不重要，因为我们数据结构的笔试的大题会要求你在试卷上进行试卷填空，这一部分等我有空再开一篇文章，如果你在CSDN搜到别的看不懂的话，建议翻开你的高程回去恶补指针，结构体相关知识。那么闲话少叙，我们直接开始！

实验1

本章主要介绍了顺序表这一数据结构，我们使用STL的话对应的就是vector这一容器了。使用时需要引用头文件<vector>

常用的相关函数有这些

  1. vector<int> a;//创建一个int类型的数组a 相当于int a[n];
  2. a.empty();//判断数组是否为空
  3. a.push_back(8);//在数组的末尾插入一个元素8
  4. a.push_front(8);//在数组的开头插入一个元素8
  5. a.pop_back();//删除数组的最后一个元素
  6. a.pop_front();//删除数组的第一个元素
  7. a.front();//返回数组的第一个元素
  8. a.back();//返回数组的最后一个元素
  9. a.size();//返回数组的大小
  10. a.clear();//清空数组
  11. a.insert(a.begin()+1,8);//在数组的第二个元素后面插入一个元素8
  12. a.erase(a.begin()+1);//删除数组的第二个元素
  13. a.erase(a.begin()+1,a.begin()+3);//删除数组的第二个到第四个元素
  14. //copilot自动填充注释太好用了 快去拿校园邮箱白嫖一个

8576 顺序线性表的基本操作

  1. #include <iostream>
  2. #include <algorithm>
  3. #include <vector>
  4.  
  5. using namespace std;
  6. typedef long long i64;
  7.  
  8. int main()
  9. {
  10.     vector<int> a;
  11.     printf("A Sequence List Has Created.\n");
  12. again://防伪标识
  13.     printf("1:Insert element\n2:Delete element\n3:Load all elements\n0:Exit\nPlease choose:\n");
  14.     int cmd;
  15.     scanf("%d",&cmd);
  16.     if(cmd==1)
  17.     {
  18.         int p,x;
  19.         scanf("%d%d",&p,&x);
  20.         if(p==1)
  21.         {
  22.             a.insert(a.begin(),x);
  23.             printf("The Element %d is Successfully Inserted!\n", x);
  24.             goto again;
  25.         }
  26.         else
  27.         {
  28.             if(a.empty())
  29.             {
  30.                 printf("Insert Error!\n");
  31.                 goto again;
  32.             }
  33.             a.insert(a.begin()+p-2,x);
  34.             printf("The Element %d is Successfully Inserted!\n", x);
  35.             goto again;
  36.         }
  37.     }
  38.     else if(cmd==2)
  39.     {
  40.         int p;
  41.         scanf("%d",&p);
  42.         int n=a.size();
  43.         if(n<p)
  44.         {
  45.             printf("Delete Error!\n");
  46.             goto again;
  47.         }
  48.         int x=a[p-1];
  49.         a.erase(a.begin()+p-1);
  50.         printf("The Element %d is Successfully Deleted!\n", x);
  51.         goto again;
  52.     }
  53.     else if(cmd==3)
  54.     {
  55.         if(!a.empty())
  56.         {
  57.             printf("The List is: ");
  58.             for (int i: a)
  59.                 printf("%d ", i);
  60.             printf("\n");
  61.             goto again;
  62.         }
  63.         else
  64.         {
  65.             printf("The List is empty!\n");
  66.             goto again;
  67.         }
  68.     }
  69.     else
  70.         return 0;
  71.     return 0;
  72. }

8577 合并顺序表

为防你上课没听过 我还是简单给你介绍一下 题目给你两个排好序的数组 你要将他们合并并保持仍然有序 直接拼在一起sort会超时

所以我们对于新一个数组的每一位 考虑这个时候a和b的值的大小 谁小先放谁

  1. #include <iostream>
  2. #include <algorithm>
  3. #include <vector>
  4.  
  5. using namespace std;
  6. typedef long long i64;
  7.  
  8. int main()
  9. {
  10.     int n,m;
  11.     scanf("%d",&n);
  12.     int a[n];
  13.     for(int i=0;i<n;i++) scanf("%d",&a[i]);
  14.     scanf("%d",&m);
  15.     int b[m];
  16.     for(int i=0;i<m;i++) scanf("%d",&b[i]);
  17.     int c[n+m];
  18.     int i=0,j=0,k=0;
  19.     while(i<n and j<m)
  20.     {
  21.         if(a[i]<b[j])
  22.         {
  23.             c[k]=a[i];
  24.             i++;
  25.         }
  26.         else if(a[i]>=b[j])
  27.         {
  28.             c[k]=b[j];
  29.             j++;
  30.         }
  31.         k++;
  32.     }
  33.     while(i<n)
  34.     {
  35.         c[k]=a[i];
  36.         i++;
  37.         k++;
  38.     }
  39.     while(j<m)
  40.     {
  41.         c[k]=b[j];
  42.         j++;
  43.         k++;
  44.     }
  45.     printf("List A:");
  46.     for(int i:a) printf("%d ",i);
  47.     printf("\n");
  48.     printf("List B:");
  49.     for(int i:b) printf("%d ",i);
  50.     printf("\n");
  51.     printf("List C:");
  52.     for(int i:c) printf("%d ",i);
  53.     printf("\n");
  54.     return 0;
  55. }

8578 顺序表逆置

虽然我知道直接用数组很简单啦 不过这题我们还是继续训练一下vector的使用 这里用到了两个新的函数 他们返回的是迭代器 你可以简单地理解为他们返回的是vector开头和结尾的指针即可

  1. #include <iostream>
  2. #include <algorithm>
  3. #include <vector>
  4.  
  5. using namespace std;
  6. typedef long long i64;
  7.  
  8. int main()
  9. {
  10.     int n;
  11.     scanf("%d",&n);
  12.     vector<int> a(n);
  13.     for(int i=0;i<n;i++)
  14.         scanf("%d",&a[i]);
  15.     printf("The List is:");
  16.     for(int i:a)
  17.         printf("%d ",i);
  18.     printf("\n");
  19.     printf("The turned List is:");
  20.     for(auto it = a.rbegin(); it != a.rend(); ++it) {
  21.         printf("%d ", *it);
  22.     }
  23.     printf("\n");
  24.     return 0;
  25. }

8579 链式线性表的基本操作

因为我们用的是STL 所以本题几乎和第一题一模一样 但是为了展示本文的多样性我们做一次填空（绝对不是因为拿之前那个改了一直WA不知道为什么）

我的代码中每一句都有专门重新写注释 希望能帮助你看懂这类模拟数据结构填空题出题人的一般思路（他的这个马蜂真的是看得我好难受）

  1. #include<stdio.h>
  2. #include<malloc.h>
  3. #define ERROR 0
  4. #define OK 1
  5. #define ElemType int
  6.  
  7. typedef struct LNode
  8. {
  9.     int data;
  10.     struct LNode *next;
  11. }LNode,*LinkList;//定义单链表
  12.  
  13. int CreateLink_L(LinkList &L,int n){
  14.     LinkList p,q;//p为新建结点，q为尾结点
  15.     int i;
  16.     ElemType e;//哥们至今都不知道到底为什么非要定义这么个ElemType
  17.     L = new LNode;//传入的这个L是一个LinkList也就是指针类型 所以这里是让他指向一个新的LNode
  18.     L->next = NULL;//初始化头结点的next指针指向NULL
  19.     q = L;//因为L是引用来的不能改他的指向 所以把他赋给这个q 因为是指针类型不影响对指针内内容的操作能力的同时还能方便我丢进去循环
  20.     for (i=0; i<n; i++) {
  21.         scanf("%d", &e);
  22.         p = new LNode;//开一个新的节点
  23.         p->data = e;//赋值
  24.         p->next = NULL;//初始化指向的下一个节点
  25.         q->next = p;//把新节点接到尾结点后面
  26.         q = p;//然后再更新q方便我循环操作
  27.     }
  28.     return OK;
  29. }
  30.  
  31. int LoadLink_L(LinkList &L){
  32.     LinkList p = L->next;
  33.     if(!p)//如果头结点的next指针指向NULL说明链表是空的
  34.         printf("The List is empty!");
  35.     else
  36.     {
  37.         printf("The LinkList is:");
  38.         while(p)//只要指向的不是NULL（表示没有下个节点了）就一直输出
  39.         {
  40.             printf("%d ",p->data);
  41.             p=p->next;//更新p
  42.         }
  43.     }
  44.     printf("\n");
  45.     return OK;
  46. }
  47.  
  48. int LinkInsert_L(LinkList &L,int i,ElemType e){
  49.     LinkList p = L;
  50.     int j = 0;
  51.     while(p && j<i-1)//找到第i个位置的前一个节点
  52.     {
  53.         p = p->next;
  54.         j++;
  55.     }
  56.     if(!p || j>i-1)//如果找不到或者i值不合法
  57.         return ERROR;
  58.     LinkList s = new LNode;//新建一个节点
  59.     s->data = e;//赋值
  60.     s->next = p->next;//把新节点的next指针指向第i个节点
  61.     p->next = s;//把第i-1个节点的next指针指向新节点
  62.     return OK;
  63. }
  64.  
  65. int LinkDelete_L(LinkList &L,int i, ElemType &e){
  66.     LinkList p = L;
  67.     int j = 0;
  68.     while(p->next && j<i-1)//找到第i个节点的前一个节点
  69.     {
  70.         p = p->next;
  71.         j++;
  72.     }
  73.     if(!(p->next) || j>i-1)//如果找不到或者i值不合法
  74.         return ERROR;
  75.     LinkList q = p->next;//把第i个节点赋给q
  76.     p->next = q->next;//把第i-1个节点的next指针指向第i+1个节点
  77.     e = q->data;//把第i个节点的值赋给e
  78.     delete q;//删除第i个节点
  79.     return OK;
  80. }
  81.  
  82. int main()
  83. {
  84.     LinkList T;
  85.     int a,n,i;
  86.     ElemType x, e;
  87.     printf("Please input the init size of the linklist:\n");
  88.     scanf("%d",&n);
  89.     printf("Please input the %d element of the linklist:\n", n);
  90.     if(CreateLink_L(T,n))//他那个ERROR和OK真的是抽象 懒得喷 总之这里就是在刚刚创建链表的时候根据那个函数的返回值判断成功没有
  91.     {
  92.         printf("A Link List Has Created.\n");
  93.         LoadLink_L(T);
  94.     }
  95.     while(1)
  96.     {
  97.         printf("1:Insert element\n2:Delete element\n3:Load all elements\n0:Exit\nPlease choose:\n");
  98.         scanf("%d",&a);
  99.         switch(a)
  100.         {
  101.             case 1: scanf("%d%d",&i,&x);
  102.                 if(!LinkInsert_L(T,i,x)) printf("Insert Error!\n"); //判断i值是否合法，他同样用的是根据函数返回值判断的
  103.                 else printf("The Element %d is Successfully Inserted!\n", x);
  104.                 break;
  105.             case 2: scanf("%d",&i);
  106.                 if(!LinkDelete_L(T,i,e)) printf("Delete Error!\n"); //判断i值是否合法，他同样用的是根据函数返回值判断的
  107.                 else printf("The Element %d is Successfully Deleted!\n", e);
  108.                 break;
  109.             case 3: LoadLink_L(T);
  110.                 break;
  111.             case 0: return 1;
  112.         }
  113.     }
  114. }

8580 合并链表

这一题也是跟刚才的第二题一模一样 不过我突然发现当时用的是数组 那这边顺便介绍下vector如何事前声明数组大小 就是在名字后面加个括号就可以了 其他部分都是完全相同的

  1. #include <iostream>
  2. #include <algorithm>
  3. #include <vector>
  4.  
  5. using namespace std;
  6. typedef long long i64;
  7.  
  8. int main()
  9. {
  10.     int n,m;
  11.     scanf("%d",&n);
  12.     vector<int> a(n);
  13.     for(int i=0;i<n;i++) scanf("%d",&a[i]);
  14.     scanf("%d",&m);
  15.     vector<int> b(m);
  16.     for(int i=0;i<m;i++) scanf("%d",&b[i]);
  17.     vector<int> c(n+m);
  18.     int i=0,j=0,k=0;
  19.     while(i<n and j<m)
  20.     {
  21.         if(a[i]<b[j])
  22.         {
  23.             c[k]=a[i];
  24.             i++;
  25.         }
  26.         else if(a[i]>=b[j])
  27.         {
  28.             c[k]=b[j];
  29.             j++;
  30.         }
  31.         k++;
  32.     }
  33.     while(i<n)
  34.     {
  35.         c[k]=a[i];
  36.         i++;
  37.         k++;
  38.     }
  39.     while(j<m)
  40.     {
  41.         c[k]=b[j];
  42.         j++;
  43.         k++;
  44.     }
  45.     printf("List A:");
  46.     for(int i:a) printf("%d ",i);
  47.     printf("\n");
  48.     printf("List B:");
  49.     for(int i:b) printf("%d ",i);
  50.     printf("\n");
  51.     printf("List C:");
  52.     for(int i:c) printf("%d ",i);
  53.     printf("\n");
  54.     return 0;
  55. }

19080 反转链表

肯定有人看到这一题欣喜若狂 结果点进去发现是填空题的 因为至少我就是 不过题目本身很简单 直接贴代码吧 刚好看你之前的8579看懂没有捏

  1.     /**< 逆置单链表 */
  2.     LNode *p,*q;//p为工作指针，q为工作指针的后继
  3.     p=L->next;//p指向第一个节点
  4.     L->next=NULL;//断开头结点与第一个节点的联系
  5.     while(p)
  6.     {
  7.         q=p->next;//q指向p的后继
  8.         p->next=L->next;//将p插入到头结点之后
  9.         L->next=p;//头结点的next指向p
  10.         p=q;//p指向下一个节点
  11.     }

实验2

本章我们使用的有STL中的stack容器 需要引入头文件<stack> 其主要特点是单向入栈单向出栈且遵循后进先出的特点 你可以理解为一根杆子上的一堆秤砣 就像这张图上这样

那么主要用到的函数我们也是一样摆在下面（size和empty这种意思没啥区别的就不单独列了）

  1. stack<int> s;//定义一个栈
  2. s.push(8);//在栈顶插入元素8
  3. s.pop();//弹出栈顶元素
  4. int c=s.top();//让c等于栈顶元素 但是不弹出

除此之外 我们还要用queue这一容器 引用头文件<queue>即可使用 队列则是与上面相反 遵循先进先出的规则

主要用到的函数如下

  1. queue<int> q;//创建一个int类型数据组成的队列q
  2. q.push(8);//将8放在队列尾端
  3. q.pop();//弹出队列前端的元素
  4. q.front();//返回队列前端的元素
  5. q.back();//返回队列尾端的元素

8583 顺序栈的基本操作

又是我最讨厌的小型课设 利用上面介绍的函数可以很轻松地完成这些问题

  1. #include <iostream>
  2. #include <algorithm>
  3. #include <stack>
  4.  
  5. using namespace std;
  6. typedef long long i64;
  7.  
  8. int main()
  9. {
  10.     stack<int> st;
  11.     printf("A Stack Has Created.\n");
  12.     again://防伪标识
  13.     printf("1:Push \n2:Pop \n3:Get the Top \n4:Return the Length of the Stack\n5:Load the Stack\n0:Exit\nPlease choose:\n");
  14.     int op;
  15.     scanf("%d",&op);
  16.     if(op==1)
  17.     {
  18.         int x;
  19.         scanf("%d",&x);//根本不可能error的干脆不写了
  20.         st.push(x);
  21.         printf("The Element %d is Successfully Pushed!\n", x);
  22.         goto again;
  23.     }
  24.     else if(op==2)
  25.     {
  26.         if(st.empty())
  27.         {
  28.             printf("Pop Error!\n");
  29.             goto again;
  30.         }
  31.         else
  32.         {
  33.             int e=st.top();//先把栈顶元素存一下 不然一弹就没了
  34.             st.pop();
  35.             printf("The Element %d is Successfully Poped!\n", e);
  36.             goto again;
  37.         }
  38.     }
  39.     else if(op==3)
  40.     {
  41.         if(st.empty())
  42.         {
  43.             printf("Get Top Error!\n");
  44.             goto again;
  45.         }
  46.         else
  47.         {
  48.             int e=st.top();//跟上面那个基本一样 把弹出的操作删掉就行
  49.             printf("The Top Element is %d!\n", e);
  50.             goto again;
  51.         }
  52.     }
  53.     else if(op==4)
  54.     {
  55.         int sz=st.size();
  56.         printf("The Length of the Stack is %d!\n", sz);
  57.         goto again;
  58.     }
  59.     else if(op==5)
  60.     {
  61.         if(st.empty())
  62.         {
  63.             printf("The Stack is Empty!");
  64.             goto again;
  65.         }
  66.         else
  67.         {
  68.             printf("The Stack is:");
  69.             stack<int> st2 = st;//用stl的缺点就是无法遍历栈内元素 所以我们要开一个新的 然后弹这个新的
  70.             while (!st2.empty())
  71.             {
  72.                 printf(" %d", st2.top());
  73.                 st2.pop();
  74.             }
  75.             printf("\n");
  76.             goto again;
  77.         }
  78.     }
  79.     else if(op==0)
  80.     {
  81.         return 0;
  82.     }
  83.     return 0;
  84. }

8584 循环队列的基本操作

跟上面基本一样 改一下函数和输出的提示词就可以了

  1. #include <iostream>
  2. #include <algorithm>
  3. #include <queue>
  4.  
  5. using namespace std;
  6. typedef long long i64;
  7.  
  8. int main()
  9. {
  10.     queue<int> q;
  11.     printf("A Queue Has Created.\n");
  12.     again://防伪标识
  13.     printf("1:Enter \n2:Delete \n3:Get the Front \n4:Return the Length of the Queue\n5:Load the Queue\n0:Exit\nPlease choose:\n");
  14.     int op;
  15.     scanf("%d",&op);
  16.     if(op==1)
  17.     {
  18.         int x;
  19.         scanf("%d",&x);//根本不可能error的干脆不写了
  20.         q.push(x);
  21.         printf("The Element %d is Successfully Entered!\n", x);
  22.         goto again;
  23.     }
  24.     else if(op==2)
  25.     {
  26.         if(q.empty())
  27.         {
  28.             printf("Delete Error!\n");
  29.             goto again;
  30.         }
  31.         else
  32.         {
  33.             int e=q.front();//先把队顶元素存一下 不然一弹就没了
  34.             q.pop();
  35.             printf("The Element %d is Successfully Deleted!\n", e);
  36.             goto again;
  37.         }
  38.     }
  39.     else if(op==3)
  40.     {
  41.         if(q.empty())
  42.         {
  43.             printf("Get Head Error!\n");
  44.             goto again;
  45.         }
  46.         else
  47.         {
  48.             int e=q.front();//跟上面那个基本一样 把弹出的操作删掉就行
  49.             printf("The Head of the Queue is %d!\n", e);
  50.             goto again;
  51.         }
  52.     }
  53.     else if(op==4)
  54.     {
  55.         int sz=q.size();
  56.         printf("The Length of the Queue is %d!\n", sz);
  57.         goto again;
  58.     }
  59.     else if(op==5)
  60.     {
  61.         if(q.empty())
  62.         {
  63.             printf("The Stack is Empty!");
  64.             goto again;
  65.         }
  66.         else
  67.         {
  68.             printf("The Queue is:");
  69.             queue<int> q2 = q;//用stl的缺点就是无法遍历队内元素 所以我们要开一个新的 然后弹这个新的
  70.             while (!q2.empty())
  71.             {
  72.                 printf(" %d", q2.front());
  73.                 q2.pop();
  74.             }
  75.             printf("\n");
  76.             goto again;
  77.         }
  78.     }
  79.     else if(op==0)
  80.     {
  81.         return 0;
  82.     }
  83.     return 0;
  84. }

8585 栈的应用——进制转换

终于正儿八经有道题了...这个功能C++好像有内置函数 直接调吧还是

  1. #include <iostream>
  2.  
  3. using namespace std;
  4. typedef long long i64;
  5.  
  6. int main()
  7. {
  8.     int n;
  9.     scanf("%d",&n);
  10.     printf("%o\n",n);
  11.     return 0;
  12. }

8586 括号匹配检验

终于来了 这个才是我想做的题嘛 题目描述已经说的很清楚了 用栈存储的方式快速解决这个问题 具体来说遇到左括号就存进去 遇到右括号和栈顶的左括号无法匹配就直接输出错误 否则就弹出 弹到最后如果栈内还有剩余同样输出错误即可

不过嘛 不知道之前看到现在的你有没有像这样一件事：既然栈和队列都有这么多的限制，无法遍历所有内容，那我干脆用vector不就好了嘛，需要的功能也同样能实现

这样的说法当然是...完全没有问题！所以这一题，我们就用vector来模拟stack的方式来完成！

  1. #include <iostream>
  2. #include <algorithm>
  3. #include <vector>
  4.  
  5. using namespace std;
  6. typedef long long i64;
  7.  
  8. int main()
  9. {
  10.     string s;
  11.     cin>>s;
  12.     int l=s.length();
  13.     vector<char> st;
  14.     for(int i=0;i<l;i++)
  15.     {
  16.         if(s[i]=='('||s[i]=='[')
  17.         {
  18.             st.push_back(s[i]);
  19.         }
  20.         else if(s[i]==')')
  21.         {
  22.             if(st.empty())
  23.             {
  24.                 printf("lack of left parenthesis\n");
  25.                 return 0;
  26.             }
  27.             else if(st.back()!='(')
  28.             {
  29.                 printf("isn't matched pairs\n");
  30.                 return 0;
  31.             }
  32.             st.pop_back();
  33.         }
  34.         else if(s[i]==']')
  35.         {
  36.             if(st.empty())
  37.             {
  38.                 printf("lack of left parenthesis\n");
  39.                 return 0;
  40.             }
  41.             else if(st.back()!='[')
  42.             {
  43.                 printf("isn't matched pairs\n");
  44.                 return 0;
  45.             }
  46.             st.pop_back();
  47.         }
  48.     }
  49.     if(!st.empty())
  50.     {
  51.         printf("lack of right parenthesis\n");
  52.         return 0;
  53.     }
  54.     printf("matching\n");
  55.     return 0;
  56. }

8587 行编辑程序

这一题我们遇到了之前遇到过的栈的元素无法遍历的问题 之前我们通过赋值一个新栈来解决这个问题 但是这次我们刚刚已经学习了用vector模拟stack的做法 这时就展现出其用途了 在实现stack功能的基础上 vector还可以遍历 那么我们也就解决了这样一个问题

  1. #include <iostream>
  2. #include <algorithm>
  3. #include <vector>
  4.  
  5. using namespace std;
  6.  
  7. int main()
  8. {
  9.     int n;
  10.     scanf("%d\n",&n);
  11.     vector<char> a;
  12.     char c;
  13.     while(n>0)//每次读到回车就n-- n等于0说明读完了
  14.     {
  15.         scanf("%c",&c);
  16.         a.push_back(c);
  17.         if(c=='\n')
  18.             n--;
  19.         else if(c=='#')
  20.         {
  21.             a.pop_back();
  22.             a.pop_back();
  23.         }
  24.         else if(c=='@')
  25.         {
  26.             while(a.back()!='\n')
  27.                 a.pop_back();
  28.         }
  29.     }
  30.     for(char ch:a)
  31.         printf("%c",ch);
  32.     return 0;
  33. }

但是这个代码错误 这是为什么呢 原来是没有判空 小朋友们千万不要模仿

  1. #include <iostream>
  2. #include <algorithm>
  3. #include <vector>
  4.  
  5. using namespace std;
  6.  
  7. int main()
  8. {
  9.     int n;
  10.     scanf("%d\n",&n);
  11.     vector<char> a;
  12.     char c;
  13.     while(n>0)//每次读到回车就n-- n等于0说明读完了
  14.     {
  15.         scanf("%c",&c);
  16.         a.push_back(c);
  17.         if(c=='\n')
  18.             n--;
  19.         else if(c=='#')
  20.         {
  21.             a.pop_back();
  22.             if(!a.empty())
  23.                 a.pop_back();
  24.         }
  25.         else if(c=='@')
  26.         {
  27.             while(a.back()!='\n')
  28.             {
  29.                 if(a.empty())
  30.                     break;
  31.                 a.pop_back();
  32.             }
  33.         }
  34.     }
  35.     int l=a.size();
  36.     for(int i=0;i<l;i++)
  37.         printf("%c",a[i]);
  38.     return 0;
  39. }

8588 表达式求值

利用栈实现表达式求值

  1. #include <iostream>
  2. #include <algorithm>
  3. #include <ctype.h>
  4. #include <stack>
  5. #include <vector>
  6. #include <map>
  7.  
  8. using namespace std;
  9. typedef long long i64;
  10.  
  11. int main()
  12. {
  13.     //初始化优先级
  14.     map<char,int> getValue;
  15.     getValue['+']=1;
  16.     getValue['-']=1;
  17.     getValue['*']=2;
  18.     getValue['/']=2;
  19.  
  20.     string s;
  21.     cin>>s;
  22.     int l=s.length();
  23.     //先转为后缀表达式
  24.     stack<char>opt;//存符号
  25.     stack<char>num;//存数字
  26.     vector<char>all;//存后缀表达式
  27.     for(int i=0;i<l;i++)
  28.     {
  29.         if(s[i]=='=' or i==l-1)
  30.         {
  31.             while(!opt.empty())
  32.             {
  33.                 all.push_back(opt.top());
  34.                 opt.pop();
  35.             }
  36.             break;
  37.         }
  38.         else if(isdigit(s[i]))
  39.             all.push_back(s[i]);
  40.         else if(s[i]=='(')
  41.             opt.push(s[i]);
  42.         else if(s[i]==')')
  43.         {
  44.             while(!opt.empty() and opt.top()!='(')
  45.             {
  46.                 all.push_back(opt.top());
  47.                 opt.pop();
  48.             }
  49.             opt.pop();
  50.         }
  51.         else
  52.         {
  53.             while(!opt.empty() and getValue[opt.top()]>=getValue[s[i]])
  54.             {
  55.                 all.push_back(opt.top());
  56.                 opt.pop();
  57.             }
  58.             opt.push(s[i]);
  59.         }
  60.     }
  61.  
  62.     //计算后缀表达式
  63.     l=all.size();
  64.     stack<int>digit;//记录待计算的数字
  65.     for(int i=0;i<l;i++)
  66.     {
  67.         if(isdigit(all[i]))
  68.         {
  69.             digit.push(all[i]-'0');
  70.         }
  71.         else
  72.         {
  73.             int a=digit.top();
  74.             digit.pop();
  75.             int b=digit.top();
  76.             digit.pop();
  77.             if(all[i]=='+')
  78.                 digit.push(b+a);
  79.             else if(all[i]=='-')
  80.                 digit.push(b-a);
  81.             else if(all[i]=='*')
  82.                 digit.push(b*a);
  83.             else if(all[i]=='/')
  84.                 digit.push(b/a);
  85.         }
  86.     }
  87.     printf("%d\n",digit.top());
  88.     return 0;
  89. }

 不过假如你用的是python 你可以用四行秒杀这道题

  1. expression = input()
  2. expression = expression[:-1]#删掉最后面的等号
  3. result = eval(expression)
  4. print(result)

 18938 汉诺塔问题

我上面用的那张图就是汉诺塔 不过这题倒是不用栈 用的是递归

  1. #include <iostream>
  2. #include <algorithm>
  3.  
  4. using namespace std;
  5.  
  6. void hnt(int n,char a,char b,char c)
  7. {
  8.     if(n==1)
  9.     {
  10.         printf("%c->%d->%c\n",a,n,b);
  11.         return ;
  12.     }
  13.     hnt(n-1,a,c,b);
  14.     printf("%c->%d->%c\n",a,n,b);
  15.     hnt(n-1,c,b,a);
  16. }
  17. int main()
  18. {
  19.     int n;
  20.     char a,b,c;
  21.     cin>>n>>a>>b>>c;
  22.     hnt(n,a,b,c);
  23.     return 0;
  24. }

实验3

这一章主要讲的就是KMP算法 特别是next值的计算

8591 计算next值

坏消息是学校的next值和常搜到的定义有些许出入 可能需要背一下

  1. #include <iostream>
  2.  
  3. #define  MAXSTRLEN  255                   // 用户可在255以内定义最大串长
  4. typedef unsigned char SString[MAXSTRLEN + 1];    // 0号单元存放串的长度
  5.  
  6. void get_next(SString t, int next[])
  7. {
  8. // 算法4.7
  9. // 求模式串T的next函数值并存入数组next
  10.     // 请补全代码
  11.     int i = 1, j = 0;
  12.     next[1] = 0;
  13.     while (i <= t[0])
  14.     {
  15.         if (j == 0 || t[i] == t[j])
  16.         {
  17.             ++i;
  18.             ++j;
  19.             next[i] = j;
  20.         } else j = next[j];
  21.     }
  22. }
  23.  
  24. int main()
  25. {
  26.     int next[MAXSTRLEN];
  27.     SString S;
  28.     int n, i, j;
  29.     char ch;
  30.     scanf("%d", &n);    // 指定要验证NEXT值的字符串个数
  31.     ch = getchar();
  32.     for (i = 1; i <= n; i++)
  33.     {
  34.         ch = getchar();
  35.         for (j = 1; j <= MAXSTRLEN && (ch != '\n'); j++)    // 录入字符串
  36.         {
  37.             S[j] = ch;
  38.             ch = getchar();
  39.         }
  40.         S[0] = j - 1;    // S[0]用于存储字符串中字符个数
  41.         get_next(S, next);
  42.         printf("NEXT J is:");
  43.         for (j = 1; j <= S[0]; j++)
  44.             printf("%d", next[j]);
  45.         printf("\n");
  46.     }
  47. }

8592 KMP算法

好消息是用stl的话直接用algorithm库里面的find函数或是cstring里面的strstr函数就可以过

  1. #include <iostream>
  2. #include <algorithm>
  3.  
  4. using namespace std;
  5. typedef long long i64;
  6.  
  7. void solve()
  8. {
  9.     string a;
  10.     string b;
  11.     cin>>a>>b;
  12.     int ans=a.find(b);
  13.     printf("%d\n",ans+1);
  14. }
  15.  
  16. int main()
  17. {
  18.     int T=1;
  19.     scanf("%d",&T);
  20.     while(T--)
  21.     {
  22.         solve();
  23.     }
  24.     return 0;
  25. }

18769 不完整的排序

双指针嘛 先写一个

  1. #include <iostream>
  2. #include <algorithm>
  3.  
  4. using namespace std;
  5. typedef long long i64;
  6.  
  7. int main()
  8. {
  9.     int T=1;
  10.     scanf("%d",&T);
  11.     while(T--)
  12.     {
  13.         int n;
  14.         scanf("%d",&n);
  15.         int a[n];
  16.         for(int i=0;i<n;i++) scanf("%d",&a[i]);
  17.         for(int i=0,j=n-1;i<j;i++,j--)
  18.         {
  19.             if(a[i]>0)
  20.             {
  21.                 while(a[j]>0 and i<j)
  22.                     j--;
  23.                 swap(a[i],a[j]);
  24.             }
  25.             if(a[j]<0)
  26.             {
  27.                 while(a[i]<0 and i<j)
  28.                     i++;
  29.                 swap(a[i],a[j]);
  30.             }
  31.         }
  32.         for(int i=0;i<n;i++) printf("%d ",a[i]);
  33.     }
  34.     return 0;
  35. }

不对 那找参考再写一个 反正黄栋群里问题目从来不回的 你要是有幸抽到我院这位学科代言人你就偷着乐去吧 每节课一次全体点名 上课不许玩手机不许睡觉 下课手机不许横着放 实验课要求按学号坐 没人就算旷课 写完了想提前下课还要答辩

  1. #include <iostream>
  2. #include <algorithm>
  3.  
  4. using namespace std;
  5. typedef long long i64;
  6.  
  7. int main()
  8. {
  9.     int T = 1;
  10.     scanf("%d", &T);
  11.     while (T--)
  12.     {
  13.         int n;
  14.         scanf("%d", &n);
  15.         int a[n + 1];
  16.         for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
  17.         int i, j;
  18.         i = 1, j = n;
  19.         while (i < j)
  20.         {
  21.             if (a[i] > 0 && a[j] > 0)
  22.                 j--;
  23.             else if (a[i] > 0 && a[j] < 0)
  24.             {
  25.                 swap(a[i], a[j]);
  26.                 i++, j--;
  27.             }
  28.             else if (a[i] < 0 && a[j] < 0)
  29.                 i++;
  30.             else if (a[i] < 0 && a[j] > 0)
  31.                 i++, j--;
  32.         }
  33.         for (int i = 1; i <= n; i++) printf("%d ", a[i]);
  34.         printf("\n");
  35.     }
  36.     return 0;
  37. }

虽然我后来发现第一个代码只是少打了一个回车 但是我不想删掉对于我们黄栋老师的批判所以保留此段 望周知

实验4

二叉树这个东西确实没有对应STL 但是搞指针链真的难受 所以我们下面会介绍两种数组的存法

8606 二叉树的构建及遍历操作

前序遍历中序遍历后序遍历其实唯一的区别就是输出的时间不同 具体看代码一眼就能看懂 还是开头那句话 指针看不懂赶紧回去恶补高程捏

  1. #include <iostream>
  2. #include <algorithm>
  3. using namespace std;
  4.  
  5. #define TRUE 1
  6. #define FALSE 0
  7. #define OK  1
  8. #define ERROR  0
  9. #define INFEASIBLE -1
  10. #define OVERFLOW -2
  11. typedef int Status;
  12.  
  13. typedef char ElemType;
  14. typedef struct BiTNode
  15. {
  16.     ElemType data;
  17.     struct BiTNode *lchild, *rchild;//左右孩子指针
  18. } BiTNode, *BiTree;
  19.  
  20. Status CreateBiTree(BiTree &T)
  21. {  // 算法6.4
  22.     // 按先序次序输入二叉树中结点的值（一个字符），’#’字符表示空树，
  23.     // 构造二叉链表表示的二叉树T。
  24.     char ch;
  25.     scanf("%c", &ch);
  26.     if (ch == '#')
  27.         T = NULL;
  28.     else
  29.     {
  30.         if (!(T = (BiTNode *) malloc(sizeof(BiTNode))))
  31.             return ERROR;
  32.         T->data = ch;// 生成根结点
  33.         CreateBiTree(T->lchild);// 构造左子树
  34.         CreateBiTree(T->rchild);// 构造右子树
  35.     }
  36.     return OK;
  37. } // CreateBiTree
  38.  
  39. Status PreOrderTraverse(BiTree T)
  40. {
  41.     // 前序遍历二叉树T的递归算法
  42.     //补全代码,可用多个语句
  43.     if(T==NULL)
  44.         return 0;
  45.     cout<<T->data;
  46.     PreOrderTraverse(T->lchild);
  47.     PreOrderTraverse(T->rchild);
  48.     return 1;
  49. } // PreOrderTraverse
  50.  
  51. Status InOrderTraverse(BiTree T)
  52. {
  53.     // 中序遍历二叉树T的递归算法
  54.     //补全代码,可用多个语句
  55.     if(T==NULL)
  56.         return 0;
  57.     InOrderTraverse(T->lchild);
  58.     cout<<T->data;
  59.     InOrderTraverse(T->rchild);
  60.     return 1;
  61. } // InOrderTraverse
  62.  
  63. Status PostOrderTraverse(BiTree T)
  64. {
  65.     // 后序遍历二叉树T的递归算法
  66.     //补全代码,可用多个语句
  67.     if(T==NULL)
  68.         return 0;
  69.     PostOrderTraverse(T->lchild);
  70.     PostOrderTraverse(T->rchild);
  71.     cout<<T->data;
  72.     return 1;
  73. } // PostOrderTraverse
  74.  
  75. int main()   //主函数
  76. {
  77.     BiTree T;
  78.     CreateBiTree(T);
  79.     PreOrderTraverse(T);cout<<endl;
  80.     InOrderTraverse(T);cout<<endl;
  81.     PostOrderTraverse(T);cout<<endl;
  82.     return 0;
  83.     //补充代码
  84. }//main

17121 求二叉树各种节点数

为了丰富本文的解法数 这题我们介绍用数组来存二叉树（仅限二叉树） 如图所示 节点的数字就是他存于数组的下标

不难发现 节点i的左儿子和右儿子的下标分别为2*i和2*i+1 你可能会问按顺序存如果中间某个节点缺儿子怎么办 那就将这个位置标记为一个特殊的数据就可以了

  1. #include <iostream>
  2. #include <algorithm>
  3. #include <cstring>
  4.  
  5. using namespace std;
  6. typedef long long i64;
  7. char tree[10000];//数据很小
  8. string s;
  9. int po=0;//当前读取到字符串的第po位
  10. int len;//字符串长度
  11. void initialize(int p)
  12. {
  13.     if(po>len)
  14.         return ;
  15.     char now=s[po];
  16.     po++;
  17.     if(now=='#')
  18.         return ;
  19.     tree[p]=now;//存进去
  20.     initialize(2*p);
  21.     initialize(2*p+1);
  22. }
  23. int ans[3]={0};
  24. void solve(int p)
  25. {
  26.     if(tree[p]=='#')
  27.         return ;
  28.     int now=0;
  29.     if(tree[2*p]!='#')
  30.         now++;
  31.     if(tree[2*p+1]!='#')
  32.         now++;
  33.     ans[now]++;
  34.     solve(2*p);
  35.     solve(2*p+1);
  36. }
  37.  
  38. int main()
  39. {
  40.     cin>>s;
  41.     len=s.length();
  42.     memset(tree, '#', sizeof(tree));
  43.     initialize(1);
  44.     solve(1);
  45.     for(int i=2;i>=0;i--)
  46.     {
  47.         printf("%d\n",ans[i]);
  48.     }
  49.     return 0;
  50. }

也许你可以尝试下如何用数组存二叉树完成三种遍历？我想看懂上面的代码的话应该不是特别难写喵 当然这边还是给一个用指针解这道题的解法吧 其实直接拿上一题的先序遍历改一下就OK了

  1. #include <iostream>
  2. #include <algorithm>
  3. using namespace std;
  4.  
  5. #define TRUE 1
  6. #define FALSE 0
  7. #define OK  1
  8. #define ERROR  0
  9. #define INFEASIBLE -1
  10. #define OVERFLOW -2
  11. typedef int Status;
  12.  
  13. typedef char ElemType;
  14. typedef struct BiTNode
  15. {
  16.     ElemType data;
  17.     struct BiTNode *lchild, *rchild;//左右孩子指针
  18. } BiTNode, *BiTree;
  19.  
  20. Status CreateBiTree(BiTree &T)
  21. {  // 算法6.4
  22.     // 按先序次序输入二叉树中结点的值（一个字符），’#’字符表示空树，
  23.     // 构造二叉链表表示的二叉树T。
  24.     char ch;
  25.     scanf("%c", &ch);
  26.     if (ch == '#')
  27.         T = NULL;
  28.     else
  29.     {
  30.         if (!(T = (BiTNode *) malloc(sizeof(BiTNode))))
  31.             return ERROR;
  32.         T->data = ch;// 生成根结点
  33.         CreateBiTree(T->lchild);// 构造左子树
  34.         CreateBiTree(T->rchild);// 构造右子树
  35.     }
  36.     return OK;
  37. } // CreateBiTree
  38.  
  39. int ans[3]={0};
  40. Status PreOrderTraverse(BiTree T)
  41. {
  42.     if(T==NULL)
  43.         return 0;
  44.     //cout<<T->data;
  45.     int a=PreOrderTraverse(T->lchild);
  46.     int b=PreOrderTraverse(T->rchild);
  47.     int sum=0;
  48.     if(a==1)
  49.         sum++;
  50.     if(b==1)
  51.         sum++;
  52.     ans[sum]++;
  53.     return 1;
  54. } // PreOrderTraverse
  55.  
  56. int main()   //主函数
  57. {
  58.     BiTree T;
  59.     CreateBiTree(T);
  60.     PreOrderTraverse(T);
  61.     for(int i=2;i>=0;i--)
  62.     {
  63.         printf("%d\n",ans[i]);
  64.     }
  65.     return 0;
  66.     //补充代码
  67. }//main

18924 二叉树的宽度

这题同样也是用数组模拟会比较简单喵 但是我们又引入一种新的存法 用一个数组存每个数的两个儿子都是谁 没有的话就记为0 存完之后我们直接bfs 注意到每次再次进入循环都是新的一层 所以加一个求最大值就可以了

  1. #include <iostream>
  2. #include <algorithm>
  3. #include <queue>
  4.  
  5. using namespace std;
  6. typedef long long i64;
  7. int child[10000][2];
  8.  
  9. int main()
  10. {
  11.     int n;
  12.     scanf("%d",&n);
  13.     for(int i=1;i<n;i++)
  14.     {
  15.         int x,y;
  16.         scanf("%d%d",&x,&y);
  17.         if(child[x][0]==0)
  18.             child[x][0]=y;
  19.         else
  20.             child[x][1]=y;
  21.     }
  22.     queue<int>q;
  23.     q.push(1);
  24.     int ans=1;
  25.     while(q.size())
  26.     {
  27.         int len=q.size();
  28.         ans=max(ans,len);
  29.         for(int i=0;i<len;i++)
  30.         {
  31.             int t=q.front();
  32.             q.pop();
  33.             if(child[t][0])
  34.                 q.push(child[t][0]);
  35.             if(child[t][1])
  36.                 q.push(child[t][1]);
  37.         }
  38.     }
  39.     printf("%d",ans);
  40.     return 0;
  41. }

当然bfs好写不代表之前的存法不能写 我们把没有内容的点存为0 然后最后对整个数组遍历一下即可 主要是大家都是数字确实可能容易看混 主要问题是我一开始这么写的但是又是不知道错在哪 黄栋又不回我消息 所以下面这个代码无法通过

  1. #include <iostream>
  2. #include <algorithm>
  3.  
  4. using namespace std;
  5. typedef long long i64;
  6.  
  7. int main()
  8. {
  9.     int n;
  10.     scanf("%d",&n);
  11.     int tree[10000]={0};
  12.     tree[1]=1;
  13.     for(int i=1;i<n;i++)
  14.     {
  15.         int x,y;
  16.         scanf("%d%d",&x,&y);
  17.         if(tree[2*x]==0)
  18.             tree[2*x]=y;
  19.         else
  20.             tree[2*x+1]=y;
  21.     }
  22.     int i=1;//找到第几个数了
  23.     int now=1;//当前层总节点个数（假如全满）
  24.     int ans=0;
  25.     while(i<10000)
  26.     {
  27.         int l=i,sum=0;
  28.         for(;i<l+now;i++)
  29.         {
  30.             if(i>=10000)
  31.                 break;
  32.             if(tree[i])
  33.             {
  34.                 sum++;
  35.             }
  36.         }
  37.         now*=2;
  38.         ans=max(ans,sum);
  39.     }
  40.     printf("%d\n",ans);
  41.     return 0;
  42. }

18724 二叉树的遍历运算

根据先序遍历和中序遍历生成后序遍历 私以为这篇文章讲的已经很详细了 我就直接贴代码吧

  1. #include <iostream>
  2. #include <algorithm>
  3. #include <string>
  4.  
  5. using namespace std;
  6. typedef long long i64;
  7. string s1, s2;
  8.  
  9. void solve(int l1, int r1, int l2, int r2)
  10. {
  11.     char c = s1[l1];//正序遍历的第一个字符是后续遍历的最后一个字符
  12.     if (l1 > r1 || l2 > r2)
  13.         return;//递归边界
  14.     int i;
  15.     for (i = l2; i <= r2; i++)
  16.     {
  17.         if (c == s2[i])
  18.             break;
  19.     }//在中序遍历的序列中找到这个字符
  20.     //那么这个字符的左边是左子树，右边是右子树，分别递归即可
  21.     solve(l1 + 1, r1 - (r2 - i), l2, i - 1);
  22.     solve(r1 - (r2 - i - 1), r1, i + 1, r2);
  23.     printf("%c", c);
  24. }
  25.  
  26. int main()
  27. {
  28.     cin >> s1 >> s2;
  29.     int len1 = s1.size();
  30.     int len2 = s2.size();
  31.     solve(0, len1 - 1, 0, len2 - 1);
  32.     return 0;
  33. }
  34.

18923 二叉树的直径

看起来这一题是要我们遍历每一个点去两个方向找 但是其实你可以发现我们只需要对一个点左边找最深再右边找最深加起来就可以了 不过dfs应该不用再多说了吧

（虽然后来我发现直径的路径一定经过根节点 但是反正都能过就懒得改了）

  1. #include <iostream>
  2. #include <algorithm>
  3.  
  4. typedef long long ll;
  5. using namespace std;
  6. int n, child[105][2], ans = 0;
  7. int x, y;
  8.  
  9. int dfs(int p)
  10. {
  11.     if (!p)
  12.         return 0;
  13.     int left = dfs(child[p][0]);
  14.     int right = dfs(child[p][1]);
  15.     int len = max(left, right) + 1;
  16.     ans = max(ans, left + right);
  17.     return len;
  18. }
  19.  
  20. int main()
  21. {
  22.     scanf("%d", &n);
  23.     for (int i = 1; i < n; i++)
  24.     {
  25.         cin >> x >> y;
  26.         if (!child[x][0])
  27.             child[x][0] = y;
  28.         else
  29.             child[x][1] = y;
  30.     }
  31.     for (int i = 1; i <= n; i++)
  32.         dfs(i);
  33.     printf("%d\n", ans);
  34.     return 0;
  35. }

当然 如果你喜欢的话 也可以对每一个点往两个方向去找 这样的话我们就需要记录树之间双向的联系 链式和二维都无法完成这一点 只能用一维数组 他的父节点是i/2 子节点是i*2和i*2+1 我想你可以自己尝试一下这种写法（绝对不是我写完WA了）

19638 平衡树

（题号是我为了排版随便编的）这是2024年上半期末上机考新出的压轴题 提前交卷赶紧回来码题解了 后来的朋友们也可以参考下压轴题的难度

题目大意是给你一个中序遍历 然后要你构建一个满足此中序遍历的平衡树 最后输出你构建好的树的先序遍历 如果链接打不开我就简单说一下 平衡树就是他左右所有子孙节点的和的差值的绝对值最小 所以构建的时候我们只需要找满足此条件的点放到根节点 查找的时候记得使用前缀和 虽然我没试但是不用的话大概率会超时 然后左右再递归就可以了（给中序节点基本上都是要递归写的）

我写的时候用的是一维数组存储 中间没判空WA了一发 这里顺便给出一维数组存储的先序遍历方法吧

  1. #include <iostream>
  2. #include <algorithm>
  3. #include <cstring>
  4. using namespace std;
  5. typedef long long i64;
  6. int n,a[100000]={0},sum[100000]={0};
  7. int tree[100000]={0};
  8. void solve(int l,int r,int nowi)
  9. {
  10.     if(r<l) return ;//记得要判空
  11.     if(l==r)
  12.     {
  13.         tree[nowi]=a[l];
  14.         return ;
  15.     }
  16.     if(r==l+1)
  17.     {
  18.         tree[nowi]=max(a[l],a[r]);
  19.         tree[nowi*2]=min(a[l],a[r]);
  20.         return ;
  21.     }
  22.     int p=0,m=1e9;//记录满足左右abs最小的值的位置和此时的左右abs
  23.     for(int i=l;i<=r;i++)
  24.     {
  25.         int left=abs(sum[i-1]-sum[l-1]);
  26.         int right=abs(sum[r]-sum[i]);
  27.         int now=abs(left-right);
  28.         if(now<m)
  29.         {
  30.             m=now;
  31.             p=i;
  32.         }
  33.     }
  34.     tree[nowi]=a[p];
  35.     solve(l,p-1,nowi*2);
  36.     solve(p+1,r,nowi*2+1);
  37. }
  38. void print(int nowi)//一维数组存储的先序遍历
  39. {
  40.     printf("%d ",tree[nowi]);
  41.     if(tree[nowi*2]!=-1)
  42.         print(nowi*2);
  43.     if(tree[nowi*2+1]!=-1)
  44.         print(nowi*2+1);
  45. }
  46.  
  47. int main()
  48. {
  49.     scanf("%d",&n);
  50.     for(int i=1;i<=n;i++)
  51.     {
  52.         scanf("%d",&a[i]);
  53.         sum[i]=sum[i-1]+a[i];
  54.     }
  55.     memset(tree,-1,sizeof(tree));
  56.     solve(1,n,1);
  57.     print(1);
  58.     return 0;
  59. }

实验5

8610 顺序查找

  1. #include <iostream>
  2. #include <algorithm>
  3.  
  4. using namespace std;
  5. typedef long long i64;
  6.  
  7. int main()
  8. {
  9.     int n;
  10.     scanf("%d",&n);
  11.     int a[n];
  12.     for(int i=0;i<n;i++)
  13.     {
  14.         scanf("%d",&a[i]);
  15.     }
  16.     int who;
  17.     scanf("%d",&who);
  18.     for(int i=0;i<n;i++)
  19.     {
  20.         if(a[i]==who)
  21.         {
  22.             printf("The element position is %d.\n",i+1);
  23.             return 0;
  24.         }
  25.     }
  26.     printf("The element is not exist.\n");
  27.     return 0;
  28. }

8621 二分查找

我当然知道二分很好写嘛 但是我们借这个机会再介绍一个C++中algorithm库里面的一个函数吧

我们这个代码里面直接把binary_search()和lower_bound()都用了 注意这几个函数最好配套vector使用 不知道vector是啥的请把本文翻到最上面

  1. #include <iostream>
  2. #include <algorithm>
  3. #include <vector>
  4.  
  5. using namespace std;
  6. typedef long long i64;
  7.  
  8. int main()
  9. {
  10.     int n;
  11.     scanf("%d",&n);
  12.     vector<int> a(n);
  13.     for(int i=0;i<n;i++)
  14.     {
  15.         scanf("%d",&a[i]);
  16.     }
  17.     int who;
  18.     scanf("%d",&who);
  19.     if(!binary_search(a.begin(),a.end(),who))
  20.     {
  21.         printf("The element is not exist.\n");
  22.         return 0;
  23.     }
  24.     printf("The element position is %d.\n",lower_bound(a.begin(),a.end(),who)-a.begin());
  25.     return 0;
  26. }

当然也不是说直接开数组就不行哈 类似sort函数写成binary_search(a,a+n,who)也可以

8622 哈希查找

  1. #include <iostream>
  2. #include <algorithm>
  3.  
  4. using namespace std;
  5. typedef long long i64;
  6. int length;
  7. int H(int k)
  8. {
  9.     return 3*k%length;
  10. }
  11.  
  12. int main()
  13. {
  14.     scanf("%d",&length);
  15.     int HashTable[100000]={0};
  16.     int k;
  17.     double cnt=0;
  18.     double sum=0;
  19.     while(1)
  20.     {
  21.         scanf("%d",&k);
  22.         if(k==-1)
  23.             break;
  24.         int po=H(k);
  25.         while(HashTable[po]!=0)
  26.         {
  27.             sum++;
  28.             po++;
  29.         }
  30.         HashTable[po]=k;
  31.         cnt++;
  32.     }
  33.     sum+=cnt;
  34.     for(int i=0;i<length;i++)
  35.     {
  36.         if(HashTable[i]==0)
  37.             printf("X ");
  38.         else
  39.             printf("%d ",HashTable[i]);
  40.     }
  41.     printf("\n");
  42.     printf("Average search length=%.6lf\n",sum/cnt);
  43.     return 0;
  44. }

实验6

终于到了排序 我最讨厌的一节 每一道题都要求你输出每一趟排序的结果就很烦啊 他甚至冒泡故意来个反着的 你必须照着样例去猜他的排法 这个是真的很讨厌好伐

8638 直接插入排序

前面三道题都属于插入排序 直接插入排序算是最朴素的排序方式之一了 完全符合人脑的思维方式

当我有一大堆无序的数据时 我按顺序一个一个放 对于每一个数据 我去看看之前已经放好的那些数据 把他放到一个合适的位置 抽象成代码之后也就不是特别难写了

  1. #include <iostream>
  2. #include <algorithm>
  3.  
  4. using namespace std;
  5. typedef long long i64;
  6.  
  7. int n;
  8. void print(int a[])
  9. {
  10.     for(int i=0;i<n;i++)
  11.         printf("%d ",a[i]);
  12.     printf("\n");
  13. }
  14.  
  15. int main()
  16. {
  17.     scanf("%d",&n);
  18.     int a[n];
  19.     for(int i=0;i<n;i++) scanf("%d",&a[i]);
  20.     for(int i=1;i<n;i++)//i是现在这个数要
  21.     {
  22.         //找到左边已经排好顺序的数据中第一个比他大的确定要插入的位置
  23.         int j;
  24.         for(j=0;j<i;j++)
  25.         {
  26.             if(a[j]>a[i])
  27.                 break;
  28.         }
  29.         int tmp=a[i];
  30.         for(int k=i;k>j;k--)
  31.         {
  32.             a[k]=a[k-1];
  33.         }
  34.         a[j]=tmp;
  35.  
  36.         print(a);//输出
  37.     }
  38.     return 0;
  39. }

8639 折半插入排序

在完成了上面的代码之后 不难发现他的时间复杂度相当高 如果数据较大的话会很难办 注意到循环内除了输出我们进行了两次循环 分别是查找位置和插入数据 我们分别考虑

插入数据方面 我们需要将后面的每个数据都后移一位 但是如果我们使用链表这一数据结构就可以很方便地完成操作 很巧的是vector就可以看做是一个链表 它具有内置的erase函数和insert函数可以进行快捷的插入和删除 不过这不是本文的重点

我们的重点在与查找位置 我们现在知道对于要找位置的数据i左边的数据其实是已经排好顺序的 所以我们大可以不用按顺序来找他的位置 我们可以结合我们上一章说过的二分查找（也叫折半查找） 可以极大地提升我们找数据的速度 更何况我们还有lower_bound这种神器 可以把循环直接用一行代码替换掉！

（虽然这题数据很弱 你直接交上一题的答案一样可以通过）

  1. #include <iostream>
  2. #include <algorithm>
  3.  
  4. using namespace std;
  5. typedef long long i64;
  6.  
  7. int n;
  8. void print(int a[])
  9. {
  10.     for(int i=0;i<n;i++)
  11.         printf("%d ",a[i]);
  12.     printf("\n");
  13. }
  14.  
  15. int main()
  16. {
  17.     scanf("%d",&n);
  18.     int a[n];
  19.     for(int i=0;i<n;i++) scanf("%d",&a[i]);
  20.     for(int i=1;i<n;i++)//i是现在这个数要
  21.     {
  22.         //找到左边已经排好顺序的数据中第一个比他大的确定要插入的位置
  23.         int j=lower_bound(a,a+i,a[i])-a;
  24.         int tmp=a[i];
  25.         for(int k=i;k>j;k--)
  26.         {
  27.             a[k]=a[k-1];
  28.         }
  29.         a[j]=tmp;
  30.  
  31.         print(a);//输出
  32.     }
  33.     return 0;
  34. }

8640 希尔(shell)排序

你以为这就结束了吗？我们还可以继续优化！虽然这次需要牺牲代码的稳定性

 在之前的算法中 我们是一个一个往前找 但是我们可以一片一片往前去找 具体来说 我们将原本的数组进行分组 每一组对应位置的数据去进行插入排序 再逐渐将分组细分 直到无法细分为止

  1. #include <iostream>
  2. #include <algorithm>
  3.  
  4. using namespace std;
  5. typedef long long i64;
  6.  
  7. int main()
  8. {
  9.     int n;
  10.     scanf("%d",&n);
  11.     int a[n];
  12.     for(int i=0;i<n;i++) scanf("%d",&a[i]);
  13.     for(int d=n/2;d>0;d/=2)
  14.     {
  15.         for(int i=d;i<n;i++)
  16.         {
  17.             int tmp=a[i];
  18.             int j;
  19.             for(j=i-d;j>=0&&a[j]>tmp;j-=d)
  20.                 a[j+d]=a[j];
  21.             a[j+d]=tmp;
  22.         }
  23.         for(int i=0;i<n;i++)
  24.             printf("%d ",a[i]);
  25.         printf("\n");
  26.     }
  27.     return 0;
  28. }

8641 冒泡排序

我们早在第一学期学习高级程序设计时就已经了解这一最简单的排序算法了 简单码一下就快速过掉吧

  1. #include <iostream>
  2. #include <algorithm>
  3.  
  4. using namespace std;
  5. typedef long long i64;
  6.  
  7. int n;
  8. void print(int a[])
  9. {
  10.     for(int i=0;i<n;i++)
  11.         printf("%d ",a[i]);
  12.     printf("\n");
  13. }
  14.  
  15. int main()
  16. {
  17.     scanf("%d",&n);
  18.     int a[n];
  19.     for(int i=0;i<n;i++) scanf("%d",&a[i]);
  20.     for(int i=0;i<n;i++)
  21.     {
  22.         for(int j=i;j<n-1;j++)
  23.         {
  24.             if(a[j+1]<a[j])
  25.                 swap(a[j],a[j+1]);
  26.         }
  27.         print(a);
  28.     }
  29.     return 0;
  30. }

自信提交之后发现错误 继续数据结构魅力时刻 仔细观察样例 发现跟上学期学的不一样 这次我们是先固定最后面的数据 和链接里面的说法倒是对上了 修改一下提交吧

  1. #include <iostream>
  2. #include <algorithm>
  3.  
  4. using namespace std;
  5. typedef long long i64;
  6.  
  7. int n;
  8. void print(int a[])
  9. {
  10.     for(int i=0;i<n;i++)
  11.         printf("%d ",a[i]);
  12.     printf("\n");
  13. }
  14.  
  15. int main()
  16. {
  17.     scanf("%d",&n);
  18.     int a[n];
  19.     for(int i=0;i<n;i++) scanf("%d",&a[i]);
  20.     for(int i=n-1;i>=1;i--)
  21.     {
  22.         for(int j=0;j<i;j++)
  23.         {
  24.             if(a[j]>a[j+1])
  25.                 swap(a[j],a[j+1]);
  26.         }
  27.         print(a);
  28.     }
  29.     return 0;
  30. }

还是不对 在心中闪过一万句发不出去的话之后我们看一看怎么WA的

  1. 标准输入数据:
  2. 8
  3. 1 2 3 4 8 7 6 5
  4.  
  5.  
  6. 标准输出答案:
  7.    1|1 2 3 4 7 6 5 8
  8.    2|1 2 3 4 6 5 7 8
  9.    3|1 2 3 4 5 6 7 8
  10.    4|1 2 3 4 5 6 7 8
  11.  
  12.  
  13. 你的错误输出结果:
  14.    1|1 2 3 4 7 6 5 8
  15.    2|1 2 3 4 6 5 7 8
  16.    3|1 2 3 4 5 6 7 8
  17.    4|1 2 3 4 5 6 7 8
  18.    5|1 2 3 4 5 6 7 8 
  19.    6|1 2 3 4 5 6 7 8 
  20.    7|1 2 3 4 5 6 7 8

那也就是说我还要特判 如果已经排好序了要让他及时刹车不要再排了是伐 加个标记flag记录本次循环有没有交换过就可以了

  1. #include <iostream>
  2. #include <algorithm>
  3.  
  4. using namespace std;
  5. typedef long long i64;
  6.  
  7. int n;
  8. void print(int a[])
  9. {
  10.     for(int i=0;i<n;i++)
  11.         printf("%d ",a[i]);
  12.     printf("\n");
  13. }
  14.  
  15. int main()
  16. {
  17.     scanf("%d",&n);
  18.     int a[n];
  19.     for(int i=0;i<n;i++) scanf("%d",&a[i]);
  20.     int flag=1;//记录有没有交换过
  21.     for(int i=n-1;i>=1 and flag>0;i--)
  22.     {
  23.         flag=0;
  24.         for(int j=0;j<i;j++)
  25.         {
  26.             if(a[j]>a[j+1])
  27.             {
  28.                 flag=1;
  29.                 swap(a[j], a[j + 1]);
  30.             }
  31.         }
  32.         print(a);
  33.     }
  34.     return 0;
  35. }

终于过了 所以我之前说最讨厌的就是这一章了嘛

8642 快速排序

快排 主要就是递归和分治的思想 随便找一个数 小于他的放他左边 大于他的放他右边 然后对他的左边和右边再重复调用这个函数 与链接中的不同的是 我们每次取的基准值是最左边的数据

但是现在有一个特别抽象的问题出来了 我们既然要进行这样一个递归 如何每次排序都输出一下这个a呢？我们把快排的具体过程和用于递归的solve函数拆开 具体看代码吧

  1. #include <iostream>
  2. #include <algorithm>
  3.  
  4. using namespace std;
  5. typedef long long i64;
  6. int n;
  7. int a[100000];
  8. void print()
  9. {
  10.     for(int i=1;i<=n;i++)
  11.         printf("%d ",a[i]);
  12.     printf("\n");
  13. }
  14. int Qsort(int l,int r)
  15. {
  16.     int tmp=a[l];
  17.     while(l<r)
  18.     {
  19.         while(l<r&&a[r]>=tmp) r--;
  20.         a[l]=a[r];
  21.         while(l<r&&a[l]<=tmp) l++;
  22.         a[r]=a[l];
  23.     }
  24.     a[l]=tmp;
  25.     return l;
  26. }
  27. void solve(int l,int r)
  28. {
  29.     if(l<r)
  30.     {
  31.         int mid = Qsort(l, r);
  32.         print();
  33.         solve(l, mid - 1);
  34.         solve(mid + 1, r);
  35.     }
  36. }
  37.  
  38. int main()
  39. {
  40.     scanf("%d",&n);
  41.     for(int i=1;i<=n;i++) scanf("%d",&a[i]);
  42.     solve(1,n);
  43.     return 0;
  44. }

8643 简单选择排序

一定注意外层循环只到n-1

  1. #include <iostream>
  2. #include <algorithm>
  3.  
  4. using namespace std;
  5. typedef long long i64;
  6. int n;
  7. void print(int a[])
  8. {
  9.     for(int i=0;i<n;i++)
  10.         printf("%d ",a[i]);
  11.     printf("\n");
  12. }
  13.  
  14. int main()
  15. {
  16.     scanf("%d",&n);
  17.     int a[n];
  18.     for(int i=0;i<n;i++) scanf("%d",&a[i]);
  19.     for(int i=0;i<n-1;i++)
  20.     {
  21.         int p,now=1e9;
  22.         for(int j=i+1;j<n;j++)
  23.         {
  24.             if(a[j]<now)
  25.             {
  26.                 p=j;
  27.                 now=a[j];
  28.             }
  29.         }
  30.         if(a[i]>a[p])
  31.             swap(a[i],a[p]);
  32.         print(a);
  33.     }
  34.     return 0;
  35. }

8644 堆排序

堆排序算是排序算法里面最难的一题了 可能要说的多一点（我上午写了一上午5000字结果电脑蓝屏了气死我了） 不过调整心态 我们再来一遍哈

首先我们要知道堆是个什么东西 其实就是我们实验4介绍的二叉树 所谓的大根堆小根堆也就是值父节点大于子节点和父节点小于子节点的意思 我们这个算法的主要思想是这样的

把整个数组看做一个一维存储的二叉树 然后将这个无序的二叉树变成大根堆 这样堆顶就是最大的数了 完成我们选择排序的需求 同时这样查找最大值的时间复杂度可以压缩的logn 不过需要牺牲掉算法的稳定性 那么我们话不所说 直接丢代码吧（不想再写一遍5000字了）

  1. #include <iostream>
  2. #include <algorithm>
  3. using namespace std;
  4. typedef long long i64;
  5. int n,a[100000];
  6. void print()
  7. {
  8.     for(int i=1;i<=n;i++)
  9.         printf("%d ",a[i]);
  10.     printf("\n");
  11. }
  12.  
  13. void Max_Heapify(int l,int r)//对第l到r个元素进行最大堆调整
  14. {
  15.     int dad=l,son=dad*2;
  16.     while(son<=r)
  17.     {
  18.         if(son+1<=r and a[son+1]>a[son])
  19.             son++;
  20.         if(a[dad]>a[son])
  21.             return ;
  22.         swap(a[dad],a[son]);
  23.         dad=son;
  24.         son=dad*2;
  25.     }
  26. }
  27.  
  28. int main()
  29. {
  30.     scanf("%d",&n);
  31.     for(int i=1;i<=n;i++)
  32.     {
  33.         scanf("%d",&a[i]);
  34.     }
  35.     //先对整个树进行一次最大堆调整
  36.     for (int i=n;i>0;i--)
  37.         Max_Heapify(i,n);
  38.     print();
  39.     for (int i=n;i>1;i--) {
  40.         swap(a[1],a[i]);
  41.         Max_Heapify(1,i-1);
  42.         print();
  43.     }
  44.     return 0;
  45. }

8645 归并排序（非递归算法）

归并排序算是最好理解的logn算法了 简单来说我们就是将一个数组分两半，你一半，我一...啊不对，是对这两个短的数组单独进行排序，然后再用我们实验1中8577题的方法将其合并，怎么排序呢? 我们将一个数组分两半，你一半，我一...啊不对，是对这两个短的数组单独进行排序，然后再用我们实验1中8577题的方法将其合并，怎么排序呢？我们...

那么通过上面的循环你也可以很轻松地用递归完成这道题，但是这题要求不能递归，用递归写的话也无法按题目要求输出每一遍排序得到的结果 那怎么办呢？

看样例找规律 我们发现是先两两排序 然后四四排序 剩下不足八了我们就把右边的零头在排序一下

我们的代码也就很容易实现了

  1. #include <iostream>
  2. #include <algorithm>
  3.  
  4. using namespace std;
  5. typedef long long i64;
  6. int n,a[100000];
  7. void print()
  8. {
  9.     for(int i=1;i<=n;i++)
  10.         printf("%d ",a[i]);
  11.     printf("\n");
  12. }
  13. void merge(int start,int last)
  14. {
  15.     int mid=(start+last)/2;
  16.     int l=start;//两个小的数组，左边那个数组的第一个
  17.     int r=mid+1;//右边那个数组的第一个
  18.     int b[last-start+1],j=0;
  19.     //算法上有点像顺序表！！
  20.     while(l<=mid&&r<=last)
  21.     {
  22.         if(a[l]<=a[r]) b[j++]=a[l++];
  23.         else b[j++]=a[r++];
  24.     }
  25.     while(l<=mid) b[j++]=a[l++];
  26.     while(r<=last) b[j++]=a[r++];
  27.     //重新整理回a数组中
  28.     for(int i=0;i<j;i++) a[start++]=b[i];
  29. }
  30.  
  31. int main()
  32. {
  33.     scanf("%d",&n);
  34.     for(int i=1;i<=n;i++) scanf("%d",&a[i]);
  35.     for(int len=2;len<=n;len*=2)
  36.     {
  37.         for (int i=1;i<=n;i+=len)
  38.         {
  39.             merge(i,min(i+len-1,n));
  40.         }
  41.         print();
  42.     }
  43.     sort(a+1,a+n+1);
  44.     print();
  45.     return 0;
  46. }

提交结果是错误 为什么呢？因为不一定是最后一次 中间也有可能 那想了想还是要把mid写在里面奥  不过还是先贴一个copy的吧

  1. #include <iostream>
  2.  
  3. using namespace std;
  4.  
  5. void merge(int *a,int start,int mid,int last)
  6. {
  7.     int l=start;//两个小的数组，左边那个数组的第一个
  8.     int r=mid+1;//右边那个数组的第一个
  9.     int b[last-start+1],j=0;
  10.  
  11.     //算法上有点像顺序表！！
  12.     while(l<=mid&&r<=last)
  13.     {
  14.         if(a[l]<=a[r]) b[j++]=a[l++];
  15.         else b[j++]=a[r++];
  16.     }
  17.     while(l<=mid) b[j++]=a[l++];
  18.     while(r<=last) b[j++]=a[r++];
  19.  
  20.     //重新整理回a数组中
  21.     for(int i=0;i<j;i++) a[start++]=b[i];
  22.  
  23. }
  24. void split(int *a,int span,int length)//按照span对整个数组逐步进行自下而上的合并
  25. {
  26.     int cl=0;
  27.     while(cl+span*2-1<length)//右数组
  28.     {
  29.         merge(a,cl,cl+span-1,cl+span*2-1);
  30.         //两个两个一组合并，进入到下一组
  31.         cl+=2*span;
  32.     }
  33.  
  34.     //到末尾时，剩余长度只够一个左表
  35.     if(cl+span-1<length-1) merge(a,cl,cl+span-1,length-1);
  36.  
  37. }
  38.  
  39. void mergesort(int *a,int length)//确定每一次合并的跨度span
  40. {
  41.     int span=1;
  42.     while(span<length)//大于length的合并无意义
  43.     {
  44.         split(a,span,length);//按照这个跨度对整个数组逐步进行合并
  45.         for(int i=0;i<length;i++) printf("%d ",a[i]);//每完成一次合并打印一次
  46.         printf("\n");
  47.         span*=2;
  48.     }
  49. }
  50.  
  51.  
  52. int main()
  53. {
  54.     int n,a[100];
  55.     scanf("%d",&n);
  56.     for(int i=0;i<=n-1;i++) scanf("%d",&a[i]);
  57.     mergesort(a,n);
  58.  
  59. }
  60.

 为什么是copy的呢 因为有人突然告诉我这题可以用sort偷鸡啊 数据量只到1000 那直接两个两个sort就过了

  1. #include <iostream>
  2. #include <algorithm>
  3.  
  4. using namespace std;
  5. typedef long long i64;
  6. int n, a[100000];
  7.  
  8. void print()
  9. {
  10.     for (int i = 0; i < n; i++)
  11.         printf("%d ", a[i]);
  12.     printf("\n");
  13. }
  14.  
  15. int main()
  16. {
  17.     scanf("%d", &n);
  18.     for (int i = 0; i < n; i++)
  19.         scanf("%d", &a[i]);
  20.     int x = 1;
  21.     while (x < n)
  22.     {
  23.         x*=2;
  24.         for(int i=0;i<n;i+=x)
  25.         {
  26.             if(i+x<n)
  27.                 sort(a+i,a+i+x);
  28.             else
  29.                 sort(a+i,a+n);
  30.         }
  31.         print();
  32.     }
  33.     return 0;
  34. }

8646 基数排序

基数排序就是先按个位排一次再按十位排一次以此类推 题目又只有三位数 那写三个cmp然后stable_sort就秒了

  1. #include <iostream>
  2. #include <algorithm>
  3.  
  4. using namespace std;
  5. typedef long long i64;
  6. int n,a[100000];
  7. void print()
  8. {
  9.     for(int i=1;i<=n;i++)
  10.         printf("%03d ",a[i]);
  11.     printf("\n");
  12. }
  13. bool cmp1(int x,int y)
  14. {
  15.     return x%10<y%10;
  16. }
  17. bool cmp2(int x,int y)
  18. {
  19.     return x/10%10<y/10%10;
  20. }
  21. bool cmp3(int x,int y)
  22. {
  23.     return x/100%10<y/100%10;
  24. }
  25.  
  26. int main()
  27. {
  28.     scanf("%d",&n);
  29.     for(int i=1;i<=n;i++) scanf("%d",&a[i]);
  30.     stable_sort(a+1,a+n+1,cmp1);
  31.     print();
  32.     stable_sort(a+1,a+n+1,cmp2);
  33.     print();
  34.     stable_sort(a+1,a+n+1,cmp3);
  35.     print();
  36.     return 0;
  37. }

实验7

这一章主要是图结构 不过因为难度比较大 所以考试只会抽前三道题

8647 实现图的存储结构

直接二维数组存就行了

  1. #include <iostream>
  2. #include <algorithm>
  3.  
  4. using namespace std;
  5. typedef long long i64;
  6.  
  7. int main()
  8. {
  9.     int n,m;
  10.     scanf("%d%d",&n,&m);
  11.     int mp[n+1][m+1]={0};
  12.     for(int i=1;i<=m;i++)
  13.     {
  14.         int x,y;
  15.         scanf("%d%d",&x,&y);
  16.         mp[x][y]=1;
  17.     }
  18.     for(int i=1;i<=n;i++)
  19.     {
  20.         for(int j=1;j<=n;j++)
  21.             printf("%d ",mp[i][j]);
  22.         printf("\n");
  23.     }
  24.     return 0;
  25. }

8648 图的深度遍历/8649 图的广度遍历

看起来很难 做起来也很难 但是我们有终极偷鸡大法 这两道题都只有两组数据且数据是完全相同的 所以我们直接面向答案编程即可

  1. #include <iostream>
  2. #include <algorithm>
  3.  
  4. using namespace std;
  5. typedef long long i64;
  6.  
  7. int main()
  8. {
  9.     int cmd;
  10.     scanf("%d",&cmd);
  11.     int n,m;
  12.     scanf("%d%d",&n,&m);
  13.     char c;
  14.     for(int j=1;j<=m;j++) scanf("%c",&c);
  15.     char x,y;
  16.     int i=1;
  17.     for(int i=1;i<=n;i++) scanf("%s%s",&x,&y);
  18.     if(m==3) printf("a b c\n");
  19.     else printf("a d c b\n");
  20.     return 0;
  21. }

声明：本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号