
```sql

-- 创建评论表
CREATE TABLE b_comment (
  id bigint PRIMARY KEY AUTO_INCREMENT, -- 评论唯一标识，自增
  content varchar(255), -- 评论内容
  commentTime datetime, -- 评论时间
  likeCount int, -- 点赞数
  userId BIGINT, -- 用户唯一标识
  thingId bigint, -- 商品唯一标识
  FOREIGN KEY (userId) REFERENCES b_user(id), -- 外键关联用户表
  FOREIGN KEY (thingId) REFERENCES b_thing(id) -- 外键关联商品表
);

-- 创建用户表
CREATE TABLE b_user (
  id BIGINT PRIMARY KEY AUTO_INCREMENT, -- 用户唯一标识，自增
  username varchar(255), -- 用户名
  password varchar(255), -- 密码
  nickname varchar(255), -- 昵称
  mobile varchar(255), -- 手机号
  email varchar(255), -- 电子邮件
  description varchar(255), -- 用户描述
  role varchar(255), -- 用户角色
  status varchar(255), -- 用户状态
  score decimal(10, 2), -- 积分
  avatar varchar(255), -- 头像
  token varchar(255), -- 用户令牌
  createTime datetime, -- 用户创建时间
  pushEmail varchar(255), -- 推送电子邮件
  pushSwitch varchar(255) -- 推送开关
);

-- 创建商品表
CREATE TABLE b_thing (
  id bigint PRIMARY KEY AUTO_INCREMENT, -- 商品唯一标识，自增
  title varchar(255), -- 商品标题
  nickname varchar(255), -- 商品昵称
  sex varchar(255), -- 商品性别
  address varchar(255), -- 商品地址
  cover varchar(255), -- 商品封面图片
  description varchar(255), -- 商品描述
  price decimal(10, 2), -- 商品价格
  status varchar(255), -- 商品状态
  createTime datetime, -- 商品创建时间
  score decimal(10, 2), -- 商品评分
  pv int, -- 商品浏览量
  recommendCount int, -- 推荐次数
  wishCount int, -- 收藏次数
  collectCount int, -- 收藏次数
  classificationId bigint, -- 分类唯一标识
  FOREIGN KEY (classificationId) REFERENCES b_classification(id) -- 外键关联分类表
);

-- 创建分类表
CREATE TABLE b_classification (
  id bigint PRIMARY KEY AUTO_INCREMENT, -- 分类唯一标识，自增
  title varchar(255), -- 分类标题
  createTime datetime -- 分类创建时间
);

-- 创建收藏商品表
CREATE TABLE b_thing_collect (
  id bigint PRIMARY KEY AUTO_INCREMENT, -- 收藏唯一标识，自增
  thingId bigint, -- 商品唯一标识
  userId BIGINT, -- 用户唯一标识
  FOREIGN KEY (thingId) REFERENCES b_thing(id), -- 外键关联商品表
  FOREIGN KEY (userId) REFERENCES b_user(id) -- 外键关联用户表
);

-- 创建商品标签表
CREATE TABLE b_thing_tag (
  id bigint PRIMARY KEY AUTO_INCREMENT, -- 商品标签唯一标识，自增
  thingId bigint, -- 商品唯一标识
  tagId bigint, -- 标签唯一标识
  FOREIGN KEY (thingId) REFERENCES b_thing(id), -- 外键关联商品表
  FOREIGN KEY (tagId) REFERENCES b_tag(id) -- 外键关联标签表
);

-- 创建用户心愿表
CREATE TABLE b_thing_wish (
  id bigint PRIMARY KEY AUTO_INCREMENT, -- 用户心愿唯一标识，自增
  thingId bigint, -- 商品唯一标识
  userId BIGINT, -- 用户唯一标识
  FOREIGN KEY (thingId) REFERENCES b_thing(id), -- 外键关联商品表
  FOREIGN KEY (userId) REFERENCES b_user(id) -- 外键关联用户表
);

/*
-- 创建广告表
CREATE TABLE b_ad (
  id bigint PRIMARY KEY AUTO_INCREMENT, -- 广告唯一标识，自增
  image varchar(255), -- 广告图片
  link varchar(255), -- 广告链接
  createTime datetime -- 广告创建时间
);

 */

-- 创建地址表
CREATE TABLE b_address (
  id bigint PRIMARY KEY AUTO_INCREMENT, -- 地址唯一标识，自增
  name varchar(255), -- 姓名
  mobile varchar(255), -- 手机号
  description varchar(255), -- 地址描述
  def varchar(255), -- 是否默认地址
  createTime datetime, -- 地址创建时间
  userId BIGINT, -- 用户唯一标识
  FOREIGN KEY (userId) REFERENCES b_user(id) -- 外键关联用户表
);

/*
-- 创建横幅表
CREATE TABLE b_banner (
  id bigint PRIMARY KEY AUTO_INCREMENT, -- 横幅唯一标识，自增
  image varchar(255), -- 横幅图片
  thingId bigint, -- 商品唯一标识
  createTime datetime, -- 横幅创建时间
  FOREIGN KEY (thingId) REFERENCES b_thing(id) -- 外键关联商品表
);

 */



-- 创建错误日志表
CREATE TABLE b_error_log (
  id bigint PRIMARY KEY AUTO_INCREMENT, -- 错误日志唯一标识，自增
  ip varchar(255), -- IP地址
  url varchar(255), -- URL
  method varchar(255), -- 请求方法
  content varchar(255), -- 错误内容
  logTime datetime -- 错误日志时间
);


-- 创建通知表
CREATE TABLE b_notice (
  id bigint PRIMARY KEY AUTO_INCREMENT, -- 通知唯一标识，自增
  title varchar(255), -- 通知标题
  content varchar(255), -- 通知内容
  createTime datetime -- 通知创建时间
);

-- 创建操作日志表
CREATE TABLE b_op_log (
  id bigint PRIMARY KEY AUTO_INCREMENT, -- 操作日志唯一标识，自增
  reIp varchar(255), -- 请求IP地址
  reTime datetime, -- 请求时间
  reUa varchar(255), -- 请求User Agent
  reUrl varchar(255), -- 请求URL
  reMethod varchar(255), -- 请求方法
  reContent varchar(255), -- 请求内容
  accessTime datetime -- 访问时间
);

-- 创建订单表
CREATE TABLE b_order (
  id bigint PRIMARY KEY AUTO_INCREMENT, -- 订单唯一标识，自增
  status varchar(255), -- 订单状态
  orderTime datetime, -- 下单时间
  payTime datetime, -- 支付时间
  thingId bigint, -- 商品唯一标识
  userId BIGINT, -- 用户唯一标识
  gwc varchar(255), -- 购物车
  amount decimal(10, 2), -- 订单金额
  orderNumber varchar(255), -- 订单编号
  receiverAddress varchar(255), -- 收货地址
  receiverName varchar(255), -- 收货人姓名
  receiverPhone varchar(255), -- 收货人电话
  remark varchar(255), -- 备注
  FOREIGN KEY (thingId) REFERENCES b_thing(id), -- 外键关联商品表
  FOREIGN KEY (userId) REFERENCES b_user(id) -- 外键关联用户表
);

-- 创建标签表
CREATE TABLE b_tag (
  id bigint PRIMARY KEY AUTO_INCREMENT, -- 标签唯一标识，自增
  title varchar(255), -- 标签标题
  createTime datetime -- 标签创建时间
);

-- 创建访问数据表
CREATE TABLE visit_data (
  re_ip varchar(255), -- 访问IP地址
  count int, -- 访问计数
  PRIMARY KEY (re_ip), -- 主键为IP地址
  INDEX idx_count (count) -- 访问计数索引
);



-- 创建评论表的thingId字段的二级索引
CREATE INDEX idx_comment_thingId ON b_comment (thingId);

-- 创建评论表的userId字段的二级索引
CREATE INDEX idx_comment_userId ON b_comment (userId);

-- 创建商品表的classificationId字段的二级索引
CREATE INDEX idx_thing_classificationId ON b_thing (classificationId);

-- 创建用户表的username字段的二级索引
CREATE INDEX idx_user_username ON b_user (username);

-- 创建用户表的email字段的二级索引
CREATE INDEX idx_user_email ON b_user (email);

```

