求助:关于数据结构的一个题目,帮小弟解决哈!(急!)

作者：秋林学士_809 | 来源：互联网 | 2023-09-23 16:12

基本要求：1初始化一个顺序表2实现插入算法a插入第i个元素，分别将2468101214依次插入到顺序表中b有

基本要求：1 初始化一个顺序表
          2 实现插入算法
          a 插入第i个元素，分别将2 4 6 8 10 12 14依次插入到顺序表中
          b 有一个已按递增次序排好序的线形表，今输入一个数，要求按原来的排序规律将它插入到线形表中
       提示：编写一个顺序表的插入函数，在测试时，可按递增次序输入数据，然后从菜单中选择所新建的函数
          3 实现线形表的删除算法
          a 删除第i个元素
          b 删除数据为x的元素
          4 已知一个线形表，用另辟空间和利用原表两种防哪个法把线形表逆置

要编一个完整能执行的程序,实现以上功能!

多谢各位兄弟!

13 个解决方案

#1

#include
#include
typedef struct Node{
   int data;
   struct Node *next;
}*Node;

void Create(struct Node **head)
{
   int a;
   struct Node *tail, *p;
   printf("please input data end of 0.\n");
   scanf("%d",&a);
   p       = (struct Node *) malloc (sizeof(struct Node));
   p->data = a;
   p->next = *head;
   *head   = p;
   tail    = p;
   scanf("%d", &a);
   while(a)
   {

      p          = (struct Node *) malloc (sizeof(struct Node));
      p->data    = a;
      p->next    = NULL;
      tail->next = p;
      tail       = p;
      scanf("%d",&a);
   }
}

int Length(Node p)
{
  int len = 0;
  while ( p != NULL)
  {
  len++;
  p = p->next;
  }
  return len;
}

void Display(Node p)
{
   while(p != NULL )
   {
      printf("  %d",p->data);
      p = p->next;
   }
   printf("\n");
}

struct Node  *Fun(struct Node *a, struct Node *b)
{
   int len1 = 0, len2 = 0;
   struct Node *p,*p1= NULL,*p2;
   len1 = Length(a);
   len2 = Length(b);
   if ( len1 != len2)
   {
    printf("Error\n");
    return NULL;
   }
   else
   {
p       = (struct Node *) malloc(sizeof(struct Node));
p->data = a->data ^ b->data;
p->next = p1;
p1      = p;
p2      = p;
a       = a->next;
b       = b->next;
while ( a != NULL && b != NULL)
{
    p        = (struct Node *) malloc (sizeof(struct Node));
    p->data  = a->data ^ b->data;
    p->next  = NULL;
    p2->next = p;
    p2       = p;
    a        = a->next;
    b        = b->next;
}
   }
   return p1;
}

void Del(struct Node **p)
{
   struct Node *a;
   while(*p)
   {
     a  = (*p)->next;
     free(*p);
     *p = a;
   }
}

main()
{
  int a;
  struct Node *p = NULL ,*p1 = NULL, *p2;
  clrscr();
  Create(&p);
  Create(&p1);
  p2 = Fun(p,p1);
  Display(p2);
  Del(&p);
  Del(&p1);
  Del(&p2);
  printf("\n");
  system("pause");
}

/* 给你一个链表的程序参考一下, 兄弟要记得自己动手写呀这样才会提高  */

#2

