数据结构

68 阅读 0 评论 45 点赞

我是靠谱客的博主朴素招牌，最近开发中收集的这篇文章主要介绍数据结构，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

数据结构

只是为了记录我写的代码，质量不高
一、顺序表

#include<iostream>
#include<stdlib.h>
#include<string.h>
using namespace std;
typedef int ElemType;
struct List
{
ElemType *list;//存线性表元素的动态存储空间的指针
int size; //线性表长度
int Maxsize;//list数组长度
};
//初始化线性表
void InitList(List &L)
{
L.Maxsize=10;
//动态空间分配
L.list=new ElemType[L.Maxsize];
if(L.list==NULL)
{
cout<<"EXIT"<<endl;
exit(1);
}
//置线性表长度为0，空表
L.size=0;
}
//删除所有元素，使之为空表
void ClearList(List &L)
{
printf("yesn");
if(L.list!=NULL)
{
delete []L.list;
L.list=NULL;
}
L.Maxsize=0;
L.size=0;
}
//得到线性表长度
void LengthList(List &L)
{
cout<<L.size<<endl;
}
//判表空
bool EmptyList(List &L)
{
return L.size==0;
}
//遍历线性表
void TraverseList(List &L)
{
for(int i=0;i<L.size;i++)
{
cout<<L.list[i]<<' ';
}
cout<<endl;
}
//按值查找元素
ElemType FindElem(List &L,ElemType item)
{
for(int i=0;i<L.size;i++)
{
if(L.list[i]==item)
{
cout<<i+1<<' '<<endl;
}
}
}
//按序号查找元素
ElemType GetElem(List &L,int i)
{
if(i<1 || i>L.size)
{
printf("out of range!");
}
cout<<"item is:"<<L.list[i-1]<<' '<<endl;
}
//更新给定值的元素
bool UpdateList(List &L,ElemType item)
{
for(int i=0;i<L.size;i++)
{
if(L.list[i]==item)
{
L.list[i]=item;
return true;
}
return false;
}
}
//按给定条件插入元素
void InsertList(List &L,ElemType item,int pos)
{
cout<<L.size<<"haha"<<endl;
//printf("yesssn");
//按值有序插
int i;
if(pos==0)
{
for(i=0;i<L.size;i++)
{
if(item<L.list[i])//顺序
break;
}
pos=i+1;//保存新插元素的序号
}
else if(pos==-1)
pos=L.size+1;
if(L.size==L.Maxsize)
{
int k=sizeof(ElemType);
L.list=(ElemType*)realloc(L.list,2*k*L.Maxsize);
if(L.list==NULL)
printf("out of range!");
L.Maxsize=2*L.Maxsize;
}
//待插入位置及所有后续位置元素从后向前依次后移
//cout<<L.size<<"haha"<<endl;
for(i=L.size-1;i>=pos-1;i--)
L.list[i+1]=L.list[i];
L.list[pos-1]=item;
L.size++;
}
//删除给定条件的元素
void DeleteList(List &L,ElemType &item,int pos)
{
//printf("deleten");
if(L.size==0)
{
printf("out of rangen");
}
if(pos<-1 || pos>L.size)
printf("pos out of rangen");
//求出按值删除时删除元素的位置，保存在pos中
int i;
if(pos==0)
{
for(i=0;i<L.size;i++)
{
if(item==L.list[i])
break;
}
if(i==L.size)
printf("no item");
pos=i+1;
}
else if(pos==-1)pos=L.size;
item=L.list[pos-1];
//待删除位置及所有后续位置元素从前向后依次前移
for(i=pos;i<L.size;i++)
L.list[i-1]=L.list[i];
L.size--;
}
//排序线性表
List SortList(List &L)
{
int i,j;
ElemType x;
for(i=1;i<L.size;i++)
{
x=L.list[i];
for (j=i-1;j>=0;j--)
{
if(x<L.list[j])
{
L.list[j+1]=L.list[j];
}
else break;
}
L.list[j+1]=x;
}
printf("sortn");
}
int main()
{
int a[14]={22,39,3,6,9,12,15,18,21,24,27,30,33,36};
int i;
ElemType x;
List L;
InitList(L);
printf("yesn");
for(i=0;i<14;i++)
{
InsertList(L,a[i],i+1);
}
InsertList(L,48,13);
InsertList(L,40,0);
GetElem(L,4);
GetElem(L,9);
SortList(L);
TraverseList(L);
//根据值查元素
cout<<"type the find item:";
cin>>x;
FindElem(L,x);
//根据值删元素
cout<<"type will delete item:";
cin>>x;
DeleteList(L,x,5);
cout<<"after delete the List: ";
TraverseList(L);
//根据值插入元素
cout<<"type the insert item: ";
cin>>x;
InsertList(L,x,0);
cout<<"after insert the List: ";
TraverseList(L);
//求线性表长度
printf("the length is: ");
LengthList(L);
ClearList(L);
}

