给出N个非负整数，要用它们构建一棵完全二叉树排序树。输出这棵完全二叉排序树的层序遍历序列。

最新推荐文章于 2023-09-16 23:26:30 发布
最新推荐文章于 2023-09-16 23:26:30 发布
阅读量551 收藏
点赞数
分类专栏： 算法系列 文章标签： 算法 c++ 蓝桥杯
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Protinx/article/details/126916681
版权

给出N个非负整数，要用它们构建一棵完全二叉树排序树。输出这棵完全
二叉排序树的层序遍历序列。




#include<cstdio>
#include<algorithm>
using namespace std;
const int maxn=1010;
int n,number[maxn],CBT[maxn],index=0;
void inOrder(int root){
    if(root>n)return;
    inOrder(root*2);
    CBT[root]=number[index++];
    inOrder(root*2+1);
}
int main(){
    scanf("%d",&n);
    for(int i=0;i<n;i++){
        scanf("%d",&number[i]);
    }
    sort(number,number+n);
    inOrder(1);
    for(int i=1;i<=n;i++){
        printf("%d",CBT[i]);
        if(i<n)printf(" ");
    }
    return 0;
}

二叉树有N个结点，给出每个结点的左右孩子结点的编号。接着给出一个
N个整数的序列，需要把这N个整数填入二叉树的结点中，使得二叉树成为
一棵二叉查找树。



#include<cstdio>
#include<queue>
#include<algorithm>
using namespace std;
const int maxn=110;
struct node
{
    int data;
    int lchild,rchild;
}Node[maxn];
int n,in[maxn],num=0;
void inOrder(int root){
    if(root==-1){
        return;
    }
    inOrder(Node[root].lchild);
    Node[root].data=in[num++];
    inOrder(Node[root].rchild);
}
void BFS(int root){
    queue<int>q;
    q.push(root);
    num=0;
    while(!q.empty()){
        int now=q.front();
        q.pop();
        printf("%d",Node[now].data);
        num++;
        if(num<n)printf(" ");
        if(Node[now].lchild!=-1)q.push(Node[now].lchild);
        if(Node[now].rchild!=-1)q.push(Node[now].rchild);
    }
}
int main(){
    int lchild,rchild;
    scanf("%d",&n);
    for(int i=0;i<n;i++){
        scanf("%d%d",&lchild,&rchild);
        Node[i].lchild=lchild;
        Node[i].rchild=rchild;
    }
    for(int i=0;i<n;i++){
        scanf("%d",&in[i]);
    }
    sort(in,in+n);
    inOrder(0);
    BFS(0);
    return 0;
}

给出N个正整数，将它们依次插入一棵初始为空的AVL树上，求插入后根结点
的值。



#include<cstdio>
#include<algorithm>
using namespace std;
struct node{
    int v,height;
    node *lchild,*rchild;
}*root;
node*newNode(int v){
    node *Node=new node;
    Node->v=v;
    Node->height=1;
    Node->lchild=Node->rchild=NULL;
    return Node;
}
int getHeight(node*root){
    if(root==NULL)return 0;
    return root->height;
}
void updateHeight(node*root){
    root->height=max(getHeight(root->lchild),getHeight(root->rchild))+1;
}
int getBalanceFactor(node*root){
    return getHeight(root->lchild)-getHeight(root->rchild);
}
void L(node*&root){
    node*temp=root->rchild;
    root->rchild=temp->lchild;
    temp->lchild=root;
    updateHeight(root);
    updateHeight(temp);
    root=temp;
}
void R(node*&root){
    node*temp=root->lchild;
    root->lchild=temp->rchild;
    temp->rchild=root;
    updateHeight(root);
    updateHeight(temp);
    root=temp;
}
void insert(node *&root,int v){
    if(root==NULL){
        root=newNode(v);
        return;
    }
    if(v<root->v){
        insert(root->lchild,  v);
        updateHeight(root);
        if(getBalanceFactor(root)==2){
            if(getBalanceFactor(root->lchild)==1){
                R(root);
            }else if(getBalanceFactor(root->lchild)==-1){
                L(root->lchild);
                R(root);
            }
        }
    }else{
        insert(root->rchild,  v);
        updateHeight(root);
        if(getBalanceFactor(root)==-2){
            if(getBalanceFactor(root->rchild)==-1){
                L(root);
            }else if(getBalanceFactor(root->rchild)==1){
                R(root->rchild);
                L(root);
            }
        }
    }
}
node*Create(int data[],int n){
    node*root=NULL;
    for(int i=0;i<n;i++){
        insert(root, data[i]);
    }
    return root;
}
int main(){
    int n,v;
    scanf("%d",&n);
    for(int i=0;i<n;i++){
        scanf("%d",&v);
        insert(root, v);
    }
    printf("%d\n",root->v);
    return 0;
}

有N个人，每个人喜欢若干项活动，如果两个人有任意一个活动相同，那么就称它们处于同一个社交网络，求这N个人总共形成了多少个社交网络。

#include<cstdio>
#include<algorithm>
using namespace std;
const int N=1010;
int father[N];
int isRoot[N]={0};
int course[N]={0};
int findFather(int x){
    int a=x;
    while(x!=father[x]){
        x=father[x];
    }
    while(a!=father[a]){
        int z=a;
        a=father[a];
        father[z]=x;
    }
    return x;
}
void Union(int a,int b){
    int faA=findFather(a);
    int faB=findFather(b);
    if(faA!=faB){
        father[faA]=faB;
    }
}
void init(int n){
    for(int i=1;i<=n;i++){
        father[i]=i;
        isRoot[i]=false;
    }
}
bool cmp(int a,int b){
    return a>b;
}
int main(){
    int n,k,h;
    scanf("%d",&n);
    init(n);
    for(int i=1;i<=n;i++){
        scanf("%d",&k);
        for(int j=0;j<k;j++){
            scanf("%d",&h);
            if(course[h]==0){
                course[h]=i;
            }
            Union(i,findFather(course[h]));
        }
    }
    for(int i=1;i<=n;i++){
        isRoot[findFather(i)]++;
    }
    int ans=0;
    for(int i=1;i<=n;i++){
       if(isRoot[i]!=0){
        ans++;
       } 
    }
    printf("%d\n",ans);
    sort(isRoot+1,isRoot+n+1,cmp);
    for(int i=1;i<=ans;i++){
        printf("%d",isRoot[i]);
        if(i<ans)printf(" ");
    }
    return 0;
}

给出一个初始序列，可以对它使用插入排序或堆排序法进行排序。现给出一个序列，
试判断它是由插入排序还是堆排序产生的，并输出下一步将会产生的序列。


#include<cstdio>
#include<algorithm>
using namespace std;
const int N=111;
int origin[N],tempOri[N],changed[N];
int n;
bool isSame(int A[],int B[]){
    for(int i=1;i<=n;i++){
        if(A[i]!=B[i])return false;
    }
    return true;
}
bool showArray(int A[]){
    for(int i=1;i<=n;i++){
        printf("%d",A[i]);
        if(i<n)printf(" ");
}
printf("\n");
}
bool insertSort(){
    bool flag=false;
    for(int i=2;i<=n;i++){
        if(i!=2&&isSame(tempOri,changed )){
            flag=true;
        }
        sort(tempOri,tempOri+i+1);
        if(flag==true){
            return true;
        }
    }
    return false;
}
void downAdjust(int low,int high){
    int i=low,j=i*2;
    while(j<=high){
        if(j+1<=high&&tempOri[j+1]>tempOri[j]){
            j=j+1;
        }
        if(tempOri[j]>tempOri[i]){
            swap(tempOri[j],tempOri[i]);
            i=j;
            j=i*2;
        }else{
            break;
        }
    }
}
void heapSort(){
    bool flag=false;
    for(int i=n/2;i>=1;i--){
        downAdjust(i, n);
    }
    for(int i=n;i>1;i--){
        if(i!=n&&isSame(tempOri,changed))
        {
            flag=true;
        }
        swap(tempOri[i],tempOri[1]);
        downAdjust(1, i-1);
        if(flag==true){
            showArray(tempOri);
            return;
        }
    }
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<n;i++){
        scanf("%d",&origin[i]);
        tempOri[i]=origin[i];
    }
    for(int i=1;i<=n;i++){
        scanf("%d",&changed);
    }
    if(insertSort()){
        printf("Insertion Sort\n");
        showArray(tempOri);
    }
    else {
    printf("Heap Sort\n");
    for(int i=1;i<=n;i++){
        tempOri[i]=origin[i];
    }
    heapSort();
    }
    return 0;
}


