单链表实现一元多项式相加请帮我看一下这个程序有什么错误,#include #include #include #incl

B
没有头结点说明第一个元素是head->next
而它是空的,那么就判断是否 == NULL,即0
所以B

这是Java的：
public class Test {
public static void main(String[] args) {
try{
LinkList list1 = new LinkList();
LinkList list2 = new LinkList();
LinkList list3 = null;

list1.addAt(0, new Item(1, 5));
list1.addAt(1, new Item(-1.5, 3));
list1.addAt(2, new Item(1, 1));

list2.addAt(0, new Item(0.5, 5));
list2.addAt(1, new Item(0.5, 4));
list2.addAt(2, new Item(1.5, 3));
list2.addAt(3, new Item(3, 0));

list3 = mergeLinkList(list1, list2);

System.out.println("一元多项式的相加过程：");
list1.listAll();
System.out.println(" + ");
list2.listAll();
System.out.println(" = ");
list3.listAll();
}
catch(Exception e){
e.printStackTrace();
}
}

//两个一元多项式相加,返回新的一元多项式
public static LinkList mergeLinkList(LinkList list1, LinkList list2){
int i = 0;
Item item = new Item();
Node curr1, curr2;
LinkList list3 = new LinkList();

curr1 = list1.getHead().getNext();
curr2 = list2.getHead().getNext();
while(curr1 != null && curr2 != null){
if(curr1.getData().getExp() > curr2.getData().getExp()){
item = curr1.getData();
list3.addAt(i, item);
curr1 = curr1.getNext();
i++;
}
else if(curr1.getData().getExp() < curr2.getData().getExp()){
item = curr2.getData();
list3.addAt(i, item);
curr2 = curr2.getNext();
i++;
}
else{
item = new Item(curr1.getData().getCoef() + curr2.getData().getCoef(), curr1.getData().getExp());
if(item.getCoef() != 0){
list3.addAt(i, item);
i++;
}
curr1 = curr1.getNext();
curr2 = curr2.getNext();
}
}
while(curr1 != null){
item = curr1.getData();
list3.addAt(i++, item);
curr1 = curr1.getNext();
}
while(curr2 != null){
item = curr2.getData();
list3.addAt(i++, item);
curr2 = curr2.getNext();
}

return list3;
}
}
/**
* 一元多项式的一般项类
*/
class Item{
private double coef; //一元多项式的一般项的系数
private int exp; //一元多项式的一般项的指数

public Item(){
this.coef = 0.0;
this.exp = 0;
}

public Item(double coef, int exp){
this.coef = coef;
this.exp = exp;
}

public double getCoef(){
return this.coef;
}

public void setCoef(double coef){
this.coef = coef;
}

public int getExp(){
return this.exp;
}

public void setExp(int exp){
this.exp = exp;
}
}
/**
* 链表结点类
*/
class Node{
private Item data;
private Node next; //链表结点的指针域,指向直接后继结点

public Node(){
data = null;
next = null;
}

public Node(Item data, Node next){
this.data = data;
this.next = next;
}

public Item getData(){
return this.data;
}

public void setData(Item data){
this.data = data;
}

public Node getNext(){
return this.next;
}

public void setNext(Node next){
this.next = next;
}
}
/**
* 链表类
*/
class LinkList{
private Node head = null; //头结点指针
private int size = 0;

public LinkList(){
head = new Node();
size = 0;
}
//在i位置插入元素elem
public boolean addAt(int i, Item elem) {
if(i < 0 || i > size){
return false;
}
Node pre,curr;
int pos;
for(pre=head; i>0 && pre.getNext()!=null; i--,pre=pre.getNext());
curr = new Node(elem, pre.getNext());
pre.setNext(curr);
size++;
return true;
}

//删除i位置的元素
public boolean removeAt(int i) {
if(i < 0 || i >= size){
return false;
}

Node pre,curr;
for(pre=head; i>0 && pre.getNext()!=null; i--,pre=pre.getNext());
curr = pre.getNext();
pre.setNext(curr.getNext());
size--;
return true;
}

//根据值value查询结点是否存在,若存在返回位置,否则返回-1
public int findByValue(Item value){
Node curr;
int pos;
for(pos=0,curr=head.getNext(); curr!=null; pos++,curr=curr.getNext()){
if(curr.getData().toString().equals(value.toString())){
break;
}
}

if(curr==null){
return -1;
}
return pos;
}

public Node getHead(){
return this.head;
}

public void setHead(Node head){
this.head = head;
}

public int getSize(){
return this.size;
}

public boolean isEmpty(){
return (size==0);
}

public void listAll(){
for(Node curr=head.getNext(); curr!=null; curr=curr.getNext()){
System.out.print("(" + curr.getData().getCoef() + ", " + curr.getData().getExp() + ")t");
}
System.out.println();
}
}