二、单链表

#include<iostream>
#include<stdlib.h>
#include<string.h>
using namespace std;
typedef int ElemType;
typedef struct LNode//定义单链表节点类型
{
ElemType data;//每个结点存放一个数据元素
struct LNode *next;//指针指向下一个结点
}LNode,*LinkList;
//struct LNode* p=(struct LNode*)malloc(sizeof(struct LNode));//增加一个新节点，在内存中申请一个节点所需空间，并用指针p指向这个节点
//初始化单链表(带头结点)
bool InitList(LinkList &L)
{
L=(LNode *)malloc(sizeof(LNode));//L是头指针，分配一个头结点
if(L==NULL)
return false;//内存不够，分配失败
L->next=NULL;//头节点之后暂时还没有节点
return true;
}
//建立单链表（头插法）
LinkList List_HeadInsert(LinkList &L)
{
int x;
L=(LinkList)malloc(sizeof(LNode));//创立头节点
L->next=NULL;
//InitList(L);
printf("please Enter:");
scanf("%d",&x);
while(x!=999)
{
LNode *s=(LNode *)malloc(sizeof(LNode));
s->data=x;
s->next=L->next;
L->next=s;
scanf("%d",&x);
}
return L;
}
//按位序插(带头结点)
LinkList ListInsert(LinkList &L,int i,ElemType e)
{
if(i<1)return 0;
LNode *p;//指针p指向当前获取的节点
int j=0;//当前p指向的是第几个节点
p=L;//指向头结点，头结点L不可随意移动
while(p!=NULL && j<i-1)
{
p=p->next;
j++;
}
if(p==NULL)return 0;
LNode* s=(LNode *)malloc(sizeof(LNode));
s->data=e;
s->next=p->next;//先连
p->next=s;//后短
return L;
}
//按位序删除(带头结点)
LinkList ListDelete(LinkList &L,int i,ElemType &e)
{
if(i<1)return 0;
LNode *p;
int j=0;
p=L;//头指针不可随意移动，故
while(p!=NULL && j<i-1)
{
p=p->next;
j++;
}
if(p==NULL)return 0;
if(p->next==NULL)return 0;
LNode *q=p->next;//令q只想被删除的节点
e=q->data;//用e返回被删除的值
p->next=q->next;
free(q);
return L;
}
//按位序查找
int GetElem(LinkList L,int i)
{
if(i<0)return 0;
LNode *p;
int j=0;
p=L;//L是头结点，故不可随意移动
while(p!=NULL && j<i)
{
p=p->next;
j++;
}
return p->data;
}
//按值查找
int LocateElem(LinkList L,ElemType e)
{
LNode *p=L;
int j=0;
while(p!=NULL && p->data !=e)
{
p=p->next;
j++;
}
return j;
}
//求表长度
int Length(LinkList L)
{
int len=0;
LNode *p=L;
while(p->next !=NULL)
{
p=p->next;
len++;
}
return len;
}
//打印整个链表
void ShowList(LinkList L)
{
LNode *p=L;
while(p!=NULL)
{
printf("%d ",p->data);
p=p->next;
}
printf("n");
}
//主函数
int main()
{
LNode *L;
ElemType m;
//ElemType int n;
//初始化
InitList(L);
printf("win!n");
//头插法
List_HeadInsert(L);
//链表长度
printf("the length is :%d",Length(L));
//按序插
printf("nlist is:");
ListInsert(L,4,25);
ShowList(L);
//按位序查找
printf("index 7 is :%dn",GetElem(L,7));
//按位序删除
printf("After delete:");
ListDelete(L,1,m);
ShowList(L);
//按值查找
printf("element 's index:%d",LocateElem(L,4));
}