输入树的结点个数N(结点编号为1~N)、非叶子结点个数M，然后输入M个
非叶子结点各自的孩子结点编号，求结点个数最多的一层(层号是从整体来看的，根结点层号为1)，
输出该层的结点个数以及层号。
#include <cstdio>
#include <vector>
using namespace std;
const int MAXN = 110;
vector<int> Node[MAXN];
int hashTable[MAXN] = {0};
void DFS(int index, int level) {
  hashTable[level]++;
  for (int j = 0; j < Node[index].size(); j++) {
    DFS(Node[index][j], level + 1);
  }
}
int main() {
  int n, m, parent, k, child;
  scanf("%d%d", &n, &m);
  for (int i = 0; i < m; i++) {
    scanf("%d%d", &parent, &k);
    for (int j = 0; j < k; j++) {
      scanf("%d", &child);
      Node[parent].push_back(child);
    }
  }
  DFS(1, 1);
  int maxLevel = -1, maxValue = 0;
  for (int i = 1; i < MAXN; i++) {
    if (hashTable[i] > maxValue) {
      maxValue = hashTable[i];
      maxLevel = i;
    }
  }
  printf("%d %d\n", maxValue, maxLevel);
  return 0;
}

给出一棵销售供应的树，树根唯一，在树根处货物的价格为P，然后从根结点
开始每往子结点走一层，该层的货物价格将会在父结点的价格上增加r%，求
叶子结点处能获得的最低价格以及能提供最低价格的叶子结点的个数
#include<cstdio>
#include<cmath>
#include<vector>
using namespace std;
const int maxn=100010;
const double INF=1e12;
vector<int>Node[maxn];
int n,num=0;
double p,r,ans=INF;
void DFS(int index,int depth){
    if(Node[index].size()==0){
        double price=p*pow(1+r,depth);
        if(price<ans){
            ans=price;
            num=1;
        }else if(price==ans){
            num++;
        }
        return;
    }
    for(int i=0;i<Node[index].size();i++){
        DFS(Node[index][i],depth+1);
    }
}
int main(){
    int k,child;
    scanf("%d%lf%lf",&n,&p,&r);
    r/=100;
    for(int i=0;i<n;i++){
        scanf("%d",&k);
        if(k!=0){
            for(int j=0;j<k;j++){
                scanf("%d",&child);
                Node[i].push_back(child);
            }
        }
    }
    DFS(0,0);
    printf("%.4f %d\n",ans,num);
    return 0;
}

给出一棵树，问每一层各有多少叶子结点。
DFS版
#include <algorithm>
#include <cstdio>
#include <iostream>
#include <stdio.h>
#include <vector>

using namespace std;
const int N = 110;
vector<int> G[N];
int leaf[N] = {0};
int max_h = 1;
void DFS(int index, int h) {
  max_h = max(h, max_h);
  if (G[index].size() == 0) {
    leaf[h]++;
    return;
  }
  for (int i = 0; i < G[index].size(); i++) {
    DFS(G[index][i], h + 1);
  }
}
int main() {
  int n, m, parent, child, k;
  scanf("%d%d", &n, &m);
  for (int i = 0; i < m; i++) {
    scanf("%d%d", &parent, &k);
    for (int j = 0; j < k; j++) {
      scanf("%d", &child);
      G[parent].push_back(child);
    }
  }
  DFS(1, 1);
  printf("%d", leaf[1]);
  for (int i = 2; i <= max_h; i++)
  printf("%d",leaf[i]);
  return 0;
}
BFS版
#include <cstdio>
#include <queue>
#include <vector>
using namespace std;
const int N = 105;
vector<int>G[N];
int h[N]={0};
int leaf[N]={0};
int max_h=0;
void BFS(){
queue<int>Q;
Q.push(1);
while(!Q.empty()){
    int id=Q.front();
    Q.pop();
    max_h=max(max_h,h[id]);
    if(G[id].size()==0){
        leaf[h[id]]++;
    }
    for(int i=0;i<G[id].size();i++){
        h[G[id][i]]=h[id]+1;
        Q.push(G[id][i]);
    }
}
}
int main(){
    int m,n;
    scanf("%d%d",&m,&n);
    for(int i=0;i<m;i++){
        int parent,k,child;
        scanf("%d%d",&parent,&k);
        for(int j=0;j<k;j++){
            scanf("%d",&child);
            G[parent].push_back(child);
        }
    }
    h[1]=1;
    BFS();
    for(int i=1;i<=max_h;i++){
        if(i==1)printf("%d",leaf[i]);
        else printf("%d",leaf[i]);
    }
    return 0;
}

给定一棵树和每个结点的权值，求所有从根结点到叶子结点的路径，使得每条路径上结点的权值之和等于给定的常数S。
如果有多条这样的路径，按路径非递增的顺序输出。
#include<cstdio>
#include<vector>
#include<algorithm>
using namespace std;
const int MAXN=110;
struct node{
    int weight;
    vector<int>child;
}Node[MAXN];
bool cmp(int a,int b){
    return Node[a].weight>Node[b].weight;
}
int n,m,S;
int path[MAXN];
void DFS(int index,int numNode,int sum){
    if(sum>S)return;
    if(sum==S){
        if(Node[index].child.size()!=0)return;
        for(int i=0;i<numNode;i++){
            printf("%d",Node[path[i]].weight);
            if(i<numNode-1)printf(" ");
            else printf("\n");
        }
        return;
    }
    for(int i=0;i<Node[index].child.size();i++){
        int child=Node[index].child[i];
        path[numNode]=child;
        DFS(child,numNode+1,sum+Node[child].weight);}
}
int main(){
    scanf("%d%d%d",&n,&m,&S);
    for(int i=0;i<n;i++){
        scanf("%d",&Node[i].weight);
    }
    int id,k,child;
    for(int i=0;i<m;i++){
        scanf("%d%d",&id,&k);
        for(int j=0;j<k;j++){
            scanf("%d",&child);
            Node[id].child.push_back(child);
        }
        sort(Node[id].child.begin(),Node[id].child.end(),cmp);
    }
    path[0]=0;
    DFS(0,1,Node[0].weight);
    return 0;
}


用栈来模拟一棵二叉树的先序和中序遍历过程，求这棵二叉树的后序遍历序列
#include<cstdio>
#include<cstring>
#include<stack>
#include<algorithm>
using namespace std;
const int maxn=50;
struct node {
    int data;
    node*lchild;
    node*rchild;
};
int pre[maxn],in[maxn],post[maxn];
int n;
node* create(int preL,int preR,int inL,int inR){
    if(preL>preR){
        return NULL;
    }
    node*root=new node;
    root->data=pre[preL];
    int k;
    for(k=inL;k<=inR;k++){
        if(in[k]==pre[preL]){
            break;
        }
    }
    int numLeft=k-inL;
    root->lchild=create(preL+1,preL+numLeft,inL,k-1);
    root->rchild=create(preL+numLeft+1,preR,k+1,inR);
    return root;
}
int num=0;
void postorder(node*root){
    if(root==NULL){
        return;
    }
    postorder(root->lchild);
    postorder(root->rchild);
    printf("%d",root->data);
    num++;
    if(num<n)printf(" ");
}
int main(){
    scanf("%d",&n);
    char str[5];
    stack<int>st;
    int x,preIndex=0,inIndex=0;
    for(int i=0;i<2*n;i++){
        scanf("%s",str);
        if(strcmp(str,"push")==0){
            scanf("%d",&x);
            pre[preIndex++]=x;
            st.push(x);
        }else{
            in[inIndex++]=st.top();
            st.pop();
        }
    }
    node*root=create(0,n-1,0,n-1);
    postorder(root);
    return 0;
}

二叉树有N个结点，给出每个结点的左右孩子结点的编号，把该二叉树反转
，输出反转后二叉树的层序遍历序列和中序遍历序列。
#include <algorithm>
#include <cstdio>
#include<queue>
using namespace std;
const int maxn = 110;
struct node {
  int lchild, rchild;
} Node[maxn];
bool notRoot[maxn] = {false};
int n, num = 0;
void print(int id) {
  printf("%d", id);
  num++;
  if (num < n)
    printf(" ");
  else
    printf("\n");
}
void inOrder(int root) {
  if (root == -1) {
    return;
  }
  inOrder(Node[root].lchild);
  print(root);
  inOrder(Node[root].rchild);
}
void BFS(int root) {
  queue<int> q;
  q.push(root);
  while (!q.empty()) {
    int now = q.front();
    q.pop();
    print(now);
    if (Node[now].lchild != -1)
      q.push(Node[now].lchild);
    if (Node[now].rchild != -1)q.push(Node[now].rchild);
  }
}
void postOrder(int root){
    if(root==-1){
        return;
    }
    postOrder(Node[root].lchild);
    postOrder(Node[root].rchild);
    swap(Node[root].lchild,Node[root].rchild);
}
int strToNum(char c){
    if(c=='-')return -1;
    else{
        notRoot[c-'0']=true;
        return c-'0';
    }
}
int findRoot(){
    for(int i=0;i<n;i++){
        if(notRoot[i]==false){
            return i;
        }
    }
}
int main(){
    char lchild,rchild;
    scanf("%d",&n);
    for(int i=0;i<n;i++){
        scanf("%*c%c %c",&lchild,&rchild);
        Node[i].lchild=strToNum(lchild);
        Node[i].rchild=strToNum(rchild);
    }
    int root=findRoot();
    postOrder(root);
    BFS(root);
    num=0;
    inOrder(root);
    return 0;
}

