对链表的操作（数据结构线性表算法设计练习）

/*1.有一个单链表（不同结点的数据域值可能相同），其头指针为head，编写一个函数计算数据域为x的结点个数*/
#include <iostream>
#include <cstdio>
using namespace std;

struct node{
int data;
struct node *next;
};
struct node *head;

/*计算数据域为x的结点个数*/
int List_count (int x){
int count=0;
node*p;
p=head;
while(p){
if (p->data==x)
{
count++;
}
p=p->next;
}
return count;
}

int main()
{
struct node *p,*q,*t;
int i,n,a;
printf("输入data个数\n");
scanf("%d",&n);
head = NULL;
printf("输入data\n");
for(i=1;i<=n;i++){
scanf("%d",&a);
p=(struct node *)new(struct node);
p->data=a;
p->next=NULL;
if(head==NULL)
head=p;
else
q->next=p;

q=p;
}

/*打印这个链表*/
t= head;
printf("你输入的data为： \n");
while(t!=NULL){
printf("%d ",t->data);
t=t->next;
}
printf("\n");
printf("输入要计数的数据域x\n");
int x;
scanf("%d",&x);
printf("数据域为%d的节点个数为%d",x,List_count(x));

return 0;
}

/*2.有一个有序单链表（从小到大排序），表头指针为head，编写一个函数向该单链表中插入一个元素为x的结点，使插入后该链表仍然有序。*/
#include <iostream>
#include <cstdio>
using namespace std;

struct node{
int data;
struct node *next;
};

int main()
{
struct node *head,*p,*q,*t;
int i,n,a;
scanf("%d",&n);
head = NULL;
for(i=1;i<=n;i++){
scanf("%d",&a);
p=(struct node *)new(struct node);
p->data=a;
p->next=NULL;
if(head==NULL)
head=p;
else
q->next=p;

q=p;
}
scanf("%d",&a);
t= head;
while(t!=NULL){
if(t->next==NULL||t->next->data > a){
p=(struct node *)new(struct node);
p->data=a;
p->next=t->next;
t->next=p;
break;
}
t=t->next;
}
t=head;
while(t!=NULL){
printf("%d ",t->data);
t=t->next;
}

return 0;
}

/*3.编写一个函数将一个头指针为a的单链表A分解成两个单链表A和B，其头指针分别为a和b，使得A
链表中含有原链表A中序号为奇数的元素，而B链表中含有原链表A中序号为偶数的元素，且保持原来的相对顺序。*/
#include <cstdio>
#include <iostream>
using namespace std;
struct node
{
int data;
node * next;
}*hda,*hdb;

void text()
{
node *tmp=hda;
for(int i=1;i<=20;i++)
{
tmp->next=(node*)new(node);
tmp=tmp->next;
tmp->data=i;
printf("%d ",tmp->data);
}
tmp->next=NULL;
printf("\n");
}
void print()
{
node *ta,*tb;
ta=hda;
ta=ta->next;

while(ta!=NULL)
printf("%d ",ta->data),ta=ta->next;
printf("\n");
tb=hdb;
tb=tb->next;
while(tb!=NULL)
printf("%d ",tb->data),tb=tb->next;
printf("\n");
}
void div(node *a,node *b)
{
int cnt=1;
node *ta,*tb,*tc;
ta=a;
tb=b;
tc=a->next;
while(tc!=NULL)
{
if(cnt&1)
ta->next=tc,tc=tc->next,ta=ta->next;
else
tb->next=tc,tc=tc->next,tb=tb->next;
cnt++;
}
ta->next=tb->next=NULL;
return ;
}
int main(){
hda=(node*)new(node);
hdb=(node*)new(node);
text();
div(hda,hdb);
print();
return 0;
}