#include
using namespace std;
const int MAXLISTSIZE=100;
template
class SeqList
{
  DataType data[MAXLISTSIZE];
  int size;
public:
  SeqList();
  ~SeqList();
  int GetSize()const;
  bool IsEmpty()const;
  int FindElement(DataType &item)const;
  DataType GetData(int pos)const;
  void InsertItem(const DataType &item,int pos);
  DataType DeleteItem(int pos);
  void ClearSeq();
  void ShowSeq()const;
};
template
SeqList::SeqList(){size=0;}
template
SeqList::~SeqList(){}
template
int SeqList::GetSize()const
{
  return size;
}
template
bool SeqList::IsEmpty()const
{
  return size?false:true;
}
template
int SeqList::FindElement(DataType &item)const
{
  if(size)
  {
    for(int i=0;i     {
        if(data==item)return i;
    }
  }
  return -1;
}
template
DataType SeqList::GetData(int pos)const
{
  if(pos<0││pos>size-1)exit(1);
  else return data[pos];
}
template
void SeqList::InsertItem(const DataType &item,int pos)
{
  if(size==MAXLISTSIZE){cout<<"操作失败,空间已满!"<   if(pos<0││pos>size){cout<<"操作失败,下标不对!"<   for(int i=size;i>pos;i--)data=data[i-1];
  data[pos]=item;
  size++;
  return ;
}
template
DataType SeqList::DeleteItem(int pos)
{
  if(!size){cout<<"操作失败,空间已空!"<   if(pos<0││pos>size-1){cout<<"操作失败,下标不对!"<   DataType temp=data[pos];
  for(int i=pos;i   size--;
  return temp;
}
template
void SeqList::ClearSeq()
{
  size=0;
}
template
void SeqList::ShowSeq()const
{
  for(int i=0;i   cout<   cout< }
int main()
{
  int i;
  SeqList sl;
  for(i=0;i<6;i++)sl.InsertItem(i+1,i);
  for(i=0;i<6;i++)cout<   cout<   sl.ShowSeq();
  for(i=0;i<6;i++)cout<   cout<      cout<   sl.ShowSeq();
  system("PAUSE");
  return 0;
}
    #include
using namespace std;
const int MAXLISTSIZE=100;
template
class SeqList
{
  DataType data[MAXLISTSIZE];
  int size;
public:
  SeqList();
  ~SeqList();
  int GetSize()const;
  bool IsEmpty()const;
  int FindElement(DataType &item)const;
  DataType GetData(int pos)const;
  void InsertItem(const DataType &item,int pos);
  DataType DeleteItem(int pos);
  void ClearSeq();
  void ShowSeq()const;
};
template
SeqList::SeqList(){size=0;}
template
SeqList::~SeqList(){}
template
int SeqList::GetSize()const
{
  return size;
}
template
bool SeqList::IsEmpty()const
{
  return size?false:true;
}
template
int SeqList::FindElement(DataType &item)const
{
  if(size)
  {
    for(int i=0;i     {
        if(data==item)return i;
    }
  }
  return -1;
}
template
DataType SeqList::GetData(int pos)const
{
  if(pos<0││pos>size-1)exit(1);
  else return data[pos];
}
template
void SeqList::InsertItem(const DataType &item,int pos)
{
  if(size==MAXLISTSIZE){cout<<"操作失败,空间已满!"<   if(pos<0││pos>size){cout<<"操作失败,下标不对!"<   for(int i=size;i>pos;i--)data=data[i-1];
  data[pos]=item;
  size++;
  return ;
}
template
DataType SeqList::DeleteItem(int pos)
{
  if(!size){cout<<"操作失败,空间已空!"<   if(pos<0││pos>size-1){cout<<"操作失败,下标不对!"<   DataType temp=data[pos];
  for(int i=pos;i   size--;
  return temp;
}
template
void SeqList::ClearSeq()
{
  size=0;
}
template
void SeqList::ShowSeq()const
{
  for(int i=0;i   cout<   cout< }
int main()
{
  int i;
  SeqList sl;
  for(i=0;i<6;i++)sl.InsertItem(i+1,i);
  for(i=0;i<6;i++)cout<   cout<   sl.ShowSeq();
  for(i=0;i<6;i++)cout<   cout<      cout<   sl.ShowSeq();
  system("PAUSE");
  return 0;
}

#3

...

既无聊，又没好处的事情都有人抢着做...

#4

感谢楼上的两位了!

太谢谢了!

#5

回复人： nicknide(封月翔天) ( ) 信誉：100
说的没错

作业要自己做啊///这样是进步不了的/

#6

回复人： du51(郁郁思扬)

写的是什么?没看懂!

那位兄弟帮忙吧1楼的修改哈

只要能实现题目的几个功能就可以了!

帮小mm做的,多谢了!

#7

...

既无聊，又没好处的事情都有人抢着做...

就当熟悉熟悉语法啊。

#8

愿意帮忙的多谢了!

不愿意帮的不好说风凉话了谢谢!

#9

我也问一道题,编写构造十字链表的算法,并进一步编写两个用十字链表描素的稀疏矩阵加法算法 ,谢谢

#10

ding

#11

#include
#include
/*结点结构*/
typedef struct sNode{
    int data;
    struct sNode *next;
}Node;
/*链表初始化,因为C中无引用传参,故用指针*/
void InitList(Node *&head)
{
    head=NULL;
}
/*链表的插入函数*/
void InsertList(Node *&head,int item)
{
    Node *q=head,*p=head;
    Node *newnode=(Node *)malloc(sizeof(Node));
    if(!newnode){printf("allocate memory error!\n");return;}
    newnode->data=item;newnode->next=NULL;
if(!head)head=newnode;
else if(head->data>newnode->data)
{
newnode->next=head;
head=newnode;
}
else
{
while(q&&q->datadata){p=q;q=q->next;}
if(!q)p->next=newnode;
else {p->next=newnode;newnode->next=q;}
}
}
void DeleteI(Node *&head,int i)             //从1开始
{
int n=0;Node *p=head,*q=head;
if(i<1||!head){printf("ERROR!\n");return;}
else if(i==1){p=head->next;free(head);head=p;}
else
{
while(q&&nnext;}
if(!q){printf("ERROR!\n");return;}
else {p->next=q->next;free(q);}
}
}
void DeleteX(Node *&head,int X)             //从1开始
{
Node *p=head,*q=head;
if(!head){printf("ERROR!\n");return;}
else if(head->data==X){p=head->next;free(head);head=p;}
else
{
while(q&&q->data-X){p=q;q=q->next;}
if(!q){printf("ERROR!\n");return;}
else {p->next=q->next;free(q);}
}
}
void InsertFirst(Node *&head,int x)
{

    Node *newnode=(Node *)malloc(sizeof(Node));
    if(!newnode){printf("allocate memory error!\n");return;}
    newnode->data=x;newnode->next=NULL;
    if(!head)head=newnode;
    else{
            newnode->next=head;
            head=newnode;
    }
}
void OutputList(Node *head)
{
    Node *p=head;
    if(head)
    {
        while(p){printf("%d",p->data);p=p->next;}
        printf("\n");
    }
}
void DestroyList(Node *&head)
{
    Node *p=head;
    while(head){p=head->next;free(head);head=p;}
}
void ReverseList(Node *&head)
{
    Node *p=head,*head1;
    InitList(head1);
    while(p){InsertFirst(head1,p->data);p=p->next;}
    DestroyList(head);
    head=head1;
}
int main()
{
    Node *head;int i=0;
    InitList(head);
    printf("INPUT YOUR DATA!\n");
    while(1){scanf("%d",&i);if(i==-1)break;InsertList(head,i);}
    OutputList(head);i=0;
    while(i++<3){DeleteI(head,i);OutputList(head);}
    DeleteX(head,3);OutputList(head);
    DeleteX(head,5);OutputList(head);
    DeleteX(head,9);OutputList(head);
    ReverseList(head);
    OutputList(head);
    DestroyList(head);
    system("PAUSE");
    return 0;
}

#12

#include
#include
#define LIST_INIT_SIZE 5
#define LIST_INCREAMENT 2
typedef int Status;
#define ERROR 0
#define OK 1
#define OVERFLOW 2
struct SqList{
int *base,length,listsize;
};
void InitList(SqList &L)
{
L.base=(int *)malloc(sizeof(int)*LIST_INIT_SIZE);
if(!L.base)exit(OVERFLOW);
L.length=0;
L.listsize=LIST_INIT_SIZE;
}
Status ListInsert(SqList &L,int i,int e)
{
int *p,*q;
if(i<1||i>L.length+1)return ERROR;
if(L.length>=L.listsize)
{
L.listsize+=LIST_INCREAMENT;
if(!(L.base=(int *)realloc(L.base,L.listsize*sizeof(int))))
exit(OVERFLOW);
}
if(!L.length){L.base[L.length++]=e;return OK;}
for(p=L.base+L.length-1,q=L.base+i-1;p>=q;p--)*(p+1)=*p;
*q=e;L.length++;
return OK;
}
Status OrderInsert(SqList &L,int e)
{
int *p=L.base,i=0;
if(!L.length)return ListInsert(L,1,e);
while(i {
p=L.base+i;
if(*p>e)break;
i++;
}
return ListInsert(L,i+1,e);
}
Status DelIElem(SqList &L,int i)
{
if(i<1||i>L.length)return ERROR;
for(int j=i+1;j<=L.length;j++)L.base[j-2]=L.base[j-1];
L.length--;
return OK;
}
Status DelXElem(SqList &L,int x)
{
int i=0;
while(i return DelIElem(L,i);
}
Status RevList(SqList &L)
{
int i,temp;
if(!L.base)return ERROR;
for(i=0;i {
temp=L.base[i];
L.base[i]=L.base[L.length-1-i];
L.base[L.length-1-i]=temp;
}
return OK;
}
void DelList(SqList &L)
{
if(L.base)free(L.base);
L.base=0;
L.length=L.listsize=0;
}
Status RevList1(SqList &L)
{
SqList L1,*p=&L;int i;
InitList(L1);
if(!L.base)return ERROR;
for(i=0;i DelList(L);
L=L1;
return OK;
}
void ShowList(SqList L)
{
int i=0;
while(i printf("\n");
}
int main()
{
SqList L,L1;int i;
InitList(L);InitList(L1);
for(i=2;i<17;i+=2)ListInsert(L,1,i);
ShowList(L);
DelXElem(L,6);DelXElem(L,16);DelXElem(L,2);
ShowList(L);
DelIElem(L,1);DelIElem(L,2);
ShowList(L);
for(i=0;i<10;i++)OrderInsert(L1,i);
OrderInsert(L1,-1);OrderInsert(L1,6);OrderInsert(L1,16);
ShowList(L1);
RevList(L1);
ShowList(L1);
RevList1(L1);
ShowList(L1);
DelList(L);
DelList(L1);
system("PAUSE");
return 0;
}

#13

TC下的.
-------------------------------
#include
#include
#define LIST_INIT_SIZE 5
#define LIST_INCREAMENT 2
#define ERROR 0
#define OK 1
#define OVERFLOW 2
typedef int Status;
typedef struct SqListTag{
    int *base,length,listsize;
}SqList;
void InitList(SqList *L)
{
    L->base=(int *)malloc(sizeof(int)*LIST_INIT_SIZE);
    if(!L->base)exit(OVERFLOW);
    L->length=0;
    L->listsize=LIST_INIT_SIZE;
}
Status ListInsert(SqList *L,int i,int e)
{
    int *p,*q;
    if(i<1||i>L->length+1)return ERROR;
    if(L->length>=L->listsize)
    {
        L->listsize+=LIST_INCREAMENT;
        if(!(L->base=(int *)realloc(L->base,L->listsize*sizeof(int))))
        exit(OVERFLOW);
    }
    if(!L->length){L->base[L->length++]=e;return OK;}
    for(p=L->base+L->length-1,q=L->base+i-1;p>=q;p--)*(p+1)=*p;
    *q=e;L->length++;
    return OK;
}
Status OrderInsert(SqList *L,int e)
{
    int *p=L->base,i=0;
    if(!L->length)return ListInsert(L,1,e);
    while(ilength)
    {
        p=L->base+i;
        if(*p>e)break;
        i++;
    }
    return ListInsert(L,i+1,e);
}
Status DelIElem(SqList *L,int i)
{
    int j;
    if(i<1||i>L->length)return ERROR;
    for(j=i+1;j<=L->length;j++)L->base[j-2]=L->base[j-1];
    L->length--;
    return OK;
}
Status DelXElem(SqList *L,int x)
{
    int i=0;
    while(ilength)if(&L->base[i++]==x)break;
    return DelIElem(L,i);
}
Status RevList(SqList *L)
{
    int i,temp;
    if(!L->base)return ERROR;
    for(i=0;ilength-1-i;i++)
    {
        temp=L->base[i];
        L->base[i]=L->base[L->length-1-i];
        L->base[L->length-1-i]=temp;
    }
    return OK;
}
void DelList(SqList *L)
{
    if(&L->base)free(&L->base);
    L->base=0;
    L->length=L->listsize=0;
}
Status RevList1(SqList *L)
{
    SqList *LL;int i;
    InitList(LL);
    if(!L->base)return ERROR;
    for(i=0;ilength;i++)ListInsert(LL,1,L->base[i]);
    DelList(L);
    *L=*LL;
    return OK;
}
void ShowList(SqList L)
{
    int i=0;
    while(i     printf("\n");
}
int main()
{
    SqList *L,*L1;int i;
    InitList(L);InitList(L1);
    for(i=2;i<17;i+=2)ListInsert(L,1,i);
    ShowList(*L);
    DelXElem(L,6);DelXElem(L,16);DelXElem(L,2);
    ShowList(*L);
    DelIElem(L,1);DelIElem(L,2);
    ShowList(*L);
    for(i=0;i<10;i++)OrderInsert(L1,i);
    OrderInsert(L1,-1);OrderInsert(L1,6);OrderInsert(L1,16);
    ShowList(*L1);
    RevList(L1);
    ShowList(*L1);
    RevList1(L1);
    ShowList(*L1);
    DelList(L);
    DelList(L1);
    system("PAUSE");
    return 0;
}

推荐阅读

get
SpringJdbcTemplate的使用详解

本文详细介绍了Spring的JdbcTemplate的使用方法，包括执行存储过程、存储函数的call()方法，执行任何SQL语句的execute()方法，单个更新和批量更新的update()和batchUpdate()方法，以及单查和列表查询的query()和queryForXXX()方法。提供了经过测试的API供使用。 ... [详细]

蜡笔小新 2023-12-13 14:27:11
get
MyBatis多表查询与动态SQL使用

本文介绍了MyBatis多表查询与动态SQL的使用方法，包括一对一查询和一对多查询。同时还介绍了动态SQL的使用，包括if标签、trim标签、where标签、set标签和foreach标签的用法。文章还提供了相关的配置信息和示例代码。 ... [详细]

蜡笔小新 2023-12-12 17:12:51
get
Android开发笔记：使用Picasso加载网络图片等比例缩放

在Android开发中，使用Picasso库可以实现对网络图片的等比例缩放。本文介绍了使用Picasso库进行图片缩放的方法，并提供了具体的代码实现。通过获取图片的宽高，计算目标宽度和高度，并创建新图实现等比例缩放。 ... [详细]

蜡笔小新 2023-12-14 17:34:00
get
向QTextEdit拖放文件的方法及实现步骤

本文介绍了在使用QTextEdit时如何实现拖放文件的功能，包括相关的方法和实现步骤。通过重写dragEnterEvent和dropEvent函数，并结合QMimeData和QUrl等类，可以轻松实现向QTextEdit拖放文件的功能。详细的代码实现和说明可以参考本文提供的示例代码。 ... [详细]

蜡笔小新 2023-12-14 16:06:38
get
CSS3选择器的使用方法详解，提高Web开发效率和精准度

本文详细介绍了CSS3新增的选择器方法，包括属性选择器的使用。通过CSS3选择器，可以提高Web开发的效率和精准度，使得查找元素更加方便和快捷。同时，本文还对属性选择器的各种用法进行了详细解释，并给出了相应的代码示例。通过学习本文，读者可以更好地掌握CSS3选择器的使用方法，提升自己的Web开发能力。 ... [详细]

蜡笔小新 2023-12-14 14:37:52
get
android listview OnItemClickListener失效原因

最近在做listview时发现OnItemClickListener失效的问题，经过查找发现是因为button的原因。不仅listitem中存在button会影响OnItemClickListener事件的失效，还会导致单击后listview每个item的背景改变，使得item中的所有有关焦点的事件都失效。本文给出了一个范例来说明这种情况，并提供了解决方法。 ... [详细]

蜡笔小新 2023-12-14 14:25:50
get
eclipse学习（第三章：ssh中的Hibernate）——11.Hibernate的缓存（2级缓存，get和load）

本文介绍了eclipse学习中的第三章内容，主要讲解了ssh中的Hibernate的缓存，包括2级缓存和get方法、load方法的区别。文章还涉及了项目实践和相关知识点的讲解。 ... [详细]

蜡笔小新 2023-12-14 00:31:35
get
关于cuowu类的错误提示和使用AdjustmentListener的问题

本文讨论了一个关于cuowu类的问题，作者在使用cuowu类时遇到了错误提示和使用AdjustmentListener的问题。文章提供了16个解决方案，并给出了两个可能导致错误的原因。 ... [详细]

蜡笔小新 2023-12-13 22:09:56
get
Python正则表达式学习记录及常用方法

本文记录了学习Python正则表达式的过程，介绍了re模块的常用方法re.search，并解释了rawstring的作用。正则表达式是一种方便检查字符串匹配模式的工具，通过本文的学习可以掌握Python中使用正则表达式的基本方法。 ... [详细]

蜡笔小新 2023-12-13 16:37:19
get
自动轮播，反转播放的ViewPagerAdapter的使用方法和效果展示

本文介绍了如何使用自动轮播、反转播放的ViewPagerAdapter，并展示了其效果。该ViewPagerAdapter支持无限循环、触摸暂停、切换缩放等功能。同时提供了使用GIF.gif的示例和github地址。通过LoopFragmentPagerAdapter类的getActualCount、getActualItem和getActualPagerTitle方法可以实现自定义的循环效果和标题展示。 ... [详细]

蜡笔小新 2023-12-13 14:41:31
filter
阿里Treebased Deep Match(TDM) 学习笔记及技术发展回顾

本文介绍了阿里Treebased Deep Match(TDM)的学习笔记，同时回顾了工业界技术发展的几代演进。从基于统计的启发式规则方法到基于内积模型的向量检索方法，再到引入复杂深度学习模型的下一代匹配技术。文章详细解释了基于统计的启发式规则方法和基于内积模型的向量检索方法的原理和应用，并介绍了TDM的背景和优势。最后，文章提到了向量距离和基于向量聚类的索引结构对于加速匹配效率的作用。本文对于理解TDM的学习过程和了解匹配技术的发展具有重要意义。 ... [详细]

蜡笔小新 2023-12-14 19:24:58
get
JS进修笔记——闭包的运转机制和作用域

本文介绍了闭包的定义和运转机制，重点解释了闭包如何能够接触外部函数的作用域中的变量。通过词法作用域的查找规则，闭包可以访问外部函数的作用域。同时还提到了闭包的作用和影响。 ... [详细]

蜡笔小新 2023-12-14 18:45:00
get
在类中定义数组时出错 - Error on defining arrays in class

Iamtryingtomakeaclassthatwillreadatextfileofnamesintoanarray,thenreturnthatarra ... [详细]

蜡笔小新 2023-12-14 17:38:12
get
云原生边缘计算之KubeEdge简介及功能特点

本文介绍了云原生边缘计算中的KubeEdge系统，该系统是一个开源系统，用于将容器化应用程序编排功能扩展到Edge的主机。它基于Kubernetes构建，并为网络应用程序提供基础架构支持。同时，KubeEdge具有离线模式、基于Kubernetes的节点、群集、应用程序和设备管理、资源优化等特点。此外，KubeEdge还支持跨平台工作，在私有、公共和混合云中都可以运行。同时，KubeEdge还提供数据管理和数据分析管道引擎的支持。最后，本文还介绍了KubeEdge系统生成证书的方法。 ... [详细]

蜡笔小新 2023-12-14 16:49:01
get
java boolean 大小_java boolean 大小

先看官方文档TheJavaTutorialshavebeenwrittenforJDK8.Examplesandpracticesdescribedinthispagedontta ... [详细]

蜡笔小新 2023-12-12 13:36:56

秋林学士_809

这个家伙很懒，什么也没留下！

Tags | 热门标签

RankList | 热门文章