给出一棵销售供应的树，树根唯一，在树根处货物的价格为P，然后从根结点
开始每往子结点走一层，该层的货物价格将会在父结点的价格上增加r%，
给出每个叶结点的货物量，求它们的价格之和。
#include <cmath>
#include <cstdio>
#include <vector>

using namespace std;
const int maxn = 100010;
struct node {
  double data;
  vector<int> child;
} Node[maxn];
int n;
double p, r, ans = 0;
void DFS(int index, int depth) {
  if (Node[index].child.size() == 0) {
    ans += Node[index].data * pow(1 + r, depth);
    return;
  }
  for (int i = 0; i < Node[index].child.size(); i++) {
    DFS(Node[index].child[i], depth + 1);
  }
}
int main() {
  int k, child;
  scanf("%d%lf%lf", &n, &p, &r);
  r /= 100;
  for (int i = 0; i < n; i++) {
    scanf("%d", &k);
    if (k == 0) {
      scanf("%lf", &Node[i].data);
    } else {
      for (int j = 0; j < k; j++) {
        scanf("%d", &child);
        Node[i].child.push_back(child);
      }
    }
  }
  DFS(0, 0);
  printf("%.lf\n", p * ans);
  return 0;
}

给出一棵销售供应的树，树根唯一，在树根处货物的价格为P，然后从根结点
开始每往子结点走一层，该层的货物价格将会在父结点的价格上增加r%，
求所有叶结点中的最高价格以及这个价格的叶结点个数。
#include<cstdio>
#include<cmath>
#include<vector>
using namespace std;
const int maxn=100010;
vector<int>child[maxn];
double p,r;
int n,maxDepth=0,num=0;
void DFS(int index,int depth){
    if(child[index].size()==0){
        if(depth>maxDepth){
            maxDepth=depth;
            num=1;
        }else if(depth==maxDepth){
            num++;
        }
        return;
    }
    for(int i=0;i<child[index].size();i++){
        DFS(child[index][i],depth+1);
    }
}
int main(){
    int father,root;
    scanf("%d%lf%lf",&n,&p,&r);
    r/=100;
    for(int i=0;i<n;i++){
        scanf("%d",&father);
        if(father!=-1){
            child[father].push_back(i);
        }else{
            root=i;
        }
        DFS(root,0);
        printf("%.2f %d\n",p*pow(1+r,maxDepth),num);
        return 0;
    }
}


给出一棵二叉树的后序遍历序列和中序序列，求这棵二叉树的层序遍历序列。
#include<cstdio>
#include<cstring>
#include<queue>
#include<algorithm>
using namespace std;
const int maxn=50;
struct node 
{
    int data;
    node*lchild;
    node*rchild;
};
int pre[maxn],in[maxn],post[maxn];
int n;
node*create(int postL,int postR,int inL,int inR){
    if(postL>postR){
    return NULL;
}
node*root=new node;
root->data=post[postR];
int k;
for(k=inL;k<=inR;k++){
    if(in[k]==post[postR]){
        break;
    }
}
int numLeft=k-inL;
root->lchild=create(postL,postL+numLeft-1,inL,k-1);
root->rchild=create(postL+numLeft,postR-1,k+1,inR);
return root;
}
int num=0;
void BFS(node*root){
    queue<node*>q;
    q.push(root);
    while(!q.empty()){
        node*now=q.front();
        q.pop();
        printf("%d",now->data);
        num++;
        if(num<n)printf(" ");
        if(now->lchild!=NULL)q.push(now->lchild);
        if(now->rchild!=NULL)q.push(now->rchild);
    }
}
int main(){
    scanf("%d",&n);
    for(int i=0;i<n;i++){
        scanf("%d", &post[i]);
    }
    for(int i=0;i<n;i++){
        scanf("%d",&in[i]);
    }
    node*root=create(0,n-1,0,n-1);
    BFS(root);
    return 0;
}

/*实现九九乘法表
for(var j=1;j<=9;j++){
    for(var i=1;i<=j;i++){
        document.write(i+'*'+j+'='+i*j+' ')
    }
    document.write("</br>")
}*/
/*求最大公约数
var max=34
var min=17
for(var i=min;i>=1;i--){
    if(max%i===0&min%i===0)
    document.write(i)
    break
}

最小公倍数

var max = 15
    var min = 10

    // 从相对小的数字向 1 进行循环
    for (var i = max; i <= min * max; i += max) {
      // 只要能整除 相对小的数字 就可以
      if (i % min === 0) {
        document.write( i )
        // 可以直接结束循环了
        break
      }
    }
*/
/*function f(n){
    var t=1
    while(n>=1){
        t*=n
        n--
    }
    document.write(t)
}
f(10)
 
function f(n){
  if   (n==1||n==2)return 1
 return f(n-1)*f(n-2);
}*/
//冒泡排序
var arr=[9,5,4,7,8,3,1,2,6]
document.write(arr)
document.write("</br>")
for(var j=0;j<arr.length-1;j++){
    for(var i=0;i<arr.length-1-j;i++){
        if(arr[i]>arr[i+1]){
            var temp=arr[i]
            arr[i]=arr[i+1]
            arr[i+1]=temp
        }
    }
}
document.write(arr)


//选择排序
var arr=[9,2,5,8,3,7,4,1,6]
document.write(arr)
document.write("</br>")
for(var j=0;j<arr.length-1;j++){
    var minIndex=j;
    for(var i=j+1;i<arr.length;i++){
        if(arr[i]<arr[minIndex]){
            minIndex=i;
        }
    }
    var temp=arr[j]
    arr[j]=arr[minIndex]
    arr[minIndex]=temp
}
document.write(arr)

//跟着鼠标移动
<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta
        http-equiv="X-UA-Compatible"
        content="IE=edge"
    >
    <meta
        name="viewport"
        content="width=device-width, initial-scale=1.0"
    >
    <title>Document</title>
    <style>
        img {
            width: 48px;
            height: 48px;
            position: fixed;
            left: 0;
            top: 0;
        }
    </style>
</head>

<body>

    <script>
        var imgBox = document.querySelector('img')
        document.onmousemove = function (e) {
            var x = e.clientX
            var y = e.clientY
            imgBox.style.left = x + 5 + 'px'
            imgBox.style.top = y + 5 + 'px'

        }
    </script>
    <img
        src="./新学期课表.jpg"
        alt=""
    >
</body>

</html>


<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta
        name="viewport"
        content="width=device-width, initial-scale=1.0"
    >
    <meta
        http-equiv="X-UA-Compatible"
        content="ie=edge"
    >
    <title>Document</title>
    <style>
        * {
            margin: 0;
            padding: 0;

        }

        body {
            background-color: skyblue;
        }

        ul,
        ol,
        li {
            list-style: none;
        }

        .tab {
            width: 600px;
            height: 400px;
            border: 10px solid yellow;
            margin: 50px auto;
            display: flex;
            flex-direction: column;
        }

        ul {
            height: 60px;
            display: flex;
        }

        ul>li {
            flex: 1;
            display: flex;
            justify-content: center;
            align-items: center;
            font-size: 40px;
            color: #fff;
            background-color: skyblue;
            cursor: pointer;
        }

        ul>li.active {
            background-color: orange;
        }

        ol {
            flex: 1;
            position: relative;
        }

        ol>li {
            position: absolute;
            left: 0;
            top: 0;
            width: 100%;
            height: 100%;
            font-size: 100px;
            color: #fff;
            background-color: beige;
            display: none;
            justify-content: center;
            align-items: center;
        }

        ol>li.active {
            display: flex;
        }
    </style>
</head>