/*4.假设有两个已排序的单链表A和B，编写一个函数将它们合并成一个链表C而不改变其排序性。*/
node *p, *q;
node *mergelink()
{
node *h, *r;
h=(node *)new(node);
h->next=NULL;
r=h;//r一直指着这条链的末尾
while (p!=NULL && q!=NULL)
if (p->data<=q->data)
{
r->next=p;
r=p;//r=p是因为刚才把p的第一个节点接到了h上，r的地址要继续指着h这条链的话必需把r的地址指向p，也就是刚刚接到h上的这个节点

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

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

r->next=p;

return h;
}
node *mergelink(p, q);

/*5.	设A=（a ,…,a ）和B=（b ,…,bn）均为顺序表，A’和B’分别为A和B中除去最大共同前缀后的子表（例如，A=（x，y，y，z，x，z），
B=（x，y，y，z，y，x，x，z），则两者中最大的共同前缀为（x,y,y,z），在A’=B’=空表，则A=B；若A’=空表，而B’<>空表，或者两者均不为
空表，且A’的首元小于B’的首元，则A<B；否则A>B。（词典次序）试写一个比较A，B大小的算法（在算法中，不要破坏原表A和B，并且不一定先求得A’和B’才进行比较）。*/
typedef struct {
ElemType *elem;
int       length;
int       listsize;
} SqList;

char Compare(SqList A, SqList B)
{
int i,j;
i = j = 0;
if(A.length > A.listsize || B.length > B.listsize) return (OVERFLOW);
if(A.elem && B.elem){
while(i <= A.length && j <= B.length){
if(A.elem[i] == B.elem[j]){
i++;
j++;
}
else
break;
}
if(!A.elem[i] && !B.elem[j]) return '=';
if(A.elem[i] > B.elem[j]) return '>';
if(A.elem[i] < B.elem[j]) return '<';
}
}

/*6.设有一个用向量表示的线性表L，要求写出一个将该表逆置的过程，并允许在原表的存储空间外再增加一个附加的工作单元。*/
void  ConvertList( Seqlist *L)
{
int   t;//附加单元
int i;
for ( i=1 ; i < L->length/2 ; i++)
{   t = L->data[i];//交换数据
L -> data[ i ]  = L -> data[ L -> length + 1 - i ]  ;
L -> data[ L -> length + 1 - i ] = t  ;
}
}

/*7.已知两个整数集合A和B，它们的元素分别依元素值递增有序存放在两个单链表HA和HB中，编写一个函数
求出这两个集合的并集C,并要求集合C的链表的结点仍依元素值递增有序存放。(提示：求并集不是归并!)*/
/*思路：处理好三种大于等于小于的情况就行了*/
node*ha,*hb,*hc;
void union(ha,ha,hc)
{
node*p,*q,*r,*s;
hc=(node*)new(node);
r=hc;p=ha;q=hb;//建立一个头结点，r总是指向HC链表的最后一个结点
while(p!=NULL && q!=NULL)
{
if(p->data<q->data)
{
s=(node*)new(node);
s->data=p->data;
r->next=s;
r=s;
p=p->next;
}
else if(p->data>q->data)
{
s=(node*)new(node);
s->data=q->data;
r->next=s;
r=s;
q=q->next;
}
else  //相等的情况，取其中一个，然后后移
{
s=(node*)new(node);
s->data=q->data;
r->next=s;
r=s;
p=p->next;
q=q->next;
}
}
if(p==NULL)
while(q!=NULL)
{
s=(node*)new(node);
s->data=q->data;
r->next=s;
r=s;
q=q->next;
}
if(q==NULL)
while(p!=NULL)
{
s=(node*)new(node);
s->data=p->data;
r->next=s;
r=s;
p=p->next;
}
r->next=NULL;
s=hc;
hc=hc->next;
free(s);
}

/*8.已知两个顺序表A和B分别表示两个集合，其元素递增排列，编写一个函数求出A和B的交集C，要求C同样以元素递增的顺序表形式存储。*/

/*思路:釆用归并的思想，设置两个工作指针pa和pb，对两个链表进行归并扫描，只有同时出现在两集合中的元素才链接到结果表中且仅保留一个，
其他的结点全部释放。当一个链表遍历完毕后，释放另一个表中剩下的全部结点。比较两个节点时，小的节点指针后移一位*/
LinkList intersection(LinkList &la,LinkList &lb) {
pa=la->next;
pb=lb->next;
pc=la;
while(pa&&pb){
if(pa->data==pb->data) {
pc->next=pa;
pc=pa;
pa=pa->next;
u=pb;
pb=pb->next;
free(u);
}
else if (pa->data<pb->data) {
u=pa;
pa=pa->next;  //后移指针
free(u) ;
}else{
u=pb;
pb=pb->next;
free (u) ;
}
}  //while 结束
while(pa){
u=pa;
pa=pa->next;
free (u) ;
}
while(pb){
u=pb;
pb=pb->next;
free(u) ;
}
pc->next=NULL;
free (lb) ;
return la;
}

转载于:https://www.cnblogs.com/mingrigongchang/p/6246200.html

• 点赞
• 收藏
• 分享
• 文章举报