更多“编写算法,实现带头结点单链表的逆置算法。”相关问题
  • 第1题:

    假设以带头结点的循环链表表示队列,并且只设一个指针指向队尾元素站点(注意不设头指针) ,试编写相应的置空队、判队空 、入队和出队等算法。


    参考答案:
      置空队就是建立一个头节点,并把头尾指针都指向头节点,头节点是不存放数据的;判队空就是当头指针等于尾指针时,队空;入队时,将新的节点插入到链队列的尾部,同时将尾指针指向这个节点;出队时,删除的是队头节点,要注意队列的长度大于1还是等于1的情况,这个时候要注意尾指针的修改,如果等于1,则要删除尾指针指向的节点。
      [算法描述]
      //先定义链队结构:
      typedef struct queuenode
      {Datatype data;
      struct queuenode *next;
      }QueueNode; //以上是结点类型的定义
      typedef struct
      {queuenode *rear;
      }LinkQueue; //只设一个指向队尾元素的指针
      (1) 置空队
      void InitQueue( LinkQueue *Q)
      { //置空队:就是使头结点成为队尾元素
      QueueNode *s;
      Q->rear = Q->rear->next;//将队尾指针指向头结点
      while (Q->rear!=Q->rear->next)//当队列非空,将队中元素逐个出队
      {s=Q->rear->next;
      Q->rear->next=s->next;
      delete s;
      }//回收结点空间
      }
      (2) 判队空
      int EmptyQueue( LinkQueue *Q)
      { //判队空。当头结点的next指针指向自己时为空队
      return Q->rear->next->next==Q->rear->next;
      }
      (3) 入队
      void EnQueue( LinkQueue *Q, Datatype x)
      { //入队。也就是在尾结点处插入元素
      QueueNode *p=new QueueNode;//申请新结点
      p->data=x; p->next=Q->rear->next;//初始化新结点并链入
      Q-rear->next=p;
      Q->rear=p;//将尾指针移至新结点
      }
      (4) 出队
      Datatype DeQueue( LinkQueue *Q)
      {//出队,把头结点之后的元素摘下
      Datatype t;
      QueueNode *p;
      if(EmptyQueue( Q ))
      Error("Queue underflow");
      p=Q->rear->next->next; //p指向将要摘下的结点
      x=p->data; //保存结点中数据
      if (p==Q->rear)
      {//当队列中只有一个结点时,p结点出队后,要将队尾指针指向头结点
      Q->rear = Q->rear->next;
      Q->rear->next=p->next;
      }
      else
      Q->rear->next->next=p->next;//摘下结点p
      delete p;//释放被删结点
      return x;
      }

  • 第2题:

    在具有n个结点的单链表中,实现()的操作,其算法的时间复杂度是O。

    A.求链表的第i个结点

    B.在地址为P的结点之后插入一个结点

    C.删除表头结点

    D.删除地址为P的结点的后继结点


    正确答案:A

  • 第3题:

    试写一算法,实现单链表的就地逆置(要求在原链表上进行)


    参考答案:void Inverse(LinkList L->next;L->next NULL;while p->next;q->next L->next;L->next

  • 第4题:

    编写递归算法,交换二叉链表存储的二叉树中每个结点的左、右子树。


    参考答案:

  • 第5题:

    设带头结点的单链表(L为头指针)中的数据元素递增有序。设计算法,将x插入到链表的适当位置上,并仍保持该表的有序性。


    参考答案:

  • 第6题:

    函数实现单链表的删除算法,请在空格处将算法补充完整。


    正确答案:

    (1)p->next!=NULL(2)p->next=q->next

  • 第7题:

    在长度为n(Il>1)的()上,删除第一个元素.其时间复杂度为O(n)。

    A.只有首结点指针的不带头结点的循环单链表
    B.只有尾结点指针的不带头结点的循环单链表
    C.只有尾结点指针的带头结点的循环单链表
    D.只有头结点的循环单链表

    答案:A
    解析:
    只有首结点指针的不带头结点的循环单链表删除第一个元素,需要遍历整个链表,因此A项的时间复杂度为O(n),BCD三项的时间复杂度都为O(1)。

  • 第8题:

    设一个带头结点的单向链表的头指针为head,设计算法,将链表的记录,按照data域的值递增排序。


    正确答案: voidassending(Lnode*heaD.
    {Lnode*p,*q,*r,*s;
    p=head->next;q=p->next;p->next=NULL;
    while(q)
    {r=q;q=q->next;
    if(r->data<=p->datA.
    {r->next=p;head->next=r;p=r;}
    else
    {while(!p&&r->data>p->datA.
    {s=p;p=p->next;}
    r->next=p;s->next=r;}
    p=head->next;}
    }

  • 第9题:

    编写算法,将一个头指针为head不带头结点的单链表改造为一个单向循环链表,并分析算法的时间复杂度。


    正确答案: voidlinklist_c(Lnode*heaD.
    {Lnode*p;p=head;
    if(!p)returnERROR;
    while(p->next!=NULL)
    p=p->next;
    p->next=head;
    }
    设单链表的长度(数据结点数)为N,则该算法的时间主要花费在查找链表最后一个结点上(算法中的while循环),所以该算法的时间复杂度为O(N)。

  • 第10题:

    问答题
    编写算法,实现带头结点单链表的逆置算法。

    正确答案: voidinvent(Lnode*heaD.
    {Lnode*p,*q;
    if(!head->next)returnERROR;
    p=head->next;q=p->next;p->next=NULL;
    while(q)
    {p=q;q=q->next;p->next=head->next;head->next=p;}
    }
    解析: 暂无解析

  • 第11题:

    填空题
    某带头结点的单链表的头指针head,判定该单链表非空的条件()。

    正确答案: head->next!=Null
    解析: 暂无解析

  • 第12题:

    问答题
    编写算法,将一个头指针为head不带头结点的单链表改造为一个单向循环链表,并分析算法的时间复杂度。

    正确答案: voidlinklist_c(Lnode*heaD.
    {Lnode*p;p=head;
    if(!p)returnERROR;
    while(p->next!=NULL)
    p=p->next;
    p->next=head;
    }
    设单链表的长度(数据结点数)为N,则该算法的时间主要花费在查找链表最后一个结点上(算法中的while循环),所以该算法的时间复杂度为O(N)。
    解析: 暂无解析

  • 第13题:

    设计一个算法,通过一趟遍历在单链表中确定值最大的结点。


    参考答案:
      假定第一个结点中数据具有最大值,依次与下一个元素比较,若其小于下一个元素,则设其下一个元素为最大值,反复进行比较,直到遍历完该链表。
      [算法描述]
      ElemType Max (LinkList L ){
      if(L->next==NULL) return NULL;
      pmax=L->next; //假定第一个结点中数据具有最大值
      p=L->next->next;
      while(p != NULL ){//如果下一个结点存在
      if(p->data > pmax->data) pmax=p;//如果p的值大于pmax的值,则重新赋值
      p=p->next;//遍历链表
      }
      return pmax->data;

  • 第14题:

    完善算法:已知单链表结点类型为:

    函数create建立以head为头指针的单链表。


    正确答案:

  • 第15题:

    在长度为n的()上删除第一个元素,其算法的时间复杂度为O(n)。

    A.只有表头指针的不带表头结点的循环单链表

    B.只有表尾指针的不带表头结点的循环单链表

    C.只有表尾指针的带表头结点的循环单链表

    D.只有表头指针的带表头结点的循环单链表


    参考答案:A

  • 第16题:

    设计算法,实现单链表的就地逆置,即利用原表的存储空间将线性表(a1,a2,„,an)逆置为(an,an-1,„,a1)。


    参考答案:

  • 第17题:

    编写实现链表排序的一种算法。说明为什么你会选择用这样的方法?


    正确答案:
     

  • 第18题:

    在具有n个结点的单链表中,实现()的操作,其算法的时间复杂度都是O(n)。

    A.遍历链表和求链表的第i个结点
    B.在地址为P的结点之后插入一个结点
    C.删除开始结点
    D.删除地址为P的结点的后继结点

    答案:A
    解析:
    A项,由于单链表是非随机存取的存储结构,遍历链表和求链表的第i个结点都必须从头指针出发寻找,其时间复杂度为0(n);B项,由于已知待插入结点的前驱结点,可以直接实现插入,其时间复杂度为0(1);CD两项,可以直接实现删除操作,其时间复杂度为O(1)。

  • 第19题:

    下列是用头插法建立带头结点的且有n个结点的单向链表的算法,请在空格内填上适当的语句。
    head=p;q=p;p->next=NULL;p->next=q->next;q->next=p

  • 第20题:

    某带头结点的单链表的头指针head,判定该单链表非空的条件()。


    正确答案:head->next!=Null

  • 第21题:

    下列算法将单链表中值重复的结点删除,使所得的结果表中各结点值均不相同,试完成该算法。 void DelSameNode(LinkList L) //L是带头结点的单链表,删除其中的值重复的结点// {ListNode * p,*q,*r; p=L->next; //p初始指向开始结点// while(p){ //处理当前结点p// q=p; r=q->next; do { //删除与结点*p的值相同的结点// while(r&&r->data!=p->data){ q=r; r=r->next; } if(r){ //结点*r的值与*p的值相同,删除*r// q->next=r->next; free(r); r=(); } }while( r ); p=p->next; } }


    正确答案:q->next

  • 第22题:

    问答题
    设某带头结头的单链表的结点结构说明如下:typedef struct nodel{int data struct nodel*next;}node;试设计一个算法:void copy(node*headl,node*head2),将以head1为头指针的单链表复制到一个不带有头结点且以head2为头指针的单链表中。

    正确答案: 一边遍历,一边申请新结点,链接到head2序列中。
    解析: 暂无解析

  • 第23题:

    问答题
    设一个带头结点的单向链表的头指针为head,设计算法,将链表的记录,按照data域的值递增排序。

    正确答案: voidassending(Lnode*heaD.
    {Lnode*p,*q,*r,*s;
    p=head->next;q=p->next;p->next=NULL;
    while(q)
    {r=q;q=q->next;
    if(r->data<=p->datA.
    {r->next=p;head->next=r;p=r;}
    else
    {while(!p&&r->data>p->datA.
    {s=p;p=p->next;}
    r->next=p;s->next=r;}
    p=head->next;}
    }
    解析: 暂无解析