#include <stdio.h>
#include <malloc.h>
typedef struct node_tag {
int data;
struct node_tag *next;
} Node;
// 创建不带头结点的单链表
Node *createNode() {
Node *pHead, *p, *q;
pHead = NULL;
p = pHead;
int n = 0;
printf("请输入数字串(-1表示结束):");
scanf("%d", &n);
while (n != -1) {
q = (Node *) malloc(sizeof(struct node_tag));
q->data = n;
q->next = NULL;
if (NULL == pHead) {
pHead = q;
}
else {
p->next = q;
}
p = q;
scanf("%d", &n);
}
// 函数体结束,q指针变量被释放,不能通过head参数带回到调用函数
// 要把head带回到调用函数,要把它定义为指向指针的指针。
return pHead;
}
// 求链表长度
int length(Node *head) {
Node *p = head;
int n = 0;
while(p) {
n++;
p = p->next;
}
return n;
}
// 输出结果
void output(Node *head) {
Node *p = head;
while (p) {
printf("%d ", p->data);
p = p->next;
}
printf("/n");
printf("length: %d/n", length(head));
}
// 单链表的逆置
Node *reverse(Node *head) {
if (head == NULL || head->next == NULL)
return head;
Node *p = head;
Node *q = p->next;
// 当到达最后一个结点时
while (q) {
Node *r = q->next;
q->next = p;
p = q;
q = r;
}
head->next = NULL;
head = p;
return head;
}
// 有序单链表的合并
Node *mergelist(Node *head1, Node *head2) {
if (head1 == NULL || head2 == NULL)
return head1;
//******************************//
// 确认两链表的排序顺序,默认从小到大
Node *p1 = head1;
Node *p2 = head2;
bool flag1 = true;
bool flag2 = true;
while (p1->next) {
if (p1->data > p1->next->data) {
flag1 = false;
break;
}
p1 = p1->next;
}
while (p2->next) {
if (p2->data > p2->next->data) {
flag2 = false;
break;
}
p2 = p2->next;
}
if (flag1 != flag2) {
head2 = reverse(head2);
}
//******************************//
Node *head = NULL;
Node *p = NULL;
p1 = head1;
p2 = head2;
// 从小到大排序
if (flag1) {
if(p1->data <= p2->data) {
head = head1;
p1 = p1->next;
}
else {
head = head2;
p2 = p2->next;
}
p = head;
while (p1 != NULL && p2 != NULL) {
if (p1->data <= p2->data) {
p->next = p1;
p = p1;
p1 = p1->next;
}
else {
p->next = p2;
p = p2;
p2 = p2->next;
}
}
}
// 从大到小排序
else {
if(p1->data >= p2->data) {
head = head1;
p1 = p1->next;
}
else {
head = head2;
p2 = p2->next;
}
p = head;
while (p1 != NULL && p2 != NULL) {
if (p1->data >= p2->data) {
p->next = p1;
p = p1;
p1 = p1->next;
}
else {
p->next = p2;
p = p2;
p2 = p2->next;
}
}
}
p->next = p1? p1 : p2;
return head;
}
// 有序单链表的交集
Node *insectlist(Node *head1, Node *head2) {
if (head1 == NULL || head2 == NULL)
return head1;
//******************************//
// 确认两链表的排序顺序,默认从小到大
Node *p1 = head1;
Node *p2 = head2;
bool flag1 = true;
bool flag2 = true;
while (p1->next) {
if (p1->data > p1->next->data) {
flag1 = false;
break;
}
p1 = p1->next;
}
while (p2->next) {
if (p2->data > p2->next->data) {
flag2 = false;
break;
}
p2 = p2->next;
}
if (flag1 != flag2) {
head2 = reverse(head2);
}
//******************************//
Node *head = NULL;
Node *p = NULL;
p1 = head1;
p2 = head2;
// 从小到大排序
if (flag1) {
while (p1 != NULL && p2 != NULL) {
if (p1->data < p2->data) {
p1 = p1->next;
}
else if(p1->data > p2->data){
p2 = p2->next;
}
else {
if (NULL == head) {
head = p1;
p = p1;
}
else {
p->next = p1;
p = p1;
}
p1 = p1->next;
p2 = p2->next;
while(p1 && p1->data == p->data)
p1 = p1->next;
while(p2 && p2->data == p->data)
p2 = p2->next;
}
}
}
// 从大到小排序
else {
while (p1 != NULL && p2 != NULL) {
if (p1->data > p2->data) {
p1 = p1->next;
}
else if(p1->data < p2->data){
p2 = p2->next;
}
else {
if (NULL == head) {
head = p1;
p = p1;
}
else {
p->next = p1;
p = p1;
}
p1 = p1->next;
p2 = p2->next;
while(p1 && p1->data == p->data)
p1 = p1->next;
while(p2 && p2->data == p->data)
p2 = p2->next;
}
}
}
p->next = NULL;
return head;
}
// 移出表头结点
// 因为函数参数是值传递,因此如果不用引用函数内部对指针指向的修改并不影响外部指针
Node *removehead(Node *head) {
Node *p;
p = head;
head = head->next;
free(p);
return head;
}
void main() {
Node *head1 = NULL;
Node *head2 = NULL;
head1 = createNode();
output(head1);
head2 = createNode();
output(head2);
//head1 = reverse(head1);
//output(head1);
//head1 = removehead(head1);
//removehead(head1);
//output(head1);
//head1 = mergelist(head1, head2);
//output(head1);
head1 = insectlist(head1, head2);
output(head1);
}