单链表专题练习

描述

6-1 求单链表元素序号 (10 分)

本题要求实现一个函数，求带头结点的单链表中元素序号。

int Locate ( LinkList L, ElemType e){
	LNode *p;
	ElemType cnt=1;
	if(L==NULL){//特判头节点是否为空
		return 0;
	}else{
		p=L->next;//取出首元结点
       while(p!=NULL){//遍历链表找到数据值为e的点
       	if(p->data!=e){
       		p=p->next;
       		cnt++;
		   }else break;
	   }
	   if(p!=NULL)return cnt;//两种情况：要么链表不存在该值，要么存在该值
	   return 0;
	}
}

6-2 单链表遍历 (10 分)

本题要求实现一个函数，输出带头结点的单链表的的所有结点元素值。

void Traverse ( LinkList L ){
	LNode *p;
	p=L->next;//取出首元结点
	while(p!=NULL){//结点不为空则输出
		printf("%d ",p->data);
		p=p->next;
	}
}

6-3 表尾插入法构造链表 (10 分)

本题实现链表的构造，采用表尾插入法构造链表，输出表中所有元素。

 

ptr creat(){
	ptr L=(ptr)malloc(sizeof (snode));//创建链表头结点
    ptr rear=L;
	int d;
	L->next=NULL;//使尾结点为空
	while(scanf("%d",&d)&&d){
		ptr s=(ptr)malloc(sizeof (snode));
        s->next=NULL;//尾插法，则每一个结点next为NULL，即为链表结尾
		s->data=d;
	    rear->next=s;//将此结点加入链表
        rear=s;
	}
	return L;
}
void output(ptr p){
	ptr q=p->next;
	while(q){
		printf("%d ",q->data);
		q=q->next;
	}
}

 6-4 表头插入法构造链表 (10 分)

本题实现链表的构造，采用表头插入法构造链表，输出表中所有元素。

ptr creat(){
	ptr L=(ptr)malloc(sizeof (snode));
	int d;
	L->next=NULL;
	while(scanf("%d",&d)&&d){
		ptr s=(ptr)malloc(sizeof (snode));
		s->data=d;
		s->next=L->next;//当前结点插入之前结点前面
		L->next=s;
	}
	return L;
}
void output(ptr p){
	ptr q=p->next;
	while(q){
		printf("%d ",q->data);
		q=q->next;
	}
}

 由头插法概念可知，此插入后用头节点遍历时会与输入顺序相反

6-5 构造有序链表 (10 分)

本题实现链表的有序构造，输出表中所有元素。

ptr creat(){
	ptr L=(ptr)malloc(sizeof (snode));
	int d;
	L->next=NULL;
	while(scanf("%d",&d)&&d){
		ptr s=(ptr)malloc(sizeof (snode));
		s->data=d;
		s->next=L->next;
		L->next=s;
	}
	return L;
}
void output(ptr p){
    ptr a,b;
    a=p->next;
   int cnt=1;
  while(a){//类似冒泡排序操作，遍历每个结点后的结点，如果逆序就交换数据值，结点关系无需改变
        b=a->next;
        while(b){
            if(a->data>b->data){
                int t;
                t=a->data;
                a->data=b->data;
                b->data=t;
            } b=b->next;
        }a=a->next;
    } 
    ptr q=p->next;
    while(q){
        printf("%d ",q->data);
        q=q->next;
    }
}

6-6 单链表逆序输出 (10 分)

本题要求实现一个函数，逆序输出不带头结点的单链表的的所有元素值。

void Reverse(LinkList L){
	if(L!=NULL){
		if(L->next!=NULL){
			Reverse(L->next);//应用递归的性质，先输出后来输入的即为逆序
		}
		printf("%d ",L->data);
	}
}

6-7 带头结点的单链表插入操作 (10 分)

本题要求实现带头结点的单链表插入操作，插入成功返回1，否则返回0。

int insert_link ( LinkList L,int i,ElemType e){
    if(i<=0||!L)return 0;
	LNode *p;
    LinkList s=(LinkList)malloc(sizeof (LNode));
	s->data=e;
	p=L;
	int j=1;
	while(p&&j<i){//找i-1的位置，因为要为第i个元素，即插入到i-1的位置
		p=p->next;
		j++;
	}
    if(!p||i!=j)return 0;//两种情况，链表中不存在i-1的位置，链表存在i-1的位置
    else {
    	s->next=p->next;
    	p->next=s;
    	return 1;
	}
}

6-8 单链表删除奇数(*) (15 分)

请编写函数，删除带头结点的单链表中所有数据元素为奇数的结点

 

 

void RemoveOdd(NODE *head){//传入为*head，因此在函数操作会影响主函数中head
    NODE *p=head;//p为最终修改后的链表
    NODE *t=head->next;
    while(t){
        if(t->data%2){
            p->next=t->next;//若此结点为奇数则删除此结点
        }           
        else{
        p=p->next;
        }
        t=t->next;
    }
}

6-9 有序稀疏多项式求和 (15 分)

本题求两个有序多项式的求和，输入的多项式有两项：系数和指数。

ptr add(ptr ha, ptr hb)
{
    ptr h, s, p;
    h = s=(ptr)malloc(sizeof(node));//新建一个链表用来存放两个链表相加后的结果
    ha=ha->next;//带头的单向链表，记得尾结点赋值为空啊
    hb=hb->next;
    while (ha&&hb)//这是对两个链表相同的长度进行运算，有的表可能长，有的可能短，这个时候以短的                
                  //链表长度为准进行比较，长的那部分，直接拿过来
    {
        if (ha->exp < hb->exp) //比较指数大小，因为此多项式为低次在前
        {
            p = (ptr)malloc(sizeof(node));
            p=ha;
            ha = ha->next;
            s->next = p;//加入p结点
            s = p;//s后移
        }
        else if(ha->exp==hb->exp)
        {
            p = (ptr)malloc(sizeof(node));
            if(ha->ceof+hb->ceof==0)//若为0，则删除该结点
            {
            ha=ha->next;
            hb=hb->next;
            }
            else
            {
                p->exp=ha->exp;
                p->ceof=ha->ceof+hb->ceof;
                ha=ha->next;
                hb=hb->next;
                s->next=p;
                s=p;
            }
        }
        else
        {
            p = (ptr)malloc(sizeof(node));
            p=hb;
            hb = hb->next;
            s->next = p;
            s = p;
        }
    }
    while (ha != NULL)//对长的那部分进行操作
    {
        p = (ptr)malloc(sizeof(node));
        p=ha;
        ha = ha->next;
        s->next = p;
        s = p;
    }
    while (hb != NULL)
    {
        p = (ptr)malloc(sizeof(node));
        p=hb;
        hb = hb->next;
        s->next = p;
        s = p;
    }
    s->next =NULL;//尾结点的值置空哦
    return h;//返回新链表的头结点，还要输出呢
}