n(n-1)/2
第一个数,0次查找
第二个数,1次查找
...
第n个数,n-1次查找
所以总共为：
（n-1+1)(n-1)/2=n(n-1)/2

一、
1、B
2、B
4、C 《 A的深度为1,B的深度为3,D的深度为3》
5、C
6、B?
7、C
8、B 直接插入排序 ：n个不同的数据元素,最多需要比较n*(n-1)/2
9、C
10、A
二、
1.线性结构 ,非线性结构 .
2.352 < 100+ (6*20+6)*2 > ,232 < 100+ (6*10+6)*2> .
3.i能被2整除,i+1
4、log2(2n+1) ,2n-1
5、n-1 0 n*(n-1)/2
6、只在栈顶进行操作 插入删除受限.
7、子表 数据元素
三、
1、对
2、错 数组中的元素必须 类型相同
3、错
4、错 拓扑序列不唯一
5、用Ch1,Ch2表示两个字符,若Ord(Ch1)＜Ord(Ch2),则称Ch1＜Ch2.（ ）
四

p->next!=NULL&&p->next->next=NULL

来空间看!

curr = L;
while ( curr->next != NULL)
{
if (curr->next->data < curr->data) return 0;
curr = curr->next;
}
return 1;

10点钟已从hi上解决,还没来得及贴上来.现在贴上
例如链表ha有元素：1、2、3、4、5
hb有元素：6、7、8
那么
while(pa->next&&pb->next){
pa=pa->next;
pb=pb->next;
}
初始pa指向元素1,pb指向元素6
第一次pa指向元素2,pb指向元素7
第三次pa指向元素3,pb指向元素8
第四次pa指向元素4,pb指向结尾了
就是先找出那个链表先到尾了,显然是hb
然后到了下面的if语句,pa->next 是有元素的,因此执行if里面的语句
把hb作为链表头,while(pb->next) pb=pb->next使得pb指向hb的尾部,将hb的尾部指针指向ha,因此两个链表连起来了

这是大致算法，具体细节问题 自己慢慢改
typedef struct linklist{
int data;
linklist *next;
};
linklist B,C
B=C=A;
linklist temp; //表示要插入的数
while(B->next!=null)
{
if(temp->data>B->next->data)
{
C=B;
B=B->next;
}
else
{
temp->next=B;
C->next=temp;
}
}

B C
顺序表就相当于数组，查找的时候可以一下就找到，所以时间复杂度为：O(1)
单链表查找的时候要一直找下一个结点，若要查找的元素在最后，就相当于找了n次，所以时间复杂度为：O(n)