<body>

    <div class="tab">
        <ul>
            <li class="active">1</li>
            <li>2</li>
            <li>3</li>
        </ul>
        <ol>
            <li class="active">1</li>
            <li>2</li>
            <li>3</li>
        </ol>
    </div>


    <script>
        /*
          简单版面向对象选项卡
    
          1. 抽象内容
            + 一个能够完成选项卡的对象, 需要有哪些属性和方法
            + 属性: 所有可以点击的按钮盒子
            + 属性: 所有可以切换的选项盒子
            + 方法: 能添加点击事件的方法
          2. 书写构造函数
            + 能创建一个对象, 包含两个属性和一个方法
            + 属性直接写在构造函数体内
            + 方法写在构造函数的原型上
        */

        // 2. 书写构造函数
        function Tabs(ele) {
            // 范围
            this.ele = document.querySelector(ele)
            // 在范围内找到所有可以点击的盒子
            this.btns = this.ele.querySelectorAll('ul > li')
            // 在范围内找到所有需要切换显示的盒子
            this.tabs = this.ele.querySelectorAll('ol > li')
        }

        // 原型上书写方法
        Tabs.prototype.change = function () {
            // 执行给所有 btns 里面的 按钮添加点击事件
            // 我怎么拿到 btns
            // 绝对不能直接使用 t 这个变量
            // console.log(this.btns)

            // 提前保存一下 this
            var _this = this

            for (var i = 0; i < this.btns.length; i++) {
                // 提前保存索引
                this.btns[i].setAttribute('index', i)

                this.btns[i].addEventListener('click', function () {
                    // console.log('我被点击了')
                    // 需要让实例的 btns 里面的每一个没有 active 类名
                    // 需要让实例的 tabs 里面的每一个没有 active 类名
                    // 这里不是在 change 函数的作用域了, 而是事件处理函数的作用域
                    // 在事件处理函数里面, this 指向当前事件的事件源
                    // console.log(_this)
                    // 当你访问 _this 的时候, 其实是在访问变量
                    // 自己作用域没有, 就会去上一级作用域查找
                    for (var j = 0; j < _this.btns.length; j++) {
                        _this.btns[j].className = ''
                        _this.tabs[j].className = ''
                    }

                    // 当前点击的这个 li 有 active 类名
                    this.className = 'active'
                    // 让 实例身上的 tabs 里面索引对应的哪一个 li 有 active 类名
                    // 拿到当前 li 身上保存的 索引
                    var index = this.getAttribute('index') - 0
                    _this.tabs[index].className = 'active'
                })
            }
        }

        // 使用的时候
        // 选项卡就可以使用了
        var t = new Tabs('.tab')
        // 实例对象在调用方法
        // 函数调用方式, 对象.函数名()
        // 函数内部的 this 就是指向 点 前面的 xxx
        // 我在 change 函数里面写的 this 就是 t
        t.change()


    </script>
</body>

</html>


深度优先搜索和广度优先搜索编程例题详解
DFS
#include <algorithm>
#include <cstdio>
#include <vector>

using namespace std;
int n, k, p, maxFacSum = -1;
vector<int> fac, ans, temp;
int power(int x) {
  int ans = 1;
  for (int i = 0; i < p; i++) {
    ans *= x;
  }
  return ans;
}
void init() {
  int i = 0, temp = 0;
  while (temp <= n) {
    fac.push_back(temp);
    temp = power(++i);
  }
}
void DFS(int index, int nowK, int sum, int facSum) {
  if (sum == n && nowK == k) {
    if (facSum > maxFacSum) {
      ans = temp;
      maxFacSum = facSum;
    }
    return;
  }
  if (sum > n || nowK > k)
    return;
  if (index - 1 >= 0) {
    temp.push_back(index);
    DFS(index, nowK + 1, sum + fac[index], facSum + index);
    temp.pop_back();
    DFS(index - 1, nowK, sum, facSum);
  }
}
int main() {
  scanf("%d%d%d", &n, &k, &p);
  init();
  DFS(fac.size() - 1, 0, 0, 0);
  if (maxFacSum == -1)
    printf("Impossible\n");
  else {
    printf("%d=%d^%d", n, ans[0], p);
    for (int i = 1; i < ans.size(); i++) {
      printf("+%d^%d", ans[i], p);
    }
  }
  return 0;
}

BFS

#include <cstdio>
#include <queue>
using namespace std;
struct node {
  int x, y, z;
} Node;
int n, m, slice, T;
int pixel[1290][130][61];
bool inq[1290][130][61] = {false};
int X[6] = {0, 0, 0, 0, 1, -1};
int Y[6] = {0, 0, 1, -1, 0, 0};
int Z[6] = {1, -1, 0, 0, 0, 0};
bool judge(int x, int y, int z) {
  if (x >= n || x < 0 || y >= m || y < 0 || z >= slice || z < 0)
    return false;
  if (pixel[x][y][z] == 0 || inq[x][y][z] == true)
    return false;
  return true;
}
int BFS(int x, int y, int z) {
  int tot = 0;
  queue<node> Q;
  Node.x = x, Node.y = y, Node.z = z;
  Q.push(Node);
  inq[x][y][z] = true;
  while (!Q.empty()) {
    node top = Q.front();
    Q.pop();
    tot++;
    for (int i = 0; i < 6; i++) {
      int newX = top.x + X[i];
      int newY = top.y + Y[i];
      int newZ = top.z + Z[i];
      if (judge(newX, newY, newZ)) {
        Node.x = newX, Node.y = newY, Node.z = newZ;
        Q.push(Node);
        inq[newX][newY][newZ] = true;
      }
    }
  }
  if (tot >= T)
    return tot;
  else
    return 0;
}
int main() {
  scanf("%d%d%d%d", &n, &m, &slice, &T);
  for (int z = 0; z < slice; z++) {
    for (int x = 0; x < n; x++) {
      for (int y = 0; y < m; y++) {
        scanf("%d", &pixel[x][y][z]);
      }
    }
  }
  int ans = 0;
  for (int z = 0; z < slice; z++) {
    for (int x = 0; x < n; x++) {
      for (int y = 0; y < m; y++) {
        if (pixel[x][y][z] == 1 && inq[x][y][z] == false) {
          ans += BFS(x, y, z);
        }
      }
    }
  }
  printf("%d\n", ans);
  return 0;
}

给出N个结点的地址address、数据域data及指针域next，然后给出链表的首地址，
要求去除权值相同的结点之后把在这个链表上的结点按data值从小到大输出。
#include <algorithm>
#include <cstdio>
#include <cstring>
using namespace std;
const int maxn = 100005;
const int TABLE = 1000010;
struct Node {
  int address, data, next;
  int order;
} node[maxn];
bool isExist[TABLE] = {false};
bool cmp(Node a, Node b) { return a.order < b.order; }
int main() {
  memset(isExist, false, sizeof(isExist));
  for (int i = 0; i < maxn; i++) {
    node[i].order = 2 * maxn;
  }
  int n, begin, address;
  scanf("%d%d", &begin, &n);
  for (int i = 0; i < n; i++) {
    scanf("%d", &address);
    scanf("%d%d", &node[address].data, &node[address].next);
    node[address].address = address;
  }
  int countValid = 0, countRemoved = 0, p = begin;
  while (p != -1) {
    if (!isExist[abs(node[p].data)]) {
      isExist[abs(node[p].data)] = true;
      node[p].order = countValid++;
    } else {
      node[p].order = maxn + countRemoved++;
    }
    p = node[p].next;
  }
  sort(node, node + maxn, cmp);
  int count = countValid + countRemoved;
  for (int i = 0; i < count; i++) {
    if (i != countValid - 1 && i != count - 1) {
      printf("%05d %d %05d\n", node[i].address, node[i].data,
             node[i + 1].address);
    } else {
      printf("%05d %d -1\n", node[i].address, node[i].data);
    }
  }
  return 0;
}

给出N个结点的地址address、数据域data及指针域next，然后给出链表的首地址，要求把在这个链表上的结点按data值从小到大输出。
#include <algorithm>
#include <cstdio>

using namespace std;
const int maxn = 100005;
struct Node {
  int address, data, next;
  bool flag;
} node[maxn];
bool cmp(Node a, Node b) {
  if (a.flag == false || b.flag == false) {
    return a.flag > b.flag;
  } else {
    return a.data < b.data;
  }
}
int main() {
  for (int i = 0; i < maxn; i++) {
    node[i].flag = false;
  }
  int n, begin, address;
  scanf("%d%d", &n, &begin);
  for (int i = 0; i < n; i++) {
    scanf("%d", &address);
    scanf("%d%d", &node[address].data, &node[address].next);
    node[address].address = address;
  }
  int count = 0, p = begin;
  while (p != -1) {
    node[p].flag = true;
    count++;
    p = node[p].next;
  }
  if (count == 0) {
    printf("0 -1");
  } else {
    sort(node, node + maxn, cmp);
    printf("%d %05d\n", count, node[0].address);
    for (int i = 0; i < count; i++) {
      if (i != count - 1) {
        printf("%05d %d %05d\n", node[i].address, node[i].data,
               node[i + 1].address);
      } else {
        printf("%05d %d -1\n", node[i].address, node[i].data);
      }
    }
  }
  return 0;
}


给出两条链表的首地址以及若干个结点的地址、数据、下一个结点的地址，求
两条链表的首个共用结点的地址。
#include <cstdio>
#include <cstring>
const int maxn = 100010;
struct NODE {
  char data;
  int next;
  bool flag;
} node[maxn];
int main() {
  for (int i = 0; i < maxn; i++) {
    node[i].flag = false;
  }
  int s1, s2, n;
  scanf("%d%d%d", &s1, &s2, &n);
  int address, next;
  char data;
  for (int i = 0; i < n; i++) {
    scanf("%d %c %d", &address, &data, &next);
    node[address].data = data;
    node[address].next = next;
  }
  int p;
  for (p = s1; p != -1; p = node[p].next) {
    node[p].flag = true;
  }
  for (p = s2; p != -1; p = node[p].next) {
    if (node[p].flag == true)
      break;
  }
  if (p != -1) {
    printf("%05d\n", p);
  } else {
    printf("-1\n");
  }
  return 0;
}

