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

 

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

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

3.已知A【n】中的元素为整形。设计算法将其调整为左右两部分。左边所有元素为奇数，右边所有元素为偶数，

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

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

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

 

 

我写的代码如下

 

1 、

/*
要求 :判断一个顺序表是否对称
*/
#include
using namespace std ;
#define MAX_SIZE 200 
template  
bool  IsSymmetrical(T List[],int length);    //利用模板可以比较任意类型的顺序表
void main()
{ 
 int group= 0;
 bool *pGroup=NULL;//保存的是比较的结果
 int *pNum =NULL;  //这里以整形顺序表为例
 int nCount=0 ;//每组数据的个数
 //cout<<"请输入要比较几组数据:"<  cin>>group;
 pGroup=new bool[group] ;  //动态分配数组内存保存对称比较结果
 for(int n=0;n  { 
  cin>>nCount ;
  pNum=new int[nCount] ;  //动态为每行数据分配内存
  for(int m=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(T List[],int length)    //利用模板可以比较任意类型的顺序表
{  
 int l=0;
 for(int n=0;n<=length-1;n++)
  if(List[n]==List[length-1-n])
   l++ ;
  if(l==length)
   return true ;
  return false ;
}

 

 

 

 

 

2、

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

向量即STL中的vector  动态数组

时间原因这里我只弄了一个线性表来循环移动算法在下面注释部分  需要像第一题多组输入的时候只需要将整个实现部分放在一个循环中实现即可
*/
#include
#include
using namespace std ;
#include "windows.h"
struct Node   //节点数据
{
 int data;
};
void main() 
{  
 vector List;   //向量的定义
 int size ;//接收输入的大小
 cout<<"请输入表中初始数据的个数:"<  cin>>size ;
 Node *pArray=NULL ;//接受输入的数据
 pArray=new Node[size] ;
 for(int n=0;n  {  
  cout<<"请输入第"<   cin>>pArray[n].data ;
  List.push_back(pArray[n]) ;  //插入数据
 }
 vector::iterator p=List.begin() ;//返回迭代器 我们可以通过迭代器访问vector
 system("cls");//清除屏幕
 cout<<"初始表中数据如下:"<  for(n=0;n   cout<  cout<  cout<<"数据输入完成请输入要向右移动的位置k:"<  int move ;  //要移动的位置
 cin>>move ;
 move=move%size ;  //取模
 Node tem ;
 List.insert(p,move,tem) ;  //在前面插入5个临时节点 
        p=List.begin();  //迭代到第一个节点
 算法实现部分
 size=List.size();int m=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(个数)   1 2 3 4 5
结果    1 3 5 2 4    然后根据提示继续输入下一组
      
*/
#include
using namespace std;
#define MAX_SIZE 100
void SetArray(int arr[],int length) ;//算法实现函数
void main()
{
 
   cout<<"\t\t\t操作例子 "<回车  "<回车结束"<    cout<<"\t\t\t结果输出   1 3 5 2 4 -->显示结果然后继续输入下组"<     int *pArray=NULL;//动态数组指针
 int nCount=0;//每行数组的个数
 int group=0;
 cout<<"请输入组数:"<  cin>>group;
 for(int i=0;i  {
 cout<<"请输入"<<"第"<  cin>>nCount;  //输入个数
 pArray=new int[nCount] ;
 for(int n=0;n   cin>>pArray[n];
 SetArray(pArray,nCount);  //调用设置函数  改变奇数偶数位置
 for(n=0;n   cout<  cout<  delete []pArray ;  //释放堆中内存
 }
 
 
}

void SetArray(int arr[],int length) //算法实现函数
{
 char buf1[MAX_SIZE] ;
 char buf2[MAX_SIZE] ;
 memset(buf1,'*',MAX_SIZE);  //存放奇数
 memset(buf2,'*',MAX_SIZE);//存放偶数
 buf2[MAX_SIZE-1]='\0';
 buf1[MAX_SIZE-1]='\0';  //防止越界
 for(int n=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
using namespace std ;
typedef struct Node   //链表节点
{
 int data  ;
 struct Node*next ;
}*Head,*LinkNode;
Head head;//头结点
int length=0 ;
Head CreatLinkList() ; //自定义带头链表创建函数
void  Reserve(Head head)  ; //反序算法的实现 其实是实现数据的反序
void Show(Head head) ;//显示函数
void main()
{  
 int group ;
 cout<<"请输入要反序的链表组数"<  cin>>group ;
 Head *pLink=new Head[group];  //保存链表头
 cout<<"输入链表的数据,数据之间空格分开,以66666结束每组输入例如:  1 2 3 4 5 66666->回车"<  for(int n=0;n  {  
  head=CreatLinkList();//创建链表
  Reserve(head) ;
  pLink[n]=head ;
     length =0;
 }
 cout<<"反序后:"<     cout<<"<------------------------->"<  for( n=0;n   Show(pLink[n]);
    cout<<"<------------------------->"<

  
 }
void  Reserve(Head head)   //反序算法的实现 其实是实现数据的反序
{
 int count=length/2 ;  //比较次数
 LinkNode p1=head,p2=head ;
 int tem ;
 for(int n=0;n  {        
  for(int m=0;m    p2=p2->next ;
  tem=p1->data ;
  p1->data=p2->data ;
  p2->data=tem ;
  p1=p1->next ;
  p2=head ;
 }
}
void Show(Head head) //显示函数
{
 while(head!=NULL)
 {
  cout<data<<" ";
  head=head->next;
 }
 cout< }
Head CreatLinkList()  //自定义带头链表创建函数
{
 LinkNode p1=NULL,p2=NULL,head =NULL ;
 p1=new Node ; 
 head=p1 ;
 p2=p1 ;
 length++;
 cin>>p1->data ;
 if(p1->data==66666)
 {
  delete p1 ; p1=NULL ;  p2=NULL;
  length--;
  return NULL ;
 }
 while(p1->data!=66666)
 {
  p2=p1 ;
  p1=new Node ;
  length++;
  cin>>p1->data ;
  if(p1->data==66666)
  {
   delete p1 ; p1=NULL ;  p2->next=NULL;
   length--;
   return head ;
  }
  p2->next=p1 ;
 }
 
 return head ;
}

 

 

5、

 

 

/*
单链表以非递减有序排列，设计算法实现在单链表中删去值相同的多余结点， 
算法实现 就是用2个循环遍历链表  算法实现在下注释部分
*/
#include
using namespace std ;
typedef struct Node   //链表节点
{
 int data  ;
 struct Node*next ;
}*Head,*LinkNode;
Head head ;//头结点
Head CreatLinkList()  ;//自定义带头链表创建函数
void Delete(Head head) ;  //删除重复的节点算法实现部分。。。。
void Show(Head head) ;//显示函数
void main()
{  
 head=CreatLinkList() ;
 system("cls");
 cout<<"表中数据如下:"<  Show(head) ;
 Delete(head) ; //删除重复节点
 cout<<"删除重复节点后的链表:"<  Show(head) ;
}

Head CreatLinkList()  //自定义带头链表创建函数
{
 LinkNode p1=NULL,p2=NULL,head =NULL ;
 p1=new Node ; 
 head=p1 ;
 p2=p1 ;
 cout<<"请输入链表节点数据,数据间空格分开 输入66666结束输入 例如  1 2 3 4 5 66666"<  cin>>p1->data ;
 if(p1->data==66666)
 {
  delete p1 ; p1=NULL ;  p2=NULL;
  return NULL ;
 }
 while(p1->data!=66666)
 {
  p2=p1 ;
  p1=new Node ;
  cin>>p1->data ;
  if(p1->data==66666)
  {
   delete p1 ; p1=NULL ;  p2->next=NULL;
   return head ;
  }
  p2->next=p1 ;
 }
 return head ;
}
/
void Delete(Head head)   //删除重复的节点算法实现部分。。。。
{
 Head p1=head,p2=head ; 
 LinkNode tem=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 ;
    delete tem ;
    continue ;
   }
   else
   p2=p2->next ;
  }
  p1=p1->next;
  p2=p1 ;
 }
}
///
void Show(Head head) //显示函数
{
 while(head!=NULL)
 {
  cout<data<<" ";
  head=head->next;
 }
 cout< }

 

 

6、

/*
6假设有两个按元素值递增有序排列的线性表A和B，均以单链表作存储结构，
是编写算法将A表和B表归并成一个按元素值递减有序排列的线性表C，并要求利用原表的结点空间存放C
<---------在输入数据的时候一定要按递增输入数据 ------>
*/
#include
using namespace std ;
typedef struct Node   //链表节点
{
 int data  ;
 struct Node*next ;
}*Head,*LinkNode;
LinkNode A =NULL;//表1
LinkNode B =NULL;//表2
LinkNode C=NULL; //表3
int GetMax(Head head);  //返回链表中的最大数据
Head CreatLinkList()  ;//自定义带头链表创建函数
Head  CombineLinkList(Head A,Head B) ; //合并算法的实现部分
void Show(Head head) ;//显示函数
void main()
{
    cout<<"表A:"<  A=CreatLinkList();  //创建表A
    cout<<"表B:"<  B=CreatLinkList(); //创建表B
 C=CombineLinkList(A,B) ;
    Show(C);
}
Head  CombineLinkList(Head A,Head B)  //合并算法的实现部分
{
      
   LinkNode tem=A ;
      while(tem->next!=NULL)
   {
    tem=tem->next;
   }
   tem->next=B ;
   C=A  ;//A B 表连接起来 然后 降序排序
   LinkNode p1=C;
      LinkNode p2=C->next;
   int inter=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;
}
void Show(Head head) //显示链表函数
{
 while(head!=NULL)
 {
  cout<data<<" ";
  head=head->next;
 }
 cout< }
int GetMax(Head head)  //返回链表中的最大数据
{
    while(head->next!=NULL)
  head=head->next ;
 return head->data;
}
Head CreatLinkList()  //自定义带头链表创建函数
{
 LinkNode p1=NULL,p2=NULL,head =NULL ;
 p1=new Node ; 
 head=p1 ;
 p2=p1 ;
 cout<<"请输入链表节点数据,数据间空格分开 输入66666结束输入 例如  1 2 3 4 5 66666"<  cin>>p1->data ;
 if(p1->data==66666)
 {
  delete p1 ; p1=NULL ;  p2=NULL;
  return NULL ;
 }
 while(p1->data!=66666)
 {
  p2=p1 ;
  p1=new Node ;
  cin>>p1->data ;
  if(p1->data==66666)
  {
   delete p1 ; p1=NULL ;  p2->next=NULL;
   return head ;
  }
  p2->next=p1 ;
 }
 return head ;
}

 

 

 

 

转载于:https://www.cnblogs.com/mosatsu/archive/2011/11/13/2466855.html