数据库课设数据表

中序遍历为：ABEDFCHG，前序遍历为：CBADEFGH。

那么根节点就是C。
于是找到了中序遍历的左子树：ABEDF 和右子树：HG。



紧接着，前序遍历找到了左子树：BADEF 和右子树：GH。

于是，我们可以继续递归下去，直至字符串为空。
```cpp
#include <iostream>
using namespace std;
string generatePostOrder(string inOrder, string preOrder) {
    if (inOrder.empty() || preOrder.empty()) {
        return "";
    }
    char root = preOrder[0];
    int rootIndex = inOrder.find(root);
    string leftInOrder = inOrder.substr(0, rootIndex);
    string rightInOrder = inOrder.substr(rootIndex + 1);
    
    string leftPreOrder = preOrder.substr(1, rootIndex);
    string rightPreOrder = preOrder.substr(rootIndex + 1);
    string leftPostOrder = generatePostOrder(leftInOrder, leftPreOrder);
    string rightPostOrder = generatePostOrder(rightInOrder, rightPreOrder);
    return leftPostOrder + rightPostOrder + root;
}
int main() {
    string inOrder, preOrder;
    cin >> inOrder >> preOrder;
    string postOrder = generatePostOrder(inOrder, preOrder);
    cout << postOrder << endl;
    return 0;
}
```