三、链栈

#include<iostream>
#include<stdlib.h>
#include<string.h>
using namespace std;
typedef int Elemtype;
struct SNode
{
Elemtype data;
SNode* next;
};
//初始化
void InitStack(SNode*& S)
{
S=NULL;//不带头结点
}
//插入元素
void Push(SNode*& S,const Elemtype item)
{
SNode* newptr=new SNode;
newptr->data=item;
newptr->next=S;
S=newptr;
}
//删除一个元素并返回
Elemtype Pop(SNode*& S)
{
if(S==NULL)
{
printf("Stack is empty!");
exit(1);
}
SNode* p=S;
S=S->next;
Elemtype temp=p->data;
delete p;
return temp;
}
//遍历一个链栈
void TraverseStack(SNode*& S)
{
SNode* a=S;
while(a!=NULL){
cout<<a->data<<" ";
a=a->next;
}
}
//判空操作
bool EmptyStack(SNode* S)
{
//printf("yessn");
return S==NULL;
}
//清除链栈为空
void CleatStack(SNode*& S)
{
//printf("yes!n");
SNode *cp,*np;
cp=S;
while(cp!=NULL)
{
np=cp->next;
delete cp;
cp=np;
}
S=NULL;
}
//读取栈顶元素
Elemtype Peek(SNode* S)
{
if(S==NULL)
{
printf("Link Stack is emptyn");
exit(1);
}
return S->data;
}
int main()
{
SNode* S;
InitStack(S);
printf("yesn");
int x;
cin>>x;
while(x!=-1)
{
Push(S,x);
cin>>x;
}
TraverseStack(S);
cout<<endl;
while(!EmptyStack(S))
{
cout<<Pop(S)<<" ";
}
cout<<endl;
CleatStack(S);
}

四、二叉树

#include<iostream>
#include<stdlib.h>
#include<string.h>
using namespace std;
typedef char ElemType;
struct BTreeNode
{
ElemType data;
BTreeNode *left;
BTreeNode *right;
};
//初始化
void InitBTree(BTreeNode*& BT)
{
BT=NULL;
}
//建立二叉树
void CreateBTree(BTreeNode*& BT,char *a)
{
const int Maxsize=10;
BTreeNode *s[Maxsize];
int top=-1;
BT=NULL;
BTreeNode *p;
int k;
int i=0;
while(a[i])
{
switch(a[i])
{
case ' ':
break;
case '(':
if(top==Maxsize-1)
{
cout<<"out of range"<<endl;
exit(1);
}
top++;
s[top]=p;
k=1;
break;
case ')':
if(top==-1)
{
cout<<"string wrong"<<endl;
exit(1);
}
top--;
break;
case ',':
k=2;
break;
default:
p=new BTreeNode;
p->data=a[i];
p->left=p->right=NULL;
if(BT==NULL)
BT=p;
else{
if(k==1)
s[top]->left=p;//左孩子插入
else
s[top]->right=p;//右孩子插入
}
}
i++;
}
}
//检查二叉树是否为空
bool EmptyBTree(BTreeNode* BT)
{
return BT==NULL;
}
//求二叉树的深度
int DepthBTree(BTreeNode* BT)
{
if(BT==NULL)
return 0;
else
{
int dep1=DepthBTree(BT->left);
int dep2=DepthBTree(BT->right);
if(dep1>dep2)
return dep1+1;
else
return dep2+1;
}
}
//查找值为x的节点,存在返回真
bool FindBTree(BTreeNode* BT,ElemType &x)
{
if(BT==NULL)
return false;
else
{
if(BT->data==x)
{
x=BT->data;
return true;
}
else
{
if(FindBTree(BT->left,x))
return true;
if(FindBTree(BT->right,x))
return true;
return false;
}
}
}
//输出二叉树
void PrintBTree(BTreeNode* BT)
{
//printf("printfn");
if(BT!=NULL)
{
cout<<BT->data;
if(BT->left!=NULL || BT->right!=NULL)
{
cout<<'(';
PrintBTree(BT->left);
if(BT->right!=NULL)
cout<<',';
PrintBTree(BT->right);
cout<<')';
}
}
}
//前序遍历
void PreOrder(BTreeNode* BT)
{
if(BT!=NULL)
{
cout<<BT->data<<' ';
PreOrder(BT->left);
PreOrder(BT->right);
}
}
//中序遍历
void InOrder(BTreeNode* BT)
{
if(BT!=NULL)
{
InOrder(BT->left);
cout<<BT->data<<' ';
InOrder(BT->right);
}
}
//后序遍历
void LastOrder(BTreeNode* BT)
{
if(BT!=NULL)
{
LastOrder(BT->left);
LastOrder(BT->right);
cout<<BT->data<<' ';
}
}
//按层遍历
void LevelOrder(BTreeNode* BT)
{
const int Maxsize=30;
BTreeNode* q[Maxsize];
int front=0,rear=0;
BTreeNode* p;
if(BT!=NULL)
{
rear=(rear+1)%Maxsize;
q[rear]=BT;
}
while(front!=rear)
{
front=(front+1)%Maxsize;
p=q[front];
cout<<p->data<<' ';
if(p->left!=NULL)
{
rear=(rear+1)%Maxsize;
q[rear]=p->left;
}
if(p->right!=NULL)
{
rear=(rear+1)%Maxsize;
q[rear]=p->right;
}
}
}
//清除二叉树
void ClearBTree(BTreeNode *&BT)
{
if(BT!=NULL)
{
ClearBTree(BT->left);
ClearBTree(BT->right);
delete BT;
BT=NULL;
}
//printf("clear");
}
int main()
{
BTreeNode* BT;
InitBTree(BT);
printf("yesn");
char b[50];
cout<<"type the string:"<<endl;
cin.getline(b,sizeof(b));
CreateBTree(BT,b);
PrintBTree(BT);
cout<<endl;
cout<<"before:";
PreOrder(BT);
cout<<endl;
cout<<"mindle:";
InOrder(BT);
cout<<endl;
cout<<"last:";
LastOrder(BT);
cout<<endl;
cout<<"anceng:";
LevelOrder(BT);
cout<<endl;
ElemType x;
cout<<"Please type the char:";
cin>>x;
if(FindBTree(BT,x))
{
cout<<x<<" yes"<<endl;
}
else
cout<<x<<" no"<<endl;
printf("depth:");
cout<<DepthBTree(BT)<<endl;
ClearBTree(BT);
}

