6个有趣的数据结构算法的题.docx

6个有趣的数据结构算法的题.docx

《6个有趣的数据结构算法的题.docx》由会员分享，可在线阅读，更多相关《6个有趣的数据结构算法的题.docx（15页珍藏版）》请在冰豆网上搜索。

6个有趣的数据结构算法的题

今天给同学写5个数据结构算法的题...感觉很有价值的几个题..感兴趣的坐下。

。

1.判断一个顺序表是否对称

2用向量作存储结构，设计以算法仅用一个辅助结点，实现将线性表中的结点循环右移k位的运算

3.已知A【n】中的元素为整形。

设计算法将其调整为左右两部分。

左边所有元素为奇数，右边所有元素为偶数，

4，设计以算法，逆置带头结点的动态链表L，

5单链表以非递减有序排列，设计算法实现在单链表中删去值相同的多余结点，

6假设有两个按元素值递增有序排列的线性表A和B，均以单链表作存储结构，是编写算法将A表和B表归并成一个按元素值递减有序排列的线性表C，并要求利用原表的结点空间存放C

我写的代码如下

1、

/*

要求:

判断一个顺序表是否对称

*/

#include

usingnamespacestd;

#defineMAX_SIZE200 

template 

bool IsSymmetrical（TList[],intlength）;   //利用模板可以比较任意类型的顺序表

voidmain（）

{ 

 intgroup=0;

 bool*pGroup=NULL;//保存的是比较的结果

 int*pNum=NULL; //这里以整形顺序表为例

 intnCount=0;//每组数据的个数

 //cout<<"请输入要比较几组数据:

"<

 cin>>group;

 pGroup=newbool[group]; //动态分配数组内存保存对称比较结果

 for（intn=0;n

 { 

  cin>>nCount;

  pNum=newint[nCount]; //动态为每行数据分配内存

  for（intm=0;m

   cin>>pNum[m]; 

  pGroup[n]=IsSymmetrical（pNum,nCount） ;//直接将函数返回结果的bool值保存在动态分配的数组中

  delete[]pNum;//第一组内存使用完毕释放掉防止内存泄露

 } 

 for（n=0;n

 {

  if（pGroup[n]）

   cout<<"Y"<

  else

   cout<<"N"<

 }

 delete[]pGroup; //最后再次释放堆内存

}

template 

bool IsSymmetrical（TList[],intlength）   //利用模板可以比较任意类型的顺序表

{  

 intl=0;

 for（intn=0;n<=length-1;n++）

  if（List[n]==List[length-1-n]）

   l++;

  if（l==length）

   returntrue;

  returnfalse;

}

2、

/*

要求:

用向量作存储结构，设计以算法仅用一个辅助结点，实现将线性表中的结点循环右移k位的运算 

向量即STL中的vector 动态数组

时间原因这里我只弄了一个线性表来循环移动算法在下面注释部分 需要像第一题多组输入的时候只需要将整个实现部分放在一个循环中实现即可

*/

#include

#include

usingnamespacestd;

#include"windows.h"

structNode  //节点数据

{

 intdata;

};

voidmain（） 

{  

 vectorList;  //向量的定义

 intsize;//接收输入的大小

 cout<<"请输入表中初始数据的个数:

"<

 cin>>size;

 Node*pArray=NULL;//接受输入的数据

 pArray=newNode[size];

 for（intn=0;n

 {  

  cout<<"请输入第"<

"<

  cin>>pArray[n].data;

  List.push_back（pArray[n]）; //插入数据

 }

 vector:

:

iteratorp=List.begin（）;//返回迭代器我们可以通过迭代器访问vector

 system（"cls"）;//清除屏幕

 cout<<"初始表中数据如下:

"<

 for（n=0;n

  cout<

 cout<

 cout<<"数据输入完成请输入要向右移动的位置k:

"<

 intmove; //要移动的位置

 cin>>move;

 move=move%size; //取模

 Nodetem;

 List.insert（p,move,tem）; //在前面插入5个临时节点 

       p=List.begin（）; //迭代到第一个节点

 ////////////////////////////////////////算法实现部分

 size=List.size（）;intm=0; 

 for（n=size-move,m=0;n

  p[m]=p[n];

   for（n=0;n

  List.pop_back（）;//pop出尾部元素

   ///////////////////////////////////

 p=List.begin（）;

 cout<<"右移后元素位置:

"<

 for（n=0;n

       cout<

 cout<

}

3、

/*

3.已知A【n】中的元素为整形。

设计算法将其调整为左右两部分。

左边所有元素为奇数，右边所有元素为偶数，

操作例子

组数   2 

第一组 5（个数）  12345

结果   13524   然后根据提示继续输入下一组

*/

#include

