单链表操作

#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);
}