单链表中结点类型定义如下:
typedef struct link {
int data;
link* next;
}node,*linklist;
- 设A和B是两个单链表(带头节点),其中元素递增有序,设计一个算法从A和B中公共元素产生单链表C,要求不破坏A B的结点
void fun3(linklist& A, linklist& B) {
//设A和B是两个单链表(带头节点),其中元素递增有序,设计一个算法从A和B中公共元素产生单链表C,要求不破坏A B的结点
node* p = A->next;
node* q = B->next;
linklist C = (node*)malloc(sizeof(node*));
C->next = NULL;
node* rear = C;//指向链表C的尾节点
while (p && q) {
if (p->data < q->data) {//小则后移
p = p->next;
}
else if (p->data > q->data) {
q = q->next;
}
else {
node* s = (node*)malloc(sizeof(node*));
if (rear != C && rear->data != p->data||rear==C) {
s->data = p->data;
s->next = rear->next;
rear->next = s;
rear = rear->next;
}
else {
p = p->next;
q = q->next;
}
}
}
display(C);
}
2.已知两个链表A和B分别表示两个集合,其中元素递增排列。绘制函数,求A和B的交集,并存放于A链表中。
void fun4(linklist& A, linklist& B){
//已知两个链表A和B分别表示两个集合,其中元素递增排列。绘制函数,求A和B的交集,并存放于A链表中。
node* p = A->next;
node* q = B->next;
A->next = NULL;
node* rear = A;
while (p && q) {
if (p->data < q->data) {//小则后移
p = p->next;
}
else if (p->data > q->data) {
q = q->next;
}
else {
node* s = (node*)malloc(sizeof(node*));
s->data = p->data;
s->next = rear->next;
rear->next = s;
rear = rear->next;
p = p->next;
q = q->next;
}
}
}
3.头指针分别为la,lb的带头节点的单链表中,结点按元素递增有序排列,将la,和lb两个单链表合并成按元素递增有序的单链表,要求不另外开辟空间,la作为合并后的单链表的头节点
linklist uni_te(linklist la, linklist lb) {
//头指针分别为la,lb的带头节点的单链表中,结点按元素递增有序排列,
//将la,和lb两个单链表合并成按元素递增有序的单链表,要求不另外开辟空间,la作为合并后的单链表的头节点
node* p = la->next;
node* q = lb->next;
la->next = NULL;
node* rear = la;
node* temp;//防止断链
while (p && q) {
if (p->data < q->data) {
temp = p->next;
p->next = rear->next;
rear->next = p;
rear = rear->next;
p = temp;
}
else {
temp = q->next;
q->next = rear->next;
rear->next = q;
rear = rear->next;
q = temp;
}
}
if (p == NULL) {//链表A用完
if (q != NULL) {
rear->next = q;
}
}
else {
if (p != NULL) {
rear->next = p;
}
}
return la;
}
4.两个整数序列A=a1,a2,a3,…,am和B=b1,b2,b3,…bn已经存入两个单链表中,设计一个算法,判断序列B是否是序列A的连续子序列
int pattern(linklist A, linklist B) {
//两个整数序列A=a1,a2,a3,....,am和B=b1,b2,b3,...bn已经存入两个单链表中,设计一个算法,判断序列B是否是序列A的连续子序列
node* p = A->next;
node* q = B->next;
node* pre = A->next;
while (p&&q) {
if (p->data == q->data) {
p = p->next;
q = q->next;
}
else {
p = pre->next;
pre = pre->next;
q = B->next;
}
}
if (q == NULL) {
cout << 1 << endl;
return 1;
}
else {
cout << 0 << endl;
return 0;
}
cout << 0 << endl;
return 0;
/*node* p = A->next;
node* q = B->next;
while (p) {
if (p->data != q->data) {
p = p->next;
}
else {
node* pp = p;
node * qq = q;
while (pp&&qq&&pp->data==qq->data) {
pp = pp->next;
qq = qq->next;
}
if (qq == NULL) {
cout << 1 << endl;
return 1;
}
p = p->next;
}
}
cout << 0 << endl;
return 0;*/
}
5.设计一个算法用于判断带头节点的循环双链表是否对称
int flag(linklist L) {
//设计一个算法用于判断带头节点的循环双链表是否对称
node* p = L->next;
node* q = L->prior;
int flag = 1;
while (p!=q&&p->next!=q) {
if (p->data == q->data) {
p = p->next;
q = q->prior;
}
else {
flag = 0;
break;
}
}
return flag;
6.有两个循环单链表(不带头节点),链表头指针分别为h1和h2,编写一个函数将链表h2链接到h1之后,要求链接后的链表仍保持循环链表形式
void fun5(linklist& h1, linklist& h2) {
//有两个循环单链表(不带头节点),链表头指针分别为h1和h2,编写一个函数将链表h2链接到h1之后,要求链接后的链表仍保持循环链表形式
node* p = h1;
node* q = h2;
while (p->next != h1) {
p = p->next;
}
while (q->next != h2) {
q = q->next;
}
p->next = h2;
q->next = h1;
}
7.设有一个带头节点的单链表,其结点值都是正整数。设计一个算法,反复找出单链表中结点值最小的结点,并输出,然后将该结点从中删除,直到单链表为空位置,再删除表头结点
void De_all(linklist& L) {
//设有一个带头节点的单链表,其结点值都是正整数。设计一个算法,反复找出单链表中结点值最小的结点,
//并输出,然后将该结点从中删除,直到单链表为空位置,再删除表头结点
node* p = L;
while (p->next!= NULL) {//找到链表尾结点
p = p->next;
}
p->next = L;
while (L->next != L) {
node* min_p = L->next;
node* min_pre = L;
node* pre = L;
node* temp=NULL;
p = L->next;
while (p!= L) {
if (p->data < min_p->data) {//更新最小值指针
min_pre = pre;
min_p = p;
}
pre = p;
p = p->next;
}
temp = min_p;
cout << temp->data << " ";
min_pre->next = min_p->next;
//free(temp);
}
//free(L);
}
8.已知带头节点单链表,头指针list,不改变链表的前提下设计高效的算法,查找链表中倒数第k个位置上的结点的值
int fun6(linklist list, int k) {
//已知带头节点单链表,头指针list,不改变链表的前提下设计高效的算法,查找链表中倒数第k个位置上的结点的值
node* p = list->next;
node* q = list->next;
while (p) {
if (k > 0) {
p = p->next;
k--;
}
else {
p = p->next;
q = q->next;
}
}
if (p == NULL && k > 0) {
cout << "k大于表的长度" << endl;
return 0;
}
cout << q->data << endl;
return 1;
/*node* p = list;
node* q = list;
while (k > 0&&q->next!=NULL) {
q = q->next;
k--;
}
if (q->next == NULL && k != 0) {
cout << "失败 k大于表长" << endl;
return 0;
}
while (q) {
p = p->next;
q = q->next;
}
cout << p->data;
return 0;*/
}