usingnamespacestd;

#defineMAX_SIZE100

voidSetArray（intarr[],intlength）;//算法实现函数

voidmain（）

{

  cout<<"\t\t\t操作例子"<回车 "<回车结束"<

  cout<<"\t\t\t结果输出  13524-->显示结果然后继续输入下组"<

   int*pArray=NULL;//动态数组指针

 intnCount=0;//每行数组的个数

 intgroup=0;

 cout<<"请输入组数:

"<

 cin>>group;

 for（inti=0;i

 {

 cout<<"请输入"<<"第"<

5   12345"<

 cin>>nCount; //输入个数

 pArray=newint[nCount];

 for（intn=0;n

  cin>>pArray[n];

 SetArray（pArray,nCount）; //调用设置函数 改变奇数偶数位置

 for（n=0;n

  cout<

 cout<

 delete[]pArray; //释放堆中内存

 }

}

voidSetArray（intarr[],intlength）//算法实现函数

{

 charbuf1[MAX_SIZE];

 charbuf2[MAX_SIZE];

 memset（buf1,'*',MAX_SIZE）; //存放奇数

 memset（buf2,'*',MAX_SIZE）;//存放偶数

 buf2[MAX_SIZE-1]='\0';

 buf1[MAX_SIZE-1]='\0'; //防止越界

 for（intn=0,m=0,i=0;n

 {

  if（arr[n]%2==0）

  {

   buf2[m]='0'+arr[n]; //保存偶数asc码

   m++;

  }

  else

  { 

           buf1[i]='0'+arr[n];//保存奇数asc码

   i++;

  }

 }

  for（n=0,m=0,i=0;n

  {

   if（buf1[m]!

='*'）

   { 

    arr[n]=buf1[m]-'0';

    m++;

   }

   else

   {

    arr[n]=buf2[i]-'0';

    i++;

   }

  }

}

4、

/*

，设计以算法，逆置带头结点的动态链表L，

先创建链表然后 进行反序

*/

#include

usingnamespacestd;

typedefstructNode  //链表节点

{

 intdata ;

 structNode*next;

}*Head,*LinkNode;

Headhead;//头结点

intlength=0;

HeadCreatLinkList（）;//自定义带头链表创建函数

void Reserve（Headhead） ;//反序算法的实现其实是实现数据的反序

voidShow（Headhead）;//显示函数

voidmain（）

{  

 intgroup;

 cout<<"请输入要反序的链表组数"<

 cin>>group;

 Head*pLink=newHead[group]; //保存链表头

 cout<<"输入链表的数据,数据之间空格分开,以66666结束每组输入例如:

 1234566666->回车"<

 for（intn=0;n

 {  

  head=CreatLinkList（）;//创建链表

  Reserve（head）;

  pLink[n]=head;

    length=0;

 }

 cout<<"反序后:

"<

   cout<<"<------------------------->"<

 for（n=0;n

  Show（pLink[n]）;

   cout<<"<------------------------->"<

 }

void Reserve（Headhead）  //反序算法的实现其实是实现数据的反序

{

 intcount=length/2; //比较次数

 LinkNodep1=head,p2=head;

 inttem;

 for（intn=0;n

 {        

  for（intm=0;m

   p2=p2->next;

  tem=p1->data;

  p1->data=p2->data;

  p2->data=tem;

  p1=p1->next;

  p2=head;

 }

}

voidShow（Headhead）//显示函数

{

 while（head!

=NULL）

 {

  cout<data<<"";

  head=head->next;

 }

 cout<

}

HeadCreatLinkList（） //自定义带头链表创建函数

{

 LinkNodep1=NULL,p2=NULL,head=NULL;

 p1=newNode; 

 head=p1;

 p2=p1;

 length++;

 cin>>p1->data;

 if（p1->data==66666）

 {

  deletep1;p1=NULL; p2=NULL;

  length--;

  returnNULL;

 }

 while（p1->data!

=66666）

 {

  p2=p1;

  p1=newNode;

  length++;

  cin>>p1->data;

  if（p1->data==66666）

  {

   deletep1;p1=NULL; p2->next=NULL;

   length--;

   returnhead;

  }

  p2->next=p1;

 }

 returnhead;

}

5、

/*

单链表以非递减有序排列，设计算法实现在单链表中删去值相同的多余结点， 

算法实现就是用2个循环遍历链表 算法实现在下注释部分

*/

#include

usingnamespacestd;

typedefstructNode  //链表节点

{

 intdata ;

 structNode*next;

}*Head,*LinkNode;

Headhead;//头结点

HeadCreatLinkList（） ;//自定义带头链表创建函数

voidDelete（Headhead）; //删除重复的节点算法实现部分。

。

。

。