P1827

```cpp
#include <iostream>
#include <vector>
#include <iomanip>




using namespace std;

// 递归函数生成组合
void generateCombinations(vector<int>& current, int n, int r, int index) {
    // 如果已经选够了r个元素，输出当前组合
    if (r == 0) {
        for (int i = 0; i < current.size(); i++) {
            cout << setw(3) << current[i]; // 输出占3个字符宽度的数字
        }
        cout << endl;
        return;
    }
    // 如果遍历完了所有元素，结束递归
    if (index > n) {
        return;
    }

    // 选择当前元素
    current.push_back(index);
    generateCombinations(current, n, r - 1, index + 1);

    // 不选择当前元素
    current.pop_back();
    generateCombinations(current, n, r, index + 1);
}

int main() {
    int n, r;
    cin >> n >> r;

    vector<int> current; // 存放当前组合的容器
    generateCombinations(current, n, r, 1); // 从第一个元素开始生成组合

    return 0;
}

```

```cpp
#include <bits/stdc++.h>//万能头文件
using namespace std;
int total=0; 
int a[50]; //a数组存每一次选的数
bool b[50];
int n,r;
void print(){ //打印函数
    for(int i=1; i<=r; i++)
    cout<<setw(3)<<a[i];//定义场宽为3，直接输出只能得10分
    cout<<endl;
} 
void search(int t)//搜索函数
{
    int i;
    if(t>r) { //如果搜完了就输出a数组
        print();
        return;
    }
    for(int i=1; i<=n; i++){ //枚举每一个数
        if(!b[i]&&i>a[t-1]||t==1)//当i木有被使用过且i必须大于前个数但除1之外
{
            a[t]=i; //将i存入a数组
            b[i]=true;//标记i已被使用
            search(t+1);//继续搜索
            a[t]=0;//回溯一步
            b[i]=false; 
        }
    } 
}
int main(){
    cin>>n>>r;//输入
   search(1);
   return 0;
}
```


```cpp
#include<iostream>
#include<iomanip>
using namespace std;
int a[1005],n,m,arr = 1;
int main()
{
    cin >> n >> m;
    while(arr){
        if(arr >= m + 1){					//达到边界时打印解
            for(int i = 1;i <= m;i++)
                cout << setw(3) << a[i];	 //注意场宽设置
            cout << endl;
            arr--;						   //回溯到前一位
            continue;
        }
        if(!a[arr]){						 //若该位置为空
            a[arr] = a[arr - 1] + 1;		 //在其前一位基础上加一
            arr ++;
            continue;
        }
        if(a[arr] + m - arr < n){			//**关键** 判定在当前位为a[arr]的情况下向后推(m - arr)位是否超出题目的最大数字限制
            a[arr++] ++;					 //当前位自加后挪至后一位	
            continue;
        }
        a[arr--] = 0;						//将当前位归零,回溯至前一位
    }
    return 0;
}
```