五、集合

#include<iostream>
#include<stdlib.h>
#include<string.h>
using namespace std;
typedef int ElemType;
struct Set
{
ElemType *set;
int len;
int MaxSize;
};
//初始化
void InitSet(Set &S)
{
S.MaxSize=10;
S.set=new ElemType[10];
if(!S.set)
cout<<"exit"<<endl;
S.len=0;
}
//清除集合中所有元素
void ClearSet(Set& S)
{
if(S.set!=NULL)
{
delete []S.set;
//指针，一次清空集合中的元素
S.set=NULL;
}
S.MaxSize=0;
S.len=0;
}
//求出集合的长度
int LenthSet(Set& S)
{
return S.len;
}
//判断集合是否为空
bool EmptySet(Set& S)
{
return S.len==0;
//若集合长度为0则返回真表示空
}
//判断一个元素是否属于集合
bool InSet(Set& S,ElemType item)
{
for(int i=0;i<S.len;i++)
if(S.set[i]==item) return true;
return false;
}
//输出集合中所有元素
void OutputSet(Set& S)
{
for(int i=0;i<S.len;i++)
cout<<S.set[i]<<' ';
cout<<endl;
}
//从集合中查找一个元素
bool FindSet(Set& S,ElemType& item)
{
int i;
for(i=0;i<S.len;i++)
if(S.set[i]==item)
break;
if(i<S.len)
{
item=S.set[i];
return true;
}
else return false;
}
//修改集合中的一个指定元素
bool ModifySet(Set& S,const ElemType& item)
{
int i;
for(i=0;i<S.len;i++)
if(S.set[i]==item) break;
if(i<S.len)
{
S.set[i]=item;
return true;
}
else return false;
}
//向集合中插入一个元素
bool InsertSet(Set& S,ElemType item)
{
int i;
for(i=0;i<S.len;i++)
if(S.set[i]==item)
return false;
if(S.len==S.MaxSize)
{
int k=sizeof(ElemType);
S.set=(ElemType*)realloc(S.set,2*S.MaxSize*k);
if(S.set==NULL)
{
cout<<"EXIT!"<<endl;
exit(1);
}
S.MaxSize=2*S.MaxSize;
}
S.set[S.len]=item;
//在末尾插入新元素
S.len++;
return true;
}
//从集合中删除一个元素
bool DeleteSet(Set& S,ElemType& item)
{
int i;
for(i=0;i<S.len;i++)
{
if(S.set[i]==item) break;
}
if(i<S.len)
{
item=S.set[i];
S.set[i]=S.set[S.len-1];
S.len--;
return true;
}
else return false;
}
//求两个集合的并集
void UnionSet(Set& S1,Set& S2,Set& S)
{
//printf("union");
int i;
if(S.MaxSize<S1.MaxSize)
{
delete []S.set;
S.set=new ElemType[S1.MaxSize];
S.MaxSize=S1.MaxSize;
}
for(i=0;i<S1.len;i++)
S.set[i]=S1.set[i];
S.len=S1.len;
for(i=0;i<S2.len;i++)
InsertSet(S,S2.set[i]);
}
//求两个集合的交集
void InterseSet(Set& S1,Set& S2,Set& S)
{
printf("InterseSetn");
int i;
ElemType x;
S.len=0;
for(i=0;i<S2.len;i++)
{
x=S2.set[i];
if(FindSet(S1,x))
{
S.set[S.len]=x;
S.len++;
if(S.len==S.MaxSize)
{
int k=sizeof(ElemType);
S.set=(ElemType*)realloc(S.set,2*S.MaxSize*k);
S.MaxSize=2*S.MaxSize;
}
}
}
}
//求两个集合的差集
void DifferenceSet(Set& S1,Set& S2,Set& S)
{
printf("DifferenceSetn");
int i;
ElemType x;
S.len=0;
for(i=0;i<S1.len;i++)
{
x=S1.set[i];
if(!FindSet(S2,x))
//用S1中的每个元素去查找S2集合
{
S.set[S.len]=x;
S.len++;
if(S.len==S.MaxSize)
{
int k=sizeof(ElemType);
S.set=(ElemType*)realloc(S.set,2*S.MaxSize*k);
S.MaxSize=2*S.MaxSize;
}
}
}
}
int main()
{
Set S;
InitSet(S);
int i=0;
ElemType x;
for(;i<S.MaxSize;i++)
{
cout<<"type the num: ";
cin>>x;
InsertSet(S,x);
}
OutputSet(S);
//判断一个元素是是否属于集合
cout<<"type the find item: ";
cin>>x;
if(InSet(S,x))
cout<<x<<" in set"<<endl;
else
cout<<x<<" not in set"<<endl;
//向集合中插入一个元素
cout<<"type the insert item: ";
cin>>x;
if(InSet(S,x))
cout<<"NO"<<endl;
else
InsertSet(S,x);
OutputSet(S);
//集合中删除一个元素
cout<<"type the delete item: ";
cin>>x;
if(InSet(S,x))
{
cout<<"yes"<<endl;
DeleteSet(S,x);
}
else
cout<<x<<"not in set"<<endl;
OutputSet(S);
//交差并集
Set S1;
Set S3;
Set S4;
Set S5;
InitSet(S1);
InitSet(S3);
InitSet(S4);
InitSet(S5);
int j=0;
ElemType y;
for(;j<S1.MaxSize;j++)
{
cout<<"type the num: ";
cin>>y;
InsertSet(S1,y);
}
OutputSet(S1);
//求并集
cout<<"union: ";
UnionSet(S,S1,S3);
OutputSet(S3);
//交集
cout<<"jiaoji: ";
InterseSet(S,S1,S4);
OutputSet(S4);
//差集
cout<<"chaji: ";
DifferenceSet(S,S1,S5);
OutputSet(S5);
}

