今天给各位分享二叉排序树的实现c语言代码的知识，其中也会对二叉树c语言实现完整代码进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！
本文目录一览：
1、生成二叉排序树(c++写代码, 数据结构)2、数据结构-课程设计：二叉排序树的实现3、二叉树c语言实现4、数据结构课程设计（C版语言）二叉排序树算法
生成二叉排序树(c++写代码, 数据结构)
#include memory.h
#include cstdlib
#include cstdio
#include iostream
#include fstream
using namespace std;
#define LEN 100
typedef char ElemType;
class BSTree;
BSTree *CreateBSTree(const ElemType *a);
// 二叉排序树节点
class BSTNode
{
friend class BSTree;
friend BSTree *CreateBSTree(const ElemType *a);
public:
BSTNode() : lchild(NULL), rchild(NULL) {}
BSTNode(ElemType d, BSTNode *l = NULL,BSTNode *r = NULL)
: data(d), lchild(l), rchild(r) {}
private:
BSTNode *lchild, *rchild;
ElemType data;
};
// 二叉排序树
class BSTree
{
friend BSTree *CreateBSTree(const ElemType *a);
public:
BSTree() : root(NULL) {}
~BSTree() { CleanUp(); }
void CleanUp(BSTNode *r);
void InOrder(BSTNode *r) const; // 中序遍历
void PostOrder(BSTNode *r) const; // 后序遍历
void CleanUp(); // 释放资源
void InOrder() const;
void PostOrder() const;
private:
BSTNode *root;
};
void BSTree::CleanUp(BSTNode *r)
{
if (r)
{
CleanUp(r-lchild);
CleanUp(r-rchild);
delete r;
}
}
void BSTree::CleanUp()
{
CleanUp(root);
}
void BSTree::InOrder(BSTNode *r) const
{
if (r)
{
InOrder(r-lchild);
cout r-data ‘ ‘;
InOrder(r-rchild);
}
}
void BSTree::InOrder() const
{
InOrder(root);
}
void BSTree::PostOrder(BSTNode *r) const
{
if (r)
{
PostOrder(r-lchild);
PostOrder(r-rchild);
cout r-data ‘ ‘;
}
}
void BSTree::PostOrder() const
{
PostOrder(root);
}
// 创建二叉排序树
BSTree *CreateBSTree(const ElemType *a)
{
BSTree *tree= new BSTree;
BSTNode *cursor;
tree-root= new BSTNode(a[0]);
const ElemType *p = a + 1;
while (*p != ‘\0’)
{
cursor = tree-root;
while (1)
{
if (*p cursor-data)
{
if (!cursor-lchild)
{
cursor-lchild = new BSTNode(*p);
break;
}
cursor = cursor-lchild;
}
else
{
if (!cursor-rchild)
{
cursor-rchild = new BSTNode(*p);
break;
}
cursor = cursor-rchild;
}
}
++p;
}
return tree;
}
int main()
{
char choice, data[LEN];
BSTree *tree = NULL;
cout “请选择创建二叉排序树的方式:” endl;
cout “1) 文件获取数据\t2) 手动输入数据” endl;
memset(data, ‘\0’, LEN);
cin choice;
while (getchar() != ‘\n’);
switch (choice)
{
case ‘1’:
{
// 假定数据文件名为data.txt
ifstream infile(“data.txt”);
if (!infile)
{
cerr “打开文件出错！” endl;
exit(-1);
}
// 从文件读取一行数据，长度为LEN减1
infile.getline(data, LEN);
// 关闭文件
infile.close();
break;
}
case ‘2’:
{
cout endl;
cout “请输入一个字符串: “;
// 从控制台读取一行数据，长度为LEN减1
cin.getline(data, LEN);
break;
}
}
tree = CreateBSTree(data);
cout endl;
cout “中序序列：” endl;
tree-InOrder();
cout endl;
cout “后序序列：” endl;
tree-PostOrder();
cout endl;
delete tree;
system(“PAUSE”);
return 0;
}
数据结构-课程设计：二叉排序树的实现
晕了，真是好纠结，我在写完下面的代码后，才在网上找了找，居然发现和你的题目完全一样的代码，算了，我就直接发在网上找到的文档和代码给你吧，可怜我写了这么久代码呀。。。。。已发，请注意查收。
代码写好了。
VC下经测试通过。
不过如果你还要论文之类的或者设计文档，我也比较难帮到你了。
#include iostream
using namespace std;
class node
{
public:
node(int i):data(i),left(NULL),right(NULL){}
void inorder(node *root) //中序遍历，符合升序输出
{
if(root!=NULL)
{
inorder(root-left);
coutroot-data’ ‘;
inorder(root-right);
}
}
void insert(node *ptr,int item) //在查找树中插入元素
{
if(ptr==NULL)
ptr=new node(item);
else if(itemptr-data)
insert(ptr-left,item);
else insert(ptr-right,item);
}
node *find(node *ptr,int item) //在查找树中查找元素,找到返回所在结点指针，找不到返回空指针。
{
if(ptr==NULL)
return NULL;
if(ptr-data==item)
return ptr;
else if(itemptr-data)
find(ptr-left,item);
else find(ptr-right,item);
}
node *findy(node *ptr,int item) //在查找树中查找肯定存在的元素,并返回其引用
{
if(ptr-data==item)
return ptr;
else if(itemptr-data)
findy(ptr-left,item);
else findy(ptr-right,item);
}
node* rl(){return left;}
node* rr(){return right;}
void dele(node *ptr) //删除值为item所在结点
{
if(ptr-rl()==NULLptr-rr()==NULL)
ptr=NULL;
else if(ptr-rr()==NULL)
ptr=ptr-rl();
else
ptr=ptr-rr();
}
private:
int data;
node *left; //左孩子结点
node *right; //右孩子结点
};
int main()
{
int t,i=0,j;
cout”输入数字个数(结点个数):”;
cint;
cout”输入”t”个数字，数字之间用空格隔开:”;
cinj;
node *x=new node(j);
for(;it-1;i++)
{
cinj;
x-insert(x,j);
}
cout”中序遍历为:”;
x-inorder(x); //作中序遍历
cout”\n输入操作(当输入-1时程序结束):”endl;
cinj;
while(j!=-1)
{
node *t=x-find(x,j); //定位结点
if(t!=NULL)
{
node *y=x-findy(x,j);
x-dele(y);
cout”中序遍历为:”;
x-inorder(x);
}
else cout”无”j;
cout”\n输入操作(当输入-1时程序结束):”endl;
cinj;
}
return 0;
}
附测试数据一组
8
22 33 1 50 88 99 77 55
33
50
51
55
-1
有什么不明的话可以M我或者留言我。
二叉树c语言实现
#includeiostream.h
#include stdio.h
#include stdlib.h
typedef struct node {
char data;
struct node *lchild,*rchild;//
}BiTNode,*BiTree;
void CreatBiTree(BiTree T)
{
char ch;
ch=getchar();
if (ch == ‘ ‘)
T = 0;
else {
T=(BiTNode*)malloc(sizeof(BiTNode));
T-data=ch;//生成根节点
CreatBiTree(T-lchild);//构造左子树
CreatBiTree(T-rchild);//构造右子树
}
}
void preorder(BiTree T)//前序遍历
{
if (T!=NULL){
printf (“%c”,T-data);
preorder(T-lchild);
preorder(T-rchild);
}
}
void inorder(BiTree T)//中序遍历
{
if (T!=NULL){
inorder(T-lchild);
printf (“%c”,T-data);
inorder(T-rchild);
}
}
void postorder(BiTree T)//后序遍历
{
if (T!=NULL){
postorder(T-lchild);
postorder(T-rchild);
printf (“%c”,T-data);
}
}
void main ()
{
cout”请输入要创建的二叉树包括空格:”endl ;
BiTree T;
CreatBiTree(T);//创建二叉树
cout”前序遍历的结果为:”endl;
preorder(T);
coutendl;
cout”中序遍历的结果为:”endl;
inorder(T);
coutendl;
cout”后序遍历的结果为:”endl;
postorder(T);
}
数据结构课程设计（C版语言）二叉排序树算法
下面的程序包含了树二叉树的所有操作
在二叉树的应用中有二叉排序树。
都是C语言，只不过用了C++的cin(输入)和cout（输出）,因为这两个不需要格式控制符。
//建一个工程：包含头文件：bittree.h Cpp文件：bittree.cpp main函数:main.cpp
编译运行就可以了。
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//头文件 bittree.h
#ifndef _DEF
#define _DEF
#include stdlib.h
#include stdio.h
#include iostream
using namespace std;
#define TURE 1
#define OK 1
#define FALSE 0
#define ERROR 0
#define INFEASIBLE -1//不可实行的
#define OVERFLOW -2
typedef int stadus;
typedef char Telemtype;
//typedef int Telemtype2;//为了二叉排序树的创建
typedef char ElemType;
#define STACK_SIZE 100;
#define STACKINCREMENT 10;
//二叉树
typedef struct bitnode{
Telemtype data;
struct bitnode *lchild,*rchild;
}BitNode,*BitTree;
extern stadus CreateBitTree(BitTree T);
extern stadus PreOrderTraverse(BitTree T);
extern stadus InOrderTraverse(BitTree T);
extern stadus PostOrderTraverse(BitTree T);
typedef BitNode selemtypechar;
typedef BitTree selemtypechar2;
// 栈
typedef struct SqStack{
selemtypechar2 *base;
selemtypechar2 *top;
int stacksize;
}sqstack;
extern stadus initstackC(sqstack S);
extern stadus gettopC(sqstack S,selemtypechar2 e);
extern stadus pushC(sqstack S,selemtypechar2 e);
extern stadus popC(sqstack S,selemtypechar2 e);
extern stadus destroyC(sqstack S);//销毁
extern stadus clearC(sqstack S);//置空
extern stadus stackempty(sqstack S);
//栈实现二叉树的输出
extern stadus PreOrderTraverse2(BitTree T);
extern stadus InOrderTraverse2(BitTree T);
extern stadus PostOrderTraverse2(BitTree T);
//二叉树的应用
extern stadus Depth(BitTree T);
extern stadus Single(BitTree T);
extern stadus Double(BitTree T);
extern stadus CountLeaf(BitTree T);
extern void Change_Left_Right(BitTree T);
//二叉层次遍历用到队列
typedef BitTree Qelemtype;
typedef struct QNode{
Qelemtype data;
struct QNode *next;
}qnode,*QueuePtr;
typedef struct {
QueuePtr front;
QueuePtr rear;
}LinkQueue;
extern stadus InitQueue(LinkQueue Q);
extern stadus DestroyQueue(LinkQueue Q);
extern stadus EnterQueue(LinkQueue Q,Qelemtype e);
extern stadus DeQueue(LinkQueue Q,Qelemtype e);
//二叉层次遍历
extern stadus LevelOrder(BitTree T);
//二叉排序树
extern void insert(BitTree T,ElemType x);
extern void CreateBiTree2(BitTree root);
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//cpp文件 bittree.cpp
#include “bittree.h”
#include stdlib.h
stadus initstackC (sqstack s)
{
s.base=(selemtypechar2 *)malloc(100*sizeof(selemtypechar));//用STACKINCREMENT会报错？？？
if (!s.base) exit(OVERFLOW);
s.top=s.base;
s.stacksize=100;
return OK;
}
stadus gettopC(sqstack s,selemtypechar2 e)
{
if(s.base==s.top) return ERROR;
e=*(s.top-1);
return OK;
}
stadus pushC(sqstack s,selemtypechar2 e)
{
if ((s.top-s.base)=s.stacksize)
{
s.base=(selemtypechar2 *)realloc(s.base,((s.stacksize+10)*(sizeof(selemtypechar))));
if(!s.base) exit(OVERFLOW);
s.top=s.base+s.stacksize;
s.stacksize+=10;
}
*(s.top++)=e;
//s.top++;
return OK;
}
stadus popC(sqstack s,selemtypechar2 e)
{
if(s.top==s.base) return ERROR;
–s.top;
e=*(s.top);
return OK;
}
stadus destroyC(sqstack s)
{
free(s.base); s.base=NULL;s.top=NULL;
return OK;
}
stadus clearC(sqstack s)
{
s.top=s.base;
return OK;
}
stadus stackempty(sqstack s)
{
if(s.top!=s.base) return ERROR;
else
return OK;
}
//二叉树
stadus CreateBitTree(BitTree T)//创建
{
Telemtype ch;
cinch;
if(ch==’#’) T=NULL;
else{
T=(BitTree)malloc(sizeof(BitNode));
if (!T) exit (OVERFLOW);
T-data=ch;
CreateBitTree(T-lchild);
CreateBitTree(T-rchild);
}
return OK;
}
stadus PreOrderTraverse(BitTree T)//先序访问
{
if(!T) return ERROR;
else if (T)
{
coutT-data” “;
PreOrderTraverse(T-lchild);
PreOrderTraverse(T-rchild);
}
return OK;
}
stadus InOrderTraverse(BitTree T)//中序
{
if(!T) return ERROR;
else if (T)
{
InOrderTraverse(T-lchild);
coutT-data” “;
InOrderTraverse(T-rchild);
}
return OK;
}
stadus PostOrderTraverse(BitTree T)//后序
{
if(!T) return ERROR;
else if (T)
{
PostOrderTraverse(T-lchild);
PostOrderTraverse(T-rchild);
coutT-data” “;
}
return OK;
}
//栈实现二叉树的访问
stadus PreOrderTraverse2(BitTree T)//先序
{
sqstack s;
BitTree p;
initstackC(s);
p=T;
//pushC(s,p);
while (p||!stackempty(s))
{
//popC(s,p);
if (p)
{
pushC(s,p);
if(!p-data)return ERROR;
coutp-data” “;
//p1=p;
p=p-lchild;
if (p==NULL)
{
popC(s,p);
p=p-rchild;
}
else
pushC(s,p);
}
else {
popC(s,p);
popC(s,p);
p=p-rchild;
if (p==NULL)
{
popC(s,p);
if (p==NULL)
{
return OK;
}
else
{
p=p-rchild;
}
}
else{
pushC(s,p);
if(!p-data)return ERROR;
coutp-data” “;
p=p-lchild;//左空不压栈
if (p==NULL)
{
popC(s,p);
p=p-rchild;
}
else
pushC(s,p);
}
}
}
destroyC(s);
return OK;
}
stadus InOrderTraverse2(BitTree T)//中序
{
sqstack s;
BitTree p;
initstackC(s);
p=T;
while (p||!stackempty(s))
{
if (p)
{
pushC(s,p);
p=p-lchild;
}
else {
popC(s,p);
if(!p-data)return ERROR;
coutp-data” “;
p=p-rchild;
}
}
destroyC(s);
return OK;
}
stadus PostOrderTraverse2(BitTree T)//后序
{
sqstack s;
BitTree p;
initstackC(s);
p=T;
while (p||!stackempty(s))
{
if (p)
{
pushC(s,p);
p=p-lchild;
if (p==NULL)
{
popC(s,p);
//p=p-rchild;
if (p-rchild==NULL)
{
if(!p-data)return ERROR;
coutp-data” “;
//p=p-rchild;
popC(s,p);
if (p==NULL)
{
return OK;
}
else
{
//pushC(s,p);//???右结点重复压栈？？？
//p1=p;
p=p-rchild;
//p-rchild=NULL;
}
}
else
{
p=p-rchild;
}
}
else
continue ;
}
else
{
//popC(s,p);
if(!p-data)return ERROR;
coutp-data” “;
popC(s,p);
if (p==NULL)
{
return OK;
}
else
{
//pushC(s,p);
//p1=p;
p=p-rchild;
//p-rchild=NULL;
}
}
}
destroyC(s);
return OK;
}
//二叉树的应用
//二叉树的深度
stadus Depth(BitTree T)
{
int depthval,depthLeft,depthRight;
if (!T) depthval=0;
else{
depthLeft=Depth(T-lchild);
depthRight=Depth(T-rchild);
depthval=1+(depthLeftdepthRight?depthLeft:depthRight);
}
return depthval;
}
//二叉树的单分支结点数
stadus Single(BitTree T)
{
if (T==NULL) return 0; //空树
else if (T-lchild==NULL T-rchild==NULL) return 0; //叶子结点
else{
if (!T-lchild T-rchild) return Single(T-rchild)+1;//只有左单分支
if (T-lchild !T-rchild) return Single(T-lchild)+1;//只有右单分支
if(T-lchild T-rchild) return Single(T-lchild)+Single(T-rchild);//双分支结点
}
}
//二叉树的多分支结点数
stadus Double(BitTree T)
{
if (T==NULL) return 0; //空树
else if (T-lchild==NULL T-rchild==NULL) return 0; //叶子结点
else{
if (!T-lchild T-rchild) return Double(T-rchild);//只有左单分支
if (T-lchild !T-rchild) return Double(T-lchild);//只有右单分支
if(T-lchild T-rchild) return Double(T-lchild)+Double(T-rchild)+1;//双分支结点
}
}
//叶子结点
stadus CountLeaf(BitTree T)
{
int num,num1,num2;
if(T==NULL) num=0;
else if(T-lchild==NULLT-rchild==NULL)
num=1;
else
{
num1=CountLeaf(T-lchild);
num2=CountLeaf(T-rchild);
num=num1+num2;
}
return num;
}
//交换左右子树
void Change_Left_Right(BitTree T)
{
BitTree Temp;
if (T)
{
Change_Left_Right(T-lchild);
Change_Left_Right(T-rchild);
Temp=T-lchild;
T-lchild=T-rchild;
T-rchild=Temp;
}
}
//二叉层次遍历用到队列
stadus InitQueue(LinkQueue Q)
{
Q.front=Q.rear=(QueuePtr)malloc(100*sizeof(qnode));
if(!Q.front) exit(OVERFLOW);
Q.front-next=NULL;
return OK;
}
stadus DestroyQueue(LinkQueue Q)
{
while (Q.front)
{
Q.rear=Q.front-next;
free(Q.front);
Q.front=Q.rear;
}
return OK;
}
stadus EnterQueue(LinkQueue Q,Qelemtype e)
{
QueuePtr p;
p=(QueuePtr)malloc(sizeof(qnode));
if(!p) return ERROR;
p-data=e;
p-next=NULL;
Q.rear-next=p;
Q.rear=p;
return OK;
}
stadus DeQueue(LinkQueue Q,Qelemtype e)
{ QueuePtr p;
if(Q.front==Q.rear) return ERROR;
p=Q.front-next;e=p-data;
Q.front-next=p-next;
if(Q.rear==p)Q.rear=Q.front;
free(p);
return OK;
}
//二叉层次遍历
stadus LevelOrder(BitTree T)
{
LinkQueue Q;
BitTree B;
InitQueue(Q);
if (T!=NULL)
{
EnterQueue(Q,T);
while (!(Q.front==Q.rear))
{
DeQueue(Q,B);
coutB-data” “;
if(B-lchild!=NULL) EnterQueue(Q,B-lchild);
if(B-rchild!=NULL) EnterQueue(Q,B-rchild);
}
}
return OK;
}
//二叉排序树
void insert(BitTree T,ElemType x)
{
if (T==NULL)
{
T=(BitTree)malloc(sizeof(BitNode));
T-data=x;
T-lchild=T-rchild=NULL;
}
else
{
if(xT-data)insert(T-lchild,x);
if(x=T-data)insert(T-rchild,x);
}
}
void CreateBiTree2(BitTree root)
{
ElemType x;
root=NULL;
cout”二叉排序树的创建以’#’结束!!!”endl;
cout”请输入字母，没写整型!!!”endl;
cinx;
while (x!=’#’)
{
insert(root,x);
cinx;
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//主函数 main.cpp
#include “bittree.h”
void main()
{
system(“cls”);
system(“color f0”);
BitTree T;
Create:
cout’\t”\t'”先序创建二叉树以’#’表示左右孩子为空!!!：”endl;
CreateBitTree(T);
BitTree T1(T);
select:
cout’\t”\t'”—————-MAIN-MENU—————-“endl;
cout’\t”\t'”1、先序输出 2、中序输出 3、后序输出 “endl;
cout’\t”\t'”4、栈实现输出 5、重新创建二叉树 0、退出”endl;
cout’\t”\t'”————6、二叉树的应用————-“endl;
char sel;
getchar();
cinsel;
switch (sel)//总
{
case ‘0’:
break;
case ‘1’:coutendl”———————————“endl;
PreOrderTraverse(T);
coutendl”———————————“endl;
goto select;
case ‘2’:coutendl”———————————“endl;
InOrderTraverse(T);
coutendl”———————————“endl;
goto select;
case ‘3’:coutendl”———————————“endl;
PostOrderTraverse(T);
coutendl”———————————“endl;
goto select;
case ‘4’:
stackcout:
coutendl’\t'” ——————-SUB-MENU1———————“endl;
cout’\t'” 1、先序输出 2、中序输出 3、后序输出 4、返回 “endl;
cout’\t'” ————————————————“endl;
cinsel;
switch (sel)//栈关于树的输出
{
case ‘1’:coutendl”———————————“endl;
PreOrderTraverse2(T1);//p-lchild==null,时 T 的值被修改！！！！！！！！
coutendl”———————————“endl;
goto stackcout;
case ‘2’:coutendl”———————————“endl;
InOrderTraverse2(T);
coutendl”———————————“endl;
goto stackcout;
case ‘3’:coutendl”———————————“endl;
PostOrderTraverse(T1);//栈实现未写完
coutendl”———————————“endl;
goto stackcout;
case ‘4’:goto select;
default:cout”选择错误!!!”endl;
goto stackcout;
}
case ‘5’:
goto Create;
case ‘6’:
{
SUB_MENU2:
cout’\t”\t'”————————-SUB-MENU2———————“endl;
cout’\t”\t'”1、二叉树的深度 2、二叉树的单分支结点数 “endl;
cout’\t”\t'”3、二叉树的多分支结点数 4、二叉树的叶子结点数 “endl;
cout’\t”\t'”5、二叉层次遍历 6、二叉排序树 7、交换左右子树 “endl;
cout’\t”\t'”——————8、输出 0、返回——————–“endl;
cinsel;
switch (sel)//二叉树的应用
{
case ‘0’:
goto select;
case ‘1’:
{
int deepth=0;
deepth=Depth(T);
coutendl”———————————“endl;
cout”树的深度为：”deepthendl;
coutendl”———————————“endl;
}
goto SUB_MENU2;
case ‘2’:
{
int cou_sig;
cou_sig=Single(T);
coutendl”———————————“endl;
cout”此树的单分支结点为数：”cou_sigendl;
coutendl”———————————“endl;
}
goto SUB_MENU2;
case ‘3’:
{
int cou_dou;
cou_dou=Double(T);
coutendl”———————————“endl;
cout”此树的双分支结点数为：”cou_douendl;
coutendl”———————————“endl;
}
goto SUB_MENU2;
case ‘4’:
{
int cou_leaf;
cou_leaf=CountLeaf(T);
coutendl”———————————“endl;
cout”此树的叶子结点数为：”cou_leafendl;
coutendl”———————————“endl;
}
goto SUB_MENU2;
case ‘5’:
{
cout”二叉层次遍历的结果为：”endl;
coutendl”———————————“endl;
LevelOrder(T);
coutendl”———————————“endl;
}
goto SUB_MENU2;
case ‘6’:
{
BitTree T3;
CreateBiTree2(T3);
SUB3:
cout’\t'”————————-SUB-MENU2——————-“endl;
cout’\t'” 1、先序输出 2、中序输出 3、后序输出 0、返回 “endl;
cout’\t'”—————————————————–“endl;
cinsel;
switch (sel)//二叉树的层次遍历
{
case ‘0’:
break;
case ‘1’:coutendl”———————————“endl;
PreOrderTraverse(T3);
coutendl”———————————“endl;
goto SUB3;
case ‘2’:coutendl”———————————“endl;
InOrderTraverse(T3);
coutendl”———————————“endl;
goto SUB3;
case ‘3’:coutendl”———————————“endl;
PostOrderTraverse(T3);
coutendl”———————————“endl;
goto SUB3;
default:
cout”选择错误!!!”endl;
goto SUB3;
}
}
goto SUB_MENU2;
case ‘7’:
{
Change_Left_Right(T);
coutendl”———————————“endl;
cout”交换完成，请选择8输出查看!!!”endl;
coutendl”———————————“endl;
}
goto SUB_MENU2;
case ‘8’:
goto select;
default:
cout”选择错误!!!”endl;
goto SUB_MENU2;
}
}
break;
default :
coutendl”选择错误!!!”endl;
goto select;
}
}
关于二叉排序树的实现c语言代码和二叉树c语言实现完整代码的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。
微信扫一扫 
支付宝扫一扫 