给定一个常数K以及一个单链表L，请编写程序将L中每K个结点反转。
#include <algorithm>
#include <cstdio>
using namespace std;
const int maxn = 100010;
struct Node {
  int address, data, next;
  int order;
} node[maxn];
bool cmp(Node a, Node b) { return a.order < b.order; }
int main() {
  for (int i = 0; i < maxn; i++) {
    node[i].order = maxn;
  }
  int begin, n, k, address;
  scanf("%d%d%d", &begin, &n, &k);
  for (int i = 0; i < n; i++) {
    scanf("%d", &address);
    scanf("%d%d", &node[address].data, &node[address].next);
    node[address].address = address;
  }
  int p = begin, count = 0;
  while (p != -1) {
    node[p].order = count++;
    p = node[p].next;
  }
  sort(node, node + maxn, cmp);
  n = count;
  for (int i = 0; i < n / k; i++) {
    for (int j = (i + 1) * k - 1; j > i * k; j--) {
      printf("%05d %d %05d\n", node[j].address, node[j].data,
             node[j - 1].address);
    }
    printf("%05d %d", node[i * k].address, node[i * k].data);
    if (i < n / k - 1) {
      printf("%05d\n", node[(i + 2) * k - 1].address);
    } else {
      if (n % k == 0) {
        printf("-1\n");
      } else {
        printf("%05d\n", node[(i + 1) * k].address);
        for (int i = n / k * k; i < n; i++) {
          printf("%05d %d", node[i].address, node[i].data);
          if (i < n - 1) {
            printf("%05d\n", node[i + 1].address);
          } else {
            printf("-1\n");
          }
        }
      }
    }
  }
  return 0;
}

Mice and Rice
#include <cstdio>
#include <queue>
using namespace std;
const int maxn = 1010;
struct mouse {
  int weight;
  int R;
} mouse[maxn];
int main() {
  int np, ng, order;
  scanf("%d%d", &np, &ng);
  for (int i = 0; i < np; i++) {
    scanf("%d", &mouse[i].weight);
  }
  queue<int> q;
  for (int i = 0; i < np; i++) {
    scanf("%d", &order);
    q.push(order);
  }
  int temp = np, group;
  while (q.size() != 1) {
    if (temp % ng == 0)
      group = temp / ng;
    else
      group = temp / ng + 1;
    for (int i = 0; i < group; i++) {
      int k = q.front();
      for (int j = 0; j < ng; j++) {
        if (i * ng + j >= temp)
          break;
        int front = q.front();
        if (mouse[front].weight > mouse[k].weight) {
          k = front;
        }
        mouse[front].R = group + 1;
        q.pop();
      }
      q.push(k);
    }
    temp = group;
  }
  mouse[q.front()].R = 1;
  for (int i = 0; i < np; i++) {
    printf("%d", mouse[i].R);
    if (i < np - 1)
      printf(" ");
  }
  return 0;
}

令“单词”的定义为大小写字母、数字的组合，给出一个字符串，问出现次数最多的单词及其出现次数。其中字母不区分大小写，且最后按小写字母输出。
#include <iostream>
#include <map>
#include <string>
using namespace std;
bool check(char c) {
  if (c >= '0' && c <= '9')
    return true;
  if (c >= 'A' && c <= 'Z')
    return true;
  if (c >= 'a' && c <= 'z')
    return true;
  return false;
}
int main() {
  map<string, int> count;
  string str;
  getline(cin, str);
  int i = 0;
  while (i < str.length()) {
    string word;
    while (i < str.length() && check(str[i]) == true) {
      if (str[i] >= 'A' && str[i] <= 'Z') {
        str[i] += 32;
      }
      word += str[i];
      i++;
    }
    if (word != "") {
      if (count.find(word) == count.end())
        count[word] = 1;
      else
        count[word]++;
    }
    while (i < str.length() && check(str[i]) == false) {
      i++;
    }
  }
  string ans;
  int MAX = 0;
  for (map<string, int>::iterator it = count.begin(); it != count.end(); it++) {
    if (it->second > MAX) {
      MAX = it->second;
      ans = it->first;
    }
  }
  cout << ans << " " << MAX << endl;
  return 0;
}

有一个容量限制为M的栈，先分别把1，2，3，...，n依次入栈，并给出一系列出栈顺序，问这些出栈顺序是否可能。
#include <cstdio>
#include <stack>
using namespace std;
const int maxn = 1010;
int arr[maxn];
stack<int> st;
int main() {
  int m, n, T;
  scanf("%d%d%d", &m, &n, &T);
  while (T--) {
    while (!st.empty()) {
      st.pop();
    }
    for (int i = 1; i <= n; i++) {
      scanf("%d", &arr[i]);
    }
    int current = 1;
    bool flag = true;
    for (int i = 1; i <= n; i++) {
      st.push(i);
      if (st.size() > m) {
        flag = false;
        break;
      }
      while (!st.empty() && st.top() == arr[current]) {
        st.pop();
        current++;
      }
    }
    if (st.empty() == true && flag == true) {
      printf("YES\n");
    } else {
      printf("NO\n");
    }
  }
  return 0;
}

给出N本书的编号、书名、作者、关键词（可能有多个）、出版社及出版年份，
并给出M个查询，每个查询给出书名、作者、关键词（单个）、出版社及出版年份中的一个，要求输出满足该给出信息的所有书的编号。
#include<iostream>
#include<cstdio>
#include<map>
#include<set>
#include<string>
using namespace std;
map<string,set<int>>mpTitle,mpAuthor,mpKey,mpPub,mpYear;
void query(map<string,set<int>>&mp,string& str){
    if(mp.find(str)==mp.end())printf("Not Found\n");
    else{
        for(set<int>::iterator it=mp[str].begin();it!=mp[str].end();it++){
            printf("%07d\n",*it);
        }
    }
}
int main(){
    int n,m,id,type;
    string title,author,key,pub,year;
    scanf("%d",&n);
    for(int i=0;i<n;i++){
        scanf("%d",&n);
        char c=getchar();
        getline(cin,title);
        mpTitle[title].insert(id);
        getline(cin,author);
        mpAuthor[author].insert(id);
        while(cin>>key){
            mpKey[key].insert(id);
            c=getchar();
            if(c=='\n')break;
        }
        getline(cin,pub);
        mpPub[pub].insert(id);
        getline(cin,year);
        mpYear[year].insert(id);
    }
    string temp;
    scanf("%d",&m);
    for(int i=0;i<m;i++){
        scanf("%d:",&type);
        getline(cin,temp);
        cout<<type<<":"<<temp<<endl;
        if(type==1)query(mpTitle, temp);
        else if(type==2)query(mpAuthor, temp);
        else if(type==3)query(mpKey,temp);
        else if(type==4)query(mpPub,temp);
        else query(mpYear, temp);
    }
    return 0;
}


给出N行M列的数字矩阵，求其中超过半数的出现次数最多的数字
#include <cstdio>
#include <map>
using namespace std;
int main() {
  int n, m, col;
  scanf("%d%d", &n, &m);
  map<int, int> count;
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < m; j++) {
      scanf("%d", &col);
      if (count.find(col) != count.end())
        count[col]++;
      else
        count[col] = 1;
    }
  }
  int k = 0, MAx = 0;
  for (map<int, int>::iterator it = count.begin(); it != count.end(); it++) {
    if (it->second > MAx) {
      k = it->first;
      MAx = it->second;
    }
  }
  printf("%d\n", k);
  return 0;
}

//题意：给出n个分数，求分数的和。分数前面可能有负号。
//若答案为假分数，则要按照要求带分数的形式输出；整数则按整数输出；否则按真分数输出。
#include <algorithm>
#include <cstdio>
using namespace std;
typedef long long ll;
ll gcd(ll a, ll b) { return b == 0 ? a : gcd(b, a % b); }
struct Fraction {
  ll up, down;
};
Fraction reduction(Fraction result) {
  if (result.down < 0) {
    result.up = -result.up;
    result.down = -result.down;
  }
  if (result.up == 0) {
    result.down = 1;
  } else {
    int d = gcd(abs(result.up), abs(result.down));
    result.up /= d;
    result.down /= d;
  }
  return result;
}
Fraction add(Fraction f1, Fraction f2) {
  Fraction result;
  result.up = f1.up * f2.down + f2.up * f1.down;
  result.down = f1.down * f2.down;
  return reduction(result);
}
void showResult(Fraction r) {
  reduction(r);
  if (r.down == 1)
    printf("%lld\n", r.up);
  else if (abs(r.up) > r.down) {
    printf("%lld%lld/%lld\n", r.up / r.down, abs(r.up) % r.down, r.down);
  } else {
    printf("%lld/%lld\n", r.up, r.down);
  }
}
int main() {
  int n;
  scanf("%d", &n);
  Fraction sum, temp;
  sum.up = 0;
  sum.down = 1;
  for (int i = 0; i < n; i++) {
    scanf("%lld/%lld", &temp.up, &temp.down);
    sum = add(sum, temp);
  }
  showResult(sum);
  return 0;
}
//编写程序，用以计算两个有理数的和、差、积、商。
#include <algorithm>
#include <cstdio>