六、回文数

#include<iostream>
#include<stdlib.h>
#include<string.h>
using namespace std;
//定义元素类型为
typedef int ElemType;
//定义链栈
struct SNode
{
ElemType data;//存栈元素
SNode* next; //指针域
};
//初始化栈
void Initstack(SNode*& S)
{
S=NULL; //链栈置空
}
//入栈操作
void Push(SNode*& S,ElemType item)
{
SNode* newnode=new SNode;//定义一个新节点
newnode->data=item;//赋给数据域
newnode->next=S;//赋给指针域
S=newnode;
//printf(S);
}
//出栈操作
ElemType Pop(SNode*& S)
{
if(S==NULL)
{
printf("the stack is empty");
}
SNode* p=S;//把栈顶赋给p，因为栈顶指针不可随意移动
S=S->next; //栈顶指针下移
ElemType temp=p->data;//把要删除元素数据域赋给temp
delete p;
return temp;
}
//读取栈顶元素
ElemType Peek(SNode* S)
{
if(S==NULL)
{
printf("the stack is empty");
}
return S->data;
}
//判栈是否为空
bool emptyS(SNode*& S)
{
return S==NULL;
}
//遍历一个链栈
void TraverseStack(SNode*& S)
{
SNode* s=S;
while(s!=NULL){
cout<<s->data<<' ';
s=s->next;
}
}
//清除链栈为空
void clearS(SNode*& S)
{
SNode *cp,*np; //cp栈顶，np栈底
cp=S;
while(cp!=NULL)
{
np=cp->next;
delete cp;
cp=np;
}
S=NULL;
}
int main()
{
SNode* S;
Initstack(S);
int x;
cout<<"Please type num:";
cin>>x;
int ch[20];
int i=0;
/*do
{
Push(S,x);
ch[i]=x;
i++;
cout<<"Please type num:";
cin>>x;
}while(x!=-1);*/
while(x!=-1)
{
Push(S,x);
ch[i]=x;
i++;
cout<<"Please type num:";
cin>>x;
}
TraverseStack(S);
cout<<endl;
int j=0;
int k=0;
while(!emptyS(S))
{
if(ch[j]!=Pop(S))
{
printf("this is stack!n");
k=0;
break;
}
else k=1;
j++;
}
if(k==0)
printf("NOT the huiwen!");
else
printf("IS the huiwen!");
clearS(S);
}