P1157

```cpp
#include<iostream>
#include<cstdio>
using namespace std;
int n,ans1,ans2[10001][11],sum,a[11];
void trys(int t,int m)//t代表当前的尝试的调料。m代表当前美味程度
{
    if (t>10) 
    {
        if (m==n) //如果美味程度与猪猪的要求相等 
        {
            ans1++;//统计方案总数 
            for (int i=1;i<=10;i++)
            ans2[ans1][i]=a[i];//存入答案的数组 
        }
        return ;
    }
    for (int i=1;i<=3;i++)
    {
        if (m+i>n) break;//如果超过了要求，那么后面的就可以直接忽略 
        a[t]=i;//储存答案 
        trys(t+1,m+i);//查看下一种调料 
        a[t]=0;//状态恢复 
    }
}
int main()
{
    cin>>n;
    trys(1,0);//从第一种调料开始尝试，美味程度为0 
    cout<<ans1<<endl;
    for (int i=1;i<=ans1;i++)
    {
        for (int j=1;j<=10;j++)
            cout<<ans2[i][j]<<" ";
        cout<<endl;
    }//输出结果 
    return 0;
} 



// 

#include<iostream>
using namespace std;
int s,t,n;
int a[11];
int b[10000][11];//一个二维数组，先出方案总数很难做呀
int c=1;
int num;
void ss(int k);
void pp();
int main() {
	cin>>n;
	ss(1);
	cout<<num<<endl;
	for(int i=1; i<c; i++) {
		for(int j=1; j<=10; j++) {
			cout<<b[i][j]<<" ";
		}
		cout<<endl;
	}
}
void ss(int k) {
	for(int i=1; i<=3; i++)//每个只能加1,或2或3 {
		s+=i;
		a[k]=i;
		if(k==10) {
			if(s==n)pp();
		} else ss(k+1);
		s-=i;//回溯
	}
}
void pp() {
	num++;
	for(int i=1; i<=10; i++)
		b[c][i]=a[i];//存数组
	c++;
}




// STL

#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
int b3[10]={0,1,2,3,4,5,6,7,8,9};//打表
int main(){
	int a,b,c;
	scanf("%d%d%d",&a,&b,&c);
	int co=0;
	do{
		int a1=100*b3[1]+10*b3[2]+b3[3];//第一个数
		int b1=100*b3[4]+10*b3[5]+b3[6];//第二个数
		int c1=100*b3[7]+10*b3[8]+b3[9];//第三个数
		if((a1*b==b1&&a1*c==c1)||(a1==a&&b1==b&&c1==c)){//判断
			co++;
			printf("%d %d %d\n",a1,b1,c1);//输出
		}
	}
	while(next_permutation(b3+1,b3+10));
	if(co==0){
		printf("No!!!");
	}
	return 0;
}
```

P2089回溯

```cpp
#include <iostream>
#include <vector>
using namespace std;



void bucketSort(vector<int>& arr) {
    const int maxVal = 1000; // 假设候选人编号不超过 1000
    vector<int> buckets(maxVal + 1, 0);

    for (int i = 0; i < arr.size(); i++) {
        buckets[arr[i]]++;
    }

    for (int i = 1; i <= maxVal; i++) {
        for (int j = 0; j < buckets[i]; j++) {
            cout << i << ' ';
        }
    }
}

int main() {
    int n, m;
    cin >> n >> m;
    vector<int> votes(m);

    for (int i = 0; i < m; i++) {
        cin >> votes[i];
    }

    bucketSort(votes); // 调用桶排序函数

    return 0;
}

```


```cpp
#include<bits/stdc++.h>
using namespace std;
int a,n,m,b[1000];
int main()
{
	cin>>n>>m;
	for(int i=0;i<m;i++)cin>>a,++b[a]; //记录票出现的次数
	for(int i=0;i<1000;i++)while(b[i]--)cout<<i<<" "; //根据票出现的次数输出
	return 0;
}
```