using namespace std;
typedef long long ll;
ll gcd(ll a, ll b) { return b == 0 ? a : gcd(b, a % b); }
struct Fraction {
  ll up, down;
} a, b;
Fraction reduction(Fraction result) {
  if (result.down < 0) {
    result.up = -result.up;
    result.down = -result.down;
  }
  if (result.up == 0) {
    result.down = 1;
  } else {
    int d = gcd(abs(result.up), abs(result.down));
    result.up /= d;
    result.down /= d;
  }
  return result;
}
Fraction add(Fraction f1, Fraction f2) {
  Fraction result;
  result.up = f1.up * f2.down + f2.up * f1.down;
  result.down = f1.down * f2.down;
  return reduction(result);
}
Fraction minu(Fraction f1, Fraction f2) {
  Fraction result;
  result.up = f1.up * f2.down - f2.up * f1.down;
  result.down = f1.down * f2.down;
  return reduction(result);
}
Fraction multi(Fraction f1, Fraction f2) {
  Fraction result;
  result.up = f1.up * f2.up;
  result.down = f1.down * f2.down;
  return reduction(result);
}
Fraction divide(Fraction f1, Fraction f2) {
  Fraction result;
  result.up = f1.up * f2.down;
  result.down = f1.down * f2.up;
  return reduction(result);
}
void showResult(Fraction r) {
  r = reduction(r);
  if (r.up < 0)
    printf("(");
  if (r.down == 1)
    printf("%lld", r.up);
  else if (abs(r.up) > r.down) {
    printf("%lld %lld/%lld", r.up / r.down, abs(r.up) % r.down, r.down);
  } else {
    printf("%lld/%lld", r.up, r.down);
  }
  if (r.up < 0)
    printf(")");
}
int main() {
  scanf("%lld/%lld %lld/%lld", &a.up, &a.down, &b.up, &b.down);
  showResult(a);
  printf("+");
  showResult(b);
  printf("=");
  showResult(add(a, b));
  printf("\n");
  showResult(a);
  printf("-");
  showResult(b);
  printf("=");
  showResult(minu(a, b));
  printf("\n");
  showResult(a);
  printf("*");
  showResult(b);
  printf("=");
  showResult(multi(a, b));
  printf("\n");
  showResult(a);
  printf("/");
  showResult(b);
  printf("=");
  if (b.up == 0)
    printf("Inf");
  else
    showResult(divide(a, b));
  return 0;
}


//求1-n内的素数对的个数
#include <cmath>
#include <cstdio>

bool isPrime(int n) {
  if (n <= 1)
    return false;
  int sqr = (int)sqrt(1.0 * n);
  for (int i = 2; i <= sqr; i++) {
    if (n % i == 0)
      return false;
  }
  return true;
}
int main() {
  int n, count = 0;
  scanf("%d", &n);
  for (int i = 3; i + 2 < n; i += 2) {
    if (isPrime(i) == true && isPrime(i + 2) == true) {
      count++;
    }
  }
  printf("%d\n", count);
  return 0;
}



//输出第m个素数至第n个素数
//暴力法
#include <math.h>
#include <stdio.h>

const int maxn = 1000001;
bool isPrime(int n) {
  if (n <= 1)
    return false;
  int sqr = (int)sqrt(1.0 * n);
  for (int i = 2; i <= sqr; i++) {
    if (n % i == 0)
      return false;
  }
  return true;
}
int prime[maxn], num = 0;
bool p[maxn] = {0};
void Find_Prime(int n) {
  for (int i = 1; i < maxn; i++) {
    if (isPrime(i) == true) {
      prime[num++] = i;
      p[i] = true;
      if (num >= n)
        break;
    }
  }
}
int main() {
  int m, n, count = 0;
  scanf("%d%d", &m, &n);
  Find_Prime(n);
  for (int i = m; i <= n; i++) {
    printf("%d", prime[i - 1]);
    count++;
    if (count % 10 != 0 && i < n)
      printf(" ");
    else
      printf("\n");
  }
  return 0;
}

//筛选法
#include <stdio.h>
const int maxn = 10000001;
int prime[maxn], num = 0;
bool p[maxn] = {0};
void Find_Prime(int n) {
  for (int i = 2; i < maxn; i++) {
    if (p[i] == false) {
      prime[num++] = i;
      if (num >= n)
        break;
      for (int j = i + i; j < maxn; j += i) {
        p[j] = true;
      }
    }
  }
}
int main() {
  int m, n, count = 0;
  scanf("%d%d", &m, &n);
  Find_Prime(n);
  for (int i = m; i <= n; i++) {
    printf("%d", prime[i - 1]);
    count++;
    if (count % 10!=0&&i<n)printf(" ");
    else
     printf("\n");
  }
  return 0;
}

给出正整数N和进制radix，如果N是素数，且N在radix进制下反转后的数在十进制下也是素数，则输出yes，否则输出no

#include <cmath>
#include <cstdio>


bool isPrime(int n) {
  if (n <= 1)
    return false;
  int sqr = (int)sqrt(1.0 * n);
  for (int i = 2; i <= sqr; i++) {
    if (n % i == 0)
      return false;
  }
  return true;
}
int d[111];
int main() {
  int n, radix;
  while (scanf("%d", &n) != EOF) {
    if (n < 0)
      break;
    scanf("%d", &radix);
    if (isPrime(n) == false) {
      printf("No\n");
    } else {
      int len = 0;
      do {
        d[len++] = n % radix;
        n /= radix;
      } while (n != 0);
      for (int i = 0; i < len; i++) {
        n = n * radix + d[i];
      }
      if (isPrime(n) == true)
        printf("Yes\n");
      else
        printf("No\n");
    }
  }
  return 0;
}


/*
给出散列表长TSize和欲插入的元素，
将这些元素按读入的顺序插入散列表中，其中散列函数为H(key)=key%TSize,
解决冲突采用只往正向增加的二次探查法*/
#include <cmath>
#include <cstdio>
#include <vector>

using namespace std;
const int N = 11111;
bool isPrime(int n) {
  if (n <= 1)
    return false;
  int sqr = (int)sqrt(1.0 * n);
  for (int i = 2; i <= sqr; i++) {
    if (n % i == 0)
      return false;
  }
  return true;
}
bool hashTable[N] = {0};
int main() {
  int n, TSize, a;
  scanf("%d%d", &TSize, &n);
  while (isPrime(TSize) == false) {
    TSize++;
  }
  for (int i = 0; i < n; i++) {
    scanf("%d", &a);
    int M = a % TSize;
    if (hashTable[M] == false) {
      hashTable[M] = true;
      if (i == 0)
        printf("%d", M);
      else
        printf("%d", M);
    } else {
      int step;
      for (step = 1; step < TSize; step++) {
        M = (a + step * step) % TSize;
        if (hashTable[M] == false) {
          hashTable[M] = true;
          if (i == 0)
            printf("%d", M);
          else
            printf("%d", M);
          break;
        }
      }
      if (step >= TSize) {
        if (i > 0)
          printf(" ");
        printf("-");
      }
    }
  }
  return 0;
}

//给出一个正整数，求一段连续的整数，使得N能被这段连续整数的乘积整除。
如果有多个方案，输出连续整数个数最多的方案；如果还有多种方案，输出其中第一个数最小的方案。
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <stdio.h>

typedef long long LL;
int main() {
  LL n;
  scanf("%lld", &n);
  LL sqr = (LL)sqrt(1.0 * n), ansI = 0, ansLen = 0;
  for (LL i = 2; i <= sqr; i++) {
    LL temp = 1, j = i;
    while (1) {
      temp *= j;
      if (n % temp != 0)
        break;

      if (j - i + 1 > ansLen) {
        ansI = i;
        ansLen = j - i + 1;
      }
      j++;
    }
  }
  if (ansLen == 0) {
    printf("1\n%lld", n);
  } else {
    printf("%lld\n", ansLen);
    for (LL i = 0; i < ansLen; i++) {
      printf("%lld", ansI + i);
      if (i < ansLen - 1) {
        printf("*");
      }
    }
  }
  return 0;
}