voidShow（Headhead）;//显示函数

voidmain（）

{  

 head=CreatLinkList（）;

 system（"cls"）;

 cout<<"表中数据如下:

"<

 Show（head）;

 Delete（head）;//删除重复节点

 cout<<"删除重复节点后的链表:

"<

 Show（head）;

}

HeadCreatLinkList（） //自定义带头链表创建函数

{

 LinkNodep1=NULL,p2=NULL,head=NULL;

 p1=newNode; 

 head=p1;

 p2=p1;

 cout<<"请输入链表节点数据,数据间空格分开输入66666结束输入例如 1234566666"<

 cin>>p1->data;

 if（p1->data==66666）

 {

  deletep1;p1=NULL; p2=NULL;

  returnNULL;

 }

 while（p1->data!

=66666）

 {

  p2=p1;

  p1=newNode;

  cin>>p1->data;

  if（p1->data==66666）

  {

   deletep1;p1=NULL; p2->next=NULL;

   returnhead;

  }

  p2->next=p1;

 }

 returnhead;

}

/////////////////////////////////////////////////////////////////////////////////

voidDelete（Headhead）  //删除重复的节点算法实现部分。

。

。

。

{

 Headp1=head,p2=head; 

 LinkNodetem=NULL; //临时节点指针

 while（p1!

=NULL）

 {

  while（p2->next!

=NULL）//当p2的next到达尾部的时候后就要推出否则 下面p2->next->next会崩溃

  { 

   if（p2->next->data==p1->data）

   {

    tem=p2->next;

    p2->next=p2->next->next;

    deletetem;

    continue;

   }

   else

   p2=p2->next;

  }

  p1=p1->next;

  p2=p1;

 }

}

///////////////////////////////////////////////////////////////////////////////////

voidShow（Headhead）//显示函数

{

 while（head!

=NULL）

 {

  cout<data<<"";

  head=head->next;

 }

 cout<

}

6、

/*

6假设有两个按元素值递增有序排列的线性表A和B，均以单链表作存储结构，

是编写算法将A表和B表归并成一个按元素值递减有序排列的线性表C，并要求利用原表的结点空间存放C

<---------在输入数据的时候一定要按递增输入数据------>

*/

#include

usingnamespacestd;

typedefstructNode  //链表节点

{

 intdata ;

 structNode*next;

}*Head,*LinkNode;

LinkNodeA=NULL;//表1

LinkNodeB=NULL;//表2

LinkNodeC=NULL;//表3

intGetMax（Headhead）; //返回链表中的最大数据

HeadCreatLinkList（） ;//自定义带头链表创建函数

Head CombineLinkList（HeadA,HeadB）;//合并算法的实现部分

voidShow（Headhead）;//显示函数

voidmain（）

{

   cout<<"表A:

"<

 A=CreatLinkList（）; //创建表A

   cout<<"表B:

"<

 B=CreatLinkList（）;//创建表B

 C=CombineLinkList（A,B）;

   Show（C）;

}

Head CombineLinkList（HeadA,HeadB） //合并算法的实现部分

{

  LinkNodetem=A;

     while（tem->next!

=NULL）

  {

   tem=tem->next;

  }

  tem->next=B;

  C=A ;//AB表连接起来然后降序排序

  LinkNodep1=C;

     LinkNodep2=C->next;

  intinter=C->data;//用于交换的临时变量

  while（p1->next!

=NULL）

  {

        while（p2!

=NULL）

  {

          if（p2->data>p1->data） //交换数据

    {

     inter=p1->data;

     p1->data=p2->data;

     p2->data=inter;

    }

    p2=p2->next;

  }

   p1=p1->next;

   p2=p1->next;

  }

 return C;

}

voidShow（Headhead）//显示链表函数

{

 while（head!

=NULL）

 {

  cout<data<<"";

  head=head->next;

 }

 cout<

}

intGetMax（Headhead） //返回链表中的最大数据

{

   while（head->next!

=NULL）

  head=head->next;

 returnhead->data;

}

HeadCreatLinkList（） //自定义带头链表创建函数

{

 LinkNodep1=NULL,p2=NULL,head=NULL;

 p1=newNode; 

 head=p1;

 p2=p1;

 cout<<"请输入链表节点数据,数据间空格分开输入66666结束输入例如 1234566666"<

 cin>>p1->data;

 if（p1->data==66666）

 {

  deletep1;p1=NULL; p2=NULL;

  returnNULL;

 }

 while（p1->data!

=66666）

 {

  p2=p1;

  p1=newNode;

  cin>>p1->data;

  if（p1->data==66666）

  {

   deletep1;p1=NULL; p2->next=NULL;

   returnhead;

  }

  p2->next=p1;

 }

 returnhead;

}