七、括号匹配

在这里插入代码片#include<stdio.h>
#include<iostream>
#include<stdlib.h>
#include<string>
using namespace std;
using std::string;
typedef int ElemType;
//定义一个顺序栈
struct
Stack
{
ElemType *stack;
int top;
int Maxsize;
};
//初始化栈
void InitStack(Stack &S)
{
S.Maxsize=10;
S.stack=new ElemType[S.Maxsize];
if(!S.stack)
{
printf("False!");
}
S.top=-1;//初始化栈顶指针
}
//元素入栈
void Push(Stack &S,ElemType item)
{
if(S.top==S.Maxsize-1)
{
int k=sizeof(ElemType);
S.stack=(ElemType*)realloc(S.stack,2*S.Maxsize*k);
S.Maxsize=2*S.Maxsize;
}
S.top++;//栈顶指针后移
S.stack[S.top]=item;//元素插入到栈顶
}
//元素出栈并返回
ElemType Pop(Stack &S)
{
if(S.top==-1)
printf("the Stack is empty!n");
S.top--;//元素退栈
return S.stack[S.top+1];
}
//判栈空
bool emptyS(Stack S)
{
return S.top==-1;
}
//读取栈顶元素
ElemType Peek(Stack &S)
{
if(S.top==-1)
printf("the Stack is empty!n");
return S.stack[S.top];
}
//清除栈
void ClearS(Stack &S)
{
//cout<<"8888888"<<endl;
if(S.stack)
{
delete[] S.stack;
S.stack=0;
}
S.top=-1;
S.Maxsize=0;
}
//判断匹配
bool suit(Stack &S,string ch)
{
int i=0;
int j,k;
for(;i<ch.length();i++)
{
j=i+1;
switch(ch[i])
{
case '{':
case '[':
case '(':
Push(S,ch[i]);
break;
case '}':
if(Peek(S)!='{')
return false;
else{
Pop(S);
if(ch[j]=='')
return true;
}
break;
case ']':
if(Peek(S)!='[')
return false;
else{
Pop(S);
if(ch[j]=='')
return true;
}
break;
case ')':
if(Peek(S)!='(')
return false;
else{
Pop(S);
if(ch[j]=='')
return true;
}
break;
default:
break;
}
}
}
//测试函数，括号匹配
int main()
{
Stack S;
InitStack(S);
string ch;
cout<<"please type: ";
cin>>ch;
if(suit(S,ch))
cout<<"yes suit"<<endl;
else
cout<<"NO suit"<<endl;
ClearS(S);
}