//给出一个int范围的整数，按照从小到大的顺序输出其分解为质因数的乘法算式
#include <cstdio>
#include <math.h>
const int maxn = 100010;
bool is_prime(int n) {
  if (n == 1)
    return false;
  int sqr = (int)sqrt(1.0 * n);
  for (int i = 2; i <= sqr; i++) {
    if (n % i == 0)
      return false;
  }
  return true;
}
int prime[maxn], pNum = 0;
void Find_Prime() {
  for (int i = 1; i < maxn; i++) {
    if (is_prime(i) == true) {
      prime[pNum++] = i;
    }
  }
}
struct factor {
  int x, cnt;
} fac[10];
int main() {
  Find_Prime();
  int n, num = 0;
  scanf("%d", &n);
  if (n == 1)
    printf("1=1");
  else {
    printf("%d=", n);
    int sqr = (int)sqrt(1.0 * n);
    for (int i = 0; i < pNum && prime[i] <= sqr; i++) {
      if (n % prime[i] == 0) {
        fac[num].x = prime[i];
        fac[num].cnt = 0;
        while (n % prime[i] == 0) {
          fac[num].cnt++;
          n /= prime[i];
        }
        num++;
      }
      if (n == 1)
        break;
    }
    if (n != 1) {
      fac[num].x = n;
      fac[num++].cnt = 1;
    }
    for (int i = 0; i < num; i++) {
      if (i > 0)
        printf("*");
      printf("%d", fac[i].x);
      if (fac[i].cnt > 1) {
        printf("%d", fac[i].cnt);
      }
    }
  }
  return 0;
}

//要求计算A/B，其中A是不超过1000位的正整数，B是1位正整数。请输出商数Q和余数R，使得A=B*Q+R成立。
#include <stdio.h>
#include <string.h>

struct bign {
  int d[1010];
  int len;
  bign() {
    memset(d, 0, sizeof(d));
    len = 0;
  }
};
bign change(char str[]) {
  bign a;
  a.len = strlen(str);
  for (int i = 0; i < a.len; i++) {
    a.d[i] = str[a.len - 1 - i] - '0';
  }
  return a;
}
bign divide(bign a, int b, int &r) {
  bign c;
  c.len = a.len;
  for (int i = a.len - 1; i >= 0; i--) {
    r = r * 10 + a.d[i];
    if (r < b)
      c.d[i] = 0;
    else {
      c.d[i] = r / b;
      r = r % b;
    }
  }
  while (c.len - 1 >= 1 && c.d[c.len - 1] == 0) {
    c.len--;
  }
  return c;
}
void print(bign a) {
  for (int i = a.len - 1; i >= 0; i--) {
    printf("%d", a.d[i]);
  }
}
int main() {
  char str1[1010], str2[1010];
  int b, r = 0;
  scanf("%s%d", str1, &b);
  bign a = change(str1);
  print(divide(a, b, r));
  printf("%d", r);
  return 0;
}

//给出一个长度不超过20的整数，问这个整数两倍后的数位是否为原数数位的一个排列。
#include <stdio.h>
#include <string.h>


struct bign {
  int d[21];
  int len;
  bign() {
    memset(d, 0, sizeof(d));
    len = 0;
  }
};
bign change(char str[]) {
  bign a;
  a.len = strlen(str);
  for (int i = 0; i < a.len; i++) {
    a.d[i] = str[a.len - i - 1] - '0';
  }
  return a;
}
bign multi(bign a, int b) {
  bign c;
  int carry = 0;
  for (int i = 0; i < a.len; i++) {
    int temp = a.d[i] * b + carry;
    c.d[c.len++] = temp % 10;
    carry = temp / 10;
  }
  while (carry != 0) {
    c.d[c.len++] = carry % 10;
    carry /= 10;
  }
  return c;
}
bool Judge(bign a, bign b) {
  if (a.len != b.len)
    return false;
  int count[10] = {0};
  for (int i = 0; i < a.len; i++) {
    count[a.d[i]]++;
    count[b.d[i]]--;
  }
  for (int i = 0; i < 10; i++) {
    if (count[i] != 0) {
      return false;
    }
  }
  return true;
}
void print(bign a) {
  for (int i = a.len - 1; i >= 0; i--) {
    printf("%d", a.d[i]);
  }
}
int main() {
  char str[21];
  gets(str);
  bign a = change(str);
  bign mul = multi(a, 2);
  if (Judge(a, mul) == true)
    printf("Yes\n");
  else
    printf("No\n");
  print(mul);
  return 0;
}

//定义一种操作：让一个整数加上这个整数首尾颠倒后的数字。问是否能在有限次数内得到回文数
#include <algorithm>
#include <stdio.h>
#include <string.h>

using namespace std;
struct bign {
  int d[1000];
  int len;
  bign() {
    memset(d, 0, sizeof(d));
    len = 0;
  }
};
bign change(char str[]) {
  bign a;
  a.len = strlen(str);
  for (int i = 0; i < a.len; i++) {
    a.d[i] = str[a.len - i - 1] - '0';
  }
  return a;
}
bign add(bign a, bign b) {
  bign c;
  int carry = 0;
  for (int i = 0; i < a.len || i < b.len; i++) {
    int temp = a.d[i] + b.d[i] + carry;
    c.d[c.len++] = temp % 10;
    carry = temp / 10;
  }
  if (carry != 0) {
    c.d[c.len++] = carry;
  }
  return c;
}
bool Judge(bign a) {
  for (int i = 0; i <= a.len / 2; i++) {
    if (a.d[i] != a.d[a.len - 1 - i]) {
      return false;
    }
  }
  return true;
}
void print(bign a) {
  for (int i = a.len - 1; i >= 0; i--) {
    printf("%d", a.d[i]);
  }
  printf("\n");
}
int main() {
  char str[1000];
  int T, k = 0;
  scanf("%s %d", str, &T);
  bign a = change(str);
  while (k < T && Judge(a) == false) {
    bign b = a;
    reverse(b.d, b.d + b.len);
    a = add(a, b);
    k++;
  }
  print(a);
  printf("%d\n", k);
  return 0;
}
有N个学生，K门课程，现在给出选择每门课程达到学生姓名，
并在之后给出N个学生的姓名，要求按顺序给出每个学生的选课情况
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <stdio.h>
#include <vector>

using namespace std;
const int N = 40010;
const int M = 26 * 26 * 26 * 10 + 1;
vector<int> selectCourse[M];
int getID(char name[]) {
  int id = 0;
  for (int i = 0; i < 3; i++) {
    id = id * 26 + (name[i] - 'A');
  }
  id = id * 10 + (name[3] - '0');
  return id;
}
int main() {
  char name[5];
  int n, k;
  scanf("%d%d", &n, &k);
  for (int i = 0; i < k; i++) {
    int course, x;
    scanf("%d%d", &course, &x);
    for (int j = 0; j < x; j++) {
      scanf("%s", name);
      int id = getID(name);
      selectCourse[id].push_back(course);
    }
  }
  for (int i = 0; i < n; i++) {
    scanf("%s", name);
    int id = getID(name);
    sort(selectCourse[id].begin(), selectCourse[id].end());
    printf("%s %d", name, selectCourse[id].size());
    for (int j = 0; j < selectCourse[id].size(); j++) {
      printf("%d", selectCourse[id][j]);
    }
    printf("\n");
  }
  return 0;
}
给出选课人数和课程数目，然后再给出每个人的选课情况，
请针对每门课程输出选课人数以及所有选该课的学生的姓名
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <stdio.h>
#include <vector>

using namespace std;
const int maxn = 40010;
const int maxc = 2510;
char name[maxn][5];
vector<int> course[maxc];
bool cmp(int a, int b) { return strcmp(name[a], name[b]) < 0; }
int main() {
  int n, k, c, courseID;
  scanf("%d%d", &n, &k);
  for (int i = 0; i < n; i++) {
    scanf("%s %d", name[i], &c);
    for (int j = 0; j < c; j++) {
      scanf("%d", &courseID);
      course[courseID].push_back(i);
    }
  }
  for (int i = 1; i <= k; i++) {
    printf("%d %d\n", i, course[i].size());
    sort(course[i].begin(), course[i].end(), cmp);
    for (int j = 0; j < course[i].size(); j++) {
      printf("%s\n", name[course[i][j]]);
    }
  }
  return 0;
}
给出N个集合，给出的集合中可能含有相同的值。然后要求M个查询，
    每个查询给出两个集合的编号X和Y，求集合X和集合Y的相同元素率，即两个集合的交集与并集（均需去重）的元素个数的比率。
#include <cstdio>
#include <set>

    using namespace std;