#include
using namespace std;
int fib(int t){
int a = 1;
int b = 1;
if(t= t) return next;
a = b;
b = next;
}
}
int main(){
cout

B

3的话你可以举一个反例,比如说有1 2 3 三个节点 比如1连接2,1连接3 这样不就不是单链表了么

递增无序?递增有序吧,如果无序,首先给两个链表排序,以下代码按升序合并
先剔除两条链表里的相同值,然后再合并
LinkList ElimtList(LinkList L)/* L为空头 *//* 剔除相同值 */
{
LinkList p = NULL;
LinkList t = NULL;
LinkList tmp = NULL;
p = L->next; /* 保存结点2 */
t = p->next; /* 保存结点3 */
while (NULL != t)/* 进入循环 */
{
if (p->num == t->num)
{
tmp = t->next;/* 保存结点t的下一个结点 */
p->next = tmp;/* 结点t的上一个结点与下一个结点相接 */
free(t); /* 释放结点t */
t = tmp; /* t指向下一个结点 */
}
else
{
p = p->next;/* 后移一位 */
t = t->next;/* 后移一位 */
}
}
return(L);
}
LinkList MergeList(LinkList L1,LinkList L2)/* 合并L1,L2两个链表,用的地址L1作为新链表地址返回 *//* 合并 */
{
LinkList p = NULL;
LinkList p1 = NULL;
LinkList p2 = NULL;
LinkList tmp = NULL;
p = L1;
p1 = L1->next;
p2 = L2->next;
while ((NULL != p1) && (NULL != p2))
{
if (p1->num < p2->num)/* 若p1的值小于p2的值,p1后移1位,p2不动 */
{
p = p1;
p1 = p1->next;
}
else if (p1->num > p2->num)/* 若p1的值大于p2的值,则p1前插入p2,p2后移1位,p1不动 */
{
tmp = p2->next;
p2->next = p1;
p->next = p2;
p = p2;
p2 = tmp;
}
else/* if (p1->num == p2->num) */
{
tmp = p2->next;/* 保存结点p2的下一个结点 */
free(p2); /* 释放结点p2 */
p2 = tmp; /* p2指向下一个结点 */
}
}
p->next = p1 p1 :p2; /*插入剩余段*/
free(L2); /*释放L2的头节点*/
return(L1);
}

void List_Insert(List A,List B,List &C)
{
int i=0,j=0,k=0;
while(A.elem[i]&&B.elem[j])
{
if(A.elem[i]B.elem[j]) j++;
if(A.elem[i]==B.elem[j])
{
C.elem[k++]=A.elem[i];
i++;
j++;
}
}

typedef int Elemtype;
typedef int status;
#define OVERFLOW -2
#define OK 1
#define ERROR -1
#include "stdio.h"
#include "stdlib.h"
typedef struct LNode {
Elemtype data;
struct LNode *next;
}*linklist;
//构造链表
void Create_Linklist(linklist &L)
{
linklist p;
p=(linklist)malloc(sizeof(LNode));
if(!p)
exit(OVERFLOW);
L=p;
L->next =NULL;
}
//节点插入
void Insert_Linklist(linklist &L)
{
linklist p;
int n,i;
printf("请输入插入节点的个数n: ");
scanf("%d",&n);
getchar();
for(i=n;i>0;i--)
{
p=(linklist )malloc(sizeof(LNode));
scanf("%d",&p->data);
p->next=L->next ;
L->next =p;
}
}
//遍历输出并输出长度
status Visit_linklist(linklist &L)
{
linklist p;
int i=1;
p=L->next ;
if(L->next==NULL)
return ERROR;
while(p->next !=NULL)
{
printf("%d ",p->data );
p=p->next ;
i++;
}
printf("%dn",p->data );
printf("长度为：%dn",i);
return OK;
}
//查找值为x的直接前驱结点q并输出
void Search_linklist(linklist &L)
{
int x,k=0;
linklist p=L,q;
printf("输入x: ");
scanf("%d",&x);
getchar();
if(L->next ==NULL)
printf("该表为空 ！n");
while(p->next!=NULL)
{
q=p;
if(p->next ->data ==x)
{
printf("%d ",q->data );
k=1;
}
p=p->next ;
}
if(p->next &&p->data ==x)
{
printf("%d ",p->data );
k=1;
}
if(k==0)
printf("未找到值为%d的结点n",&x);
printf("n");
}
//删除节点
status Delete_linklist(linklist &L)
{
linklist p,q;
int k=0,x;
printf("请输入删除节点的值x: ");
scanf("%d",&x);
getchar();
if(L->next ==NULL)
return ERROR;
p=L;
q=L->next ;
while(q!=NULL)
if(q->data ==x)
{
k=1;
p=q ;
p->next =q->next ;
free(q);
q=p->next ;
}
else
{
p=q ;
q=p->next ;
}
if(k==0)
printf("表中没有值为%d的结点！n",&x);
return OK;
}

//链表逆置
void ListInverse_linkliast(linklist &L)
{
linklist k,p,q;
p=L;
while (p->next !=NULL)
{
p=p->next ;
}
k=p;
while (L->next !=p)
{
q=L->next ;
L->next = q->next ;
k->next =q;
}
}
//链表奇偶分解
void Break_linklist (linklist &La,linklist &Lb)
{
linklist p,q;
p=La->next;
q=Lb;
while(p->next!=NULL)
{
if(p->data %2==0)
{
q->next =p;
q=q->next ;
}
p=p->next ;
}
if(p->data %2==0)
{
q->next =p;
q=q->next ;
}
}

//主菜单
void main()
{
linklist L1,L2;
printf(" （1） 建立带头节点的单链表n");
printf(" （2） 插入节点n");
printf(" （3） 计算链表长度并输出单链表n");
printf(" （4） 查找值为x的直接前驱结点并输出其值n");
printf(" （5） 删除节点值为x的结点n");
printf(" （6） 逆置单链表结点n");
printf(" （7） 单链表奇偶分解n");
int choice;
printf(" 请输入选择：");
while(scanf("%d",&choice))
{
getchar();
printf("nn");
switch(choice)
{
case 1:
Create_Linklist(L1);
break;
case 2:
Insert_Linklist(L1);
break;
case 3:
Visit_linklist(L1);
break;
case 4:
Search_linklist(L1);
break;
case 5:
Delete_linklist(L1);
break;
case 6:
ListInverse_linkliast(L1);
break;
case 7:
Create_Linklist(L2);
Break_linklist (L1,L2);
break;
default:
printf(" 输入有误！");
break;
}
}
}

这个问题.
typedef struct node
{
ElemType data;
struct node * next;
}linknode,*linklist;
void concat(linklist &hc,linklist ha,linklist hb)
{//hb表的首结点连接在ha表的最后一个结点之后,hc指向连接后的单链表.
linknode *p;
hc=ha;
p=ha;
while(p->next!=NULL)
{
p=p->next;
}
p->next=hb->next;
}

s表示要插入的节点,假设s已被赋值.
L表示目的链表,且L.head仅为头指针,不存储信息
Node* q = L.head
Node* p = L.head->next
while( p != NULL ) {
if( s->value value ) // 找到了s该插入的位置,并且此时p,q已记录下要插入的位置
break
else
q = p
p = p->next
}
// 将s节点插入到q,p节点之间
s->next = p;
q->next = s;
画画图就出来了,不过不要漏考虑插入位置在表头或表尾的情况

选B
s->next=p->next; //先让s->next指向p->next
p->next=s;//然后再将s设置为p的后继结点
若先做p->next=s,那么p原来的后继结点就没办法找到了,链表被断开

node *mergelink(node *p, node *q)
{
node *h, *r;
h = (node*) malloc (sizeof(node));
h->next = NULL;
r = h;
while (p != NULL && q != NULL)
{
if (p->data <= q->data)
{
r->next = p;
r = p;
p = p->next;
}
else
{
r->next = q;
r = q;
q = q->next;
}
}

if (p == NULL)
r->next = q;
if (q == NULL)
r->next = p;

p = h->next;
h = h->next;
free(p);
return h;
}

/*------------------------------------------------------------
* 使用C++完成前插和后插创建链表,如果您是要使用C的话,只需要
* 简单做一些改动即可,程序在VS2005中调试通过
*------------------------------------------------------------*/
#include
using namespace std;
//链表的节点的结构体
struct Node
{
int data; //数据域
Node *next;//指针域
};
typedef Node LinkList;
//前插法创建链表
LinkList *CreateFront(int num)//参数num是创建链表的节点个数
{
//
LinkList *head = NULL; //链表表头
int x;
for(int i=0; inext;//将指针后移,为了插入下一个节点做准备
}
}
return head;
}
//此函数是用于打印结果的
void Display(LinkList *head)
{
LinkList *p = head;//指向链表表头
while(p != NULL)//若指针不空,则打印出节点的数据,一直到打印玩整个链表
{
cout

data_int
#include "head.h"
struct LNode{
// char data[10];
int data;
struct LNode *next;
};
typedef struct LNode * LinkList;
void InitList_L(LinkList &L)//链表构造函数
{
L=new LNode;
L->next=NULL;
}
void PrintList_L(LinkList &H)//链表显示函数
{
LinkList L=H;
L=L->next;
while(1)
{
cout<<"data value is "<data< L=L->next;
if (L==NULL)
return;
}
}
void Insert_L(LinkList &H,int n=0)//插入链表
{
LinkList L=H;
LinkList p=L;
int i=0;
if (n==0)
{
n=1;
while(p->next!=NULL)
{
p=p->next;
n++;
}

}
else if (n<1)
{
cout<<"error"< return;
}
for (i=0;i {
if (L->next==NULL)
{
cout<<"error"< return;
}
L=L->next;
}
p=new LNode;
cout<<"please input a value:";
cin>>p->data;
p->next=L->next;
L->next=p;
}
LinkList bing_LinkList(LinkList a,LinkList b)
{
LinkList c;
LinkList nc;
LinkList t;
InitList_L(c);
nc=c;
a=a->next;
while (a!=NULL)//复制a到c
{
t=new LNode;
t->data=a->data;
nc->next=t;
t->next=NULL;
nc=nc->next;
a=a->next;
}
b=b->next;
while (b!=NULL)
{
nc=c;
while (nc->next!=NULL)
{
if (nc->next->data==b->data)
break;
nc=nc->next;
}
if (nc->next==NULL)
{
t=new LNode;
t->data=b->data;
nc->next=t;
t->next=NULL;
nc=nc->next;
}
b=b->next;
}
return c;
}
void main()
{
LinkList a,b,c;
int i=0;

InitList_L(a);
cout<<"nI will input date."< for (i=1;i<=3;i++)
Insert_L(a,i);
// PrintList_L(a);
InitList_L(b);
cout<<"nI will input date."< for (i=1;i<=3;i++)
Insert_L(b,i);
// PrintList_L(b);
c=bing_LinkList(a,b);
PrintList_L(c);

}

答案选择B，希望可以帮到你。

你这是数据结构的实验？邮箱给我 我可以给你发一份 望采纳

用C语言给你写了一个,其他语言的话再说,算法思想基本就是从表头开始遍历,按照fibonacci的特性进行检验
按单链表的特点,节点命名为node,
一个节点有long int型的data和节点指针型的next两个属性,以下是判断方法
bool Check(node head)
{
//a为当前遍历的节点,b为a之后的节点
node *a, *b;
bool isFibonacci;
//初始化
a = head;
b = head -> next;
//验证最初的两个数
if(!(a->data == 1) && (b->data == 1))
isFibonacci = false;
else
{
isFibonacci = true;
//根据特性,遍历检查
while(b->next != NULL)
{
if((b->next->data) == a->data + b->data)
{
a = b;
b = b->next;
}
else
{
isFibonacci = false;
break;
}
}
}
return isFibonacci;
}

1. tmp = L;
while(tmp->next !=p) tmp=tmp->next;
tmp->next = s;
s->next = p;
2. tmp = L;
while(tmp->next != null ) tmp=tmp->next;
tmp->next =s;
s->next =null;
3. tmp = p->next;
p->next = tmp->next;
4. tmp = L->next;
L->next = tmp->next;

1、k ->c->n
2、j->l->h->k->c->n
3、j->l->g->c->n
4、l->j->m->n
5、l->j->f->"p->next = NULL"->n //删除尾节点需要有个->next = NULL 的赋值吧,选项没有

s->next=p->next;
p->next=s;

假设链表类型为
struct node
{
int data;
struct node *next;
};
node *q = p->next;
p->data = q->data;
p->next = q->next;
free(q);
搞定!
思路是这样的：
我们删除p的下一个节点很容易,删除p所指向的节点很难,我们可以用一个巧妙的方法,把p的下一个节点的内容赋值给p（相当于把p删除了,只是下一个节点是一个多余的节点了）,那么我们只要删除下一个节点就可以了,这样就转化成删除p的下一个节点了.
最终的到的链是一样的,只是换个思路想问题.

在算法的复杂性表示中,O记号表示复杂度的上限.
即：O(g(n)) = {f(n):存在正常数c和n0,使对所有的n>= n0,有0

未知长度单链表求倒数第K个元素解法：
1.指针a从链表头结点移动k个位置
2.指针b从头结点开始移动,同时指针a从第k个位置开始移动,当a到达链表尾部时,指针b到达倒数第k个元素位置.
设链表长度为n,a从k到尾部移动了n-k,所以b也移动了n-k,所以b的位置是倒数n-(n-k)=k