const int N = 51;
set<int> st[N];
void compare(int x, int y) {
  int totalNum = st[y].size(), sameNum = 0;
  for (set<int>::iterator it = st[x].begin(); it != st[x].end(); it++) {
    if (st[y].find(*it) != st[y].end())
      sameNum++;
    else
      totalNum++;
  }
  printf("%.lf%\n", sameNum * 100.0 / totalNum);
}
int main() {
  int n, k, q, v, st1, st2;
  scanf("%d", &n);
  for (int i = 1; i <= n; i++) {
    scanf("%d", &k);
    for (int j = 0; j < k; j++) {
      scanf("%d", &v);
      st[i].insert(v);
    }
  }
  scanf("%d", &q);
  for (int i = 0; i < q; i++) {
    scanf("%d%d", &st1, &st2);
    compare(st1, st2);
  }
  return 0;
}
给出两个数，问将它们写成保留N位小数的科学计数法后是否相等。
如果相等，则输出“YES"，并给出该转换结果；如果不相等，则输出"NO"，并分别给出两个数的转换结果。
#include<iostream>
#include<string>
using namespace std;
int n;;
string deal(string s,int& e){
    int k=0;
    while(s.length()>0&&s[0]=='0'){
        s.erase(s.begin());
    }
    if(s[0]=='.'){
        s.erase(s.begin());
        while(s.length()>0&&s[0]=='0'){
            s.erase(s.begin());
            e--;
        }
    }else{
        while(k<s.length()&&s[k]!='.'){
            k++;
            e++;
        }
        if(k<s.length()){
            s.erase(s.begin()+k);
        }
    }
    if(s.length()==0){
        e=0;
    }
    int num=0;
    k=0;
    string res;
    while(num<n){
        if(k<s.length())res+=s[k++];
        else res+='0';
        num++;
    }
    return res;
}
int main(){
    string s1,s2,s3,s4;
    cin>>n>>s1>>s2;
    int e1=0,e2=0;
    s3=deal(s1,e1);
    s4=deal(s2,e2);
    if(s3==s4&&e1==e2){
      cout << "YES 0." << s3 << "*10^" << e1 << endl;
    }else{
         cout<<"NO 0."<<s3<<"*10^"<<e1<<"0."<<s4<<"*10^"<<e2<<endl;
    }
    return 0;
}

二叉查找树(二叉排序树)的详细实现
Touch_2011的专栏
09-28 6万+
1、序      详细实现了二叉查找树的各种操作：插入结点、构造二叉树、删除结点、查找、  查找最大值、查找最小值、查找指定结点的前驱和后继 2、二叉查找树简介      它或者是一棵空树；或者是具有下列性质的二叉树： （1）若左子树不空，则左子树上所有结点的值均小于它的根
数据结构与算法题目及C++解答
热门推荐
Ankang的博客
06-03 1万+
前言 题目主要按照类型进行整理，包括leetcode，nowcoder等网站，对于可以使用多种方法的题目，不重复列举。推荐书籍《数据结构与算法分析--C++语言描述》第四版。 本文中所有源代码及博客中其他文章的VS源代码均在github：https://github.com/AnkangH，根据名称检索即可。 1.排序算法 SortAlgorithm 排序算法的源码见博客内排序算法的文章。...
构造二叉排序树
01-01
用java语言来构造二叉排序树，理解java数据结构。
二叉排序树的基本操作
Qianzshuo的博客
10-22 1464
题目描述 二叉排序树或者是一棵空树，或者是具有以下几条性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根节点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根节点的值； 它的左右子树也分别为二叉排序树。 二叉排序树又可以被称为二叉查找树，根据上述定义的结构不难知道，它的查找过程十分简单，只需要通过不断的将当前结点的值与需要查找的值进行比较，如果相等则直接输出，如果要查找的值更小则深入至左子树进行比较，否则就深入右子树进行比较，直到找到相应的值或者
数据结构与算法：二叉排序树
最新发布
学习中
09-16 613
数据结构与算法：二叉排序树
【数据结构与算法】二叉排序树构造与遍历
A91A981E的博客
03-20 2927
【问题描述】 从标准输入中读入n个数值元素,请将它们用二叉排序树存储,并输出该二叉排序树的层次和中序序列. 【输入形式】 首先输入一个整数n表示元素个数,然后再依次输入n个元素的值,每个元素之间用空格分割.例如: 8 50 35 70 40 50 65 20 80 说明:表明有8个元素,分别为50,35,70,40,50,65,20,和80. 【输出形式】 输出形式为两行,第一行为二叉排序树的层次数,第二行为二叉排序树的中序序列. 【样例输入】 10 50 30 80 10 90 95 70
构造唯一完全二叉搜索树的层序遍历序列
题目中提到，给定一个由不同非负整数键值组成的序列，可以唯一构造出一棵既符合二叉搜索树（BST）又符合完全二叉树（CBT）的树结构。这是基于二叉搜索树的性质和完全二叉树的定义，通过排列这些整数以满足上述两个...
深入探讨二叉树：排序、遍历与哈希查找技术
1. 升序序列：利用二叉排序树的中序遍历即可生成升序序列。 2. 降序序列：需要修改中序遍历的顺序，通常通过中序遍历的递归函数进行左右子树的处理顺序对调来实现。 ### 程序填空说明 根据提供的描述，需要修改`...
《剑指Offer》Java代码（高清带目录） (1).pdf
02-02
32. 从1到非负整数n中1出现的次数：涉及数学计算和递归。 33. 把数组中的数排成一个最小的数：考察字符串的排序以及自定义比较规则。 34. 求第N个丑数：涉及动态规划以及最小堆的实现。 35. 第一个出现一次的字符...
牛客 剑指offer_编程题 详细题解 （已完结）
weixin_44211980的博客
01-31 4700
文章目录剑指offer_编程题【1.二维数组中的查找】【2.替换空格】C++JAVA【3.从尾到头打印链表】【4.重建二叉树】【5.用两个栈实现队列】【6.旋转数组的最小数字】暴力Sort二分法【7.斐波那契数列】【8.跳台阶】【9.变态跳台阶】 剑指offer_编程题 【1.二维数组中的查找】 【题目描述】 在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都...
数据结构实验之查找一：二叉排序树
qq_43345339的博客
12-05 269
Problem Description 对应给定的一个序列可以唯一确定一棵二叉排序树。然而，一棵给定的二叉排序树却可以由多种不同的序列得到。例如分别按照序列{3,1,4}和{3,4,1}插入初始为空的二叉排序树，都得到一样的结果。你的任务书对于输入的各种序列，判断它们是否能生成一样的二叉排序树。 Input 输入包含若干组测试数据。每组数据的第1行给出两个正整数N (n < =...
数据结构-二叉排序树的操作与实现
m0_61789994的博客
06-01 2486
二叉排序树（Binary Search Tree，简称BST）是一种二叉树，它满足以下条件：1. 左子树上所有节点的值均小于它的根节点的值；2. 右子树上所有节点的值均大于它的根节点的值；3. 左右子树也分别为二叉排序树。二叉排序树的定义可以用递归的方式描述，即一个二叉树是二叉排序树，当且仅当它的左子树是二叉排序树，右子树是二叉排序树，并且左子树中所有节点的值都小于根节点的值，右子树中所有节点的值都大于根节点的值。二叉排序树是一种常见的数据结构，可以用于排序、查找和数据统计等操作。
二叉排序树
Fiverya的博客
03-27 1651
设计算法，将n个数据组成二叉排序树结构，并可以删除其中的一个结点。 输入：数据个数n、n个数据、需要删除的数值value。 输出：原始数据、二叉排序树的中序输出及删除结点value后的结果。 #include<iostream> using namespace std; template <class T> struct BTNode{ ...
给出N个正整数来作为一棵二叉排序树的结点插入顺序，问这串序列是否是该二叉排序树的先序序列或是该二叉排序树的镜像树的先序序列。
Protinx的博客
09-18 226
给出N个正整数来作为一棵二叉排序树的结点插入顺序，问这串序列是否是该二叉排序树的先序序或是该二叉排序树的镜像树的先序序列。
PAT A1064 Complete Binary Search Tree （***构建完全二叉排序树）
jiangjiangjiang6的博客
03-07 229
问题链接：https://pintia.cn/problem-sets/994805342720868352/problems/994805407749357568 题意： 给出N个非负整数，要用它们构建一颗完全二叉排序树。输出这棵完全二叉排序树的层序遍历序列。 思路： 如果使用数组来存放完全二叉树，那么对完全二叉树当中的任何一个结点（设编号为x，根节点编号为1），其左孩子结点的编号为2...
输入一串整数，构造其对应的二叉排序树，并在其上删除任意一个值等于用户输入值的结点。
qq_47991812的博客
11-21 1517
输入一串整数，构造其对应的二叉排序树，并在其上删除任意一个值等于用户输入值的结点。
将序列{4, 5, 8, 2, 1, 3, 6}中的整数依次插入一棵空的平衡二叉树中，要求依 次画出插入各整数后得到的平衡二叉树。...
weixin_35749440的博客
02-12 310
平衡二叉树是一种特殊的二叉搜索树，它的每一个节点的左右子树的高度差不超过 1。因此，插入整数时需要注意保持平衡。 插入整数 4，可以得到如下图所示的平衡二叉树：4 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

超翔之逸

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值