【数据结构与算法】单链表操作（C++）

 #include <stdio.h>
 #include <malloc.h>
 /*单链表节点定义*/
 typedef struct LNode {
     int data;            //data中存放节点数据域
     struct LNode *next;   //指向后继节点的指针
 }LNode;  //定义单链表节点类型

 /*例2.3开始*/
 /*A和B是两个单链表（带表头结点），其中元素递增有序，设计一个算法，将A 和B归并成一个按元素值非递减有序的链表C，C由A和B中的节点组成*/
 void mergeLNodeAsc(LNode *A, LNode *B, LNode *&C) {
     LNode *p = A->next;//p用来跟踪A的最小值节点  A->next表示A链表的开始节点（头结点的下一个） A递增，所以p指向他表示指向A的最小节点，即用p来跟踪A的最小节点
     LNode *q = B->next;//q来跟踪B的最小值节点
     LNode *r; //r始终指向C的终端节点
     C = A;//用A的头结点来做C的头结点
     C->next = NULL;
     free(B); //B的头结点无用，则释放掉
     r = C;//r指向C 因为此时头结点也是终端节点
     while (p!=NULL&&q!=NULL) {//当p和q都不空时，选取p和q所指节点中的较小者插入C的尾部
         if (p->data<=q->data) {
             printf("p小于q");
             r->next=p; //赋值C的节点
             p = p->next; //p前移一个
             r = r->next; //r前移一个

         }
         else {
             printf("q小于p");
             r->next = q;
             q = q->next;
             r = r->next;
         }

     }
     r->next = NULL; //这一个其实可以去掉 因为至少会剩下一个插入到C的尾部
     /*将还有剩余节点的链表插入到C的尾部*/
     if (p!=NULL) {
         r->next = p;
     }
     if (q != NULL) {
         r->next = q;
     }

 }
 /*例2.3结束*/

 /*尾插法建立链表C*/

 void createListR(LNode *&C,int a[],int n) {//要改变的变量用引用型
     LNode *s, *r;//s用来指向新申请的节点，r始终指向C的终端节点
     int i;
     C = (LNode *)malloc(sizeof(LNode));//申请C的头结点空间
     C->next = NULL;
     r = C;//r指向头结点，因为此时头结点就是终端节点
     for (i = ; i < n;++i) {
         s = (LNode *)malloc(sizeof(LNode)); //s指向新申请的节点
         s->data = a[i]; //用新申请的节点来接收a的一个元素
         r->next = s; //用r来接纳新节点
         r = r->next; //用r指向终端节点，以便于接纳下一个到来的节点
     }
     r->next = NULL;//数组a中所有的元素都已经装入链表C中，C的终端节点的指针域为NULL C建立完成

 }

 /*头插法建立链表C*/
 void createListF(LNode *&C, int a[], int n) {//要改变的变量用引用型
     LNode *s;//s用来指向新申请的节点
     int i;
     C = (LNode *)malloc(sizeof(LNode));//申请C的头结点空间
     C->next = NULL;
     for (i = ; i < n; ++i) {
         s = (LNode *)malloc(sizeof(LNode)); //s指向新申请的节点
         s->data = a[i]; //用新申请的节点来接收a的一个元素
         s->next = C->next;//s所指新节点的指针域next指向C的开始节点
         C->next = s;//头结点的指针域next指向s节点，使得s称为新的开始节点
     }

 }

 /*归并为递减的单链表*/

 void  mergeLNodeDesc(LNode *A,LNode *B,LNode *&C) {

     LNode *p = A->next;
     LNode *q = B->next;
     LNode *s;
     C = A;
     C->next = NULL;
     free(B);
     while (p!=NULL&&q!=NULL) {
         if (p->data<=q->data) {
             s = p;
             p=p->next;
             s->next=C->next;
             C->next = s;
         }
         else {
             s = q;
             q = q->next;
             s->next = C->next;
             C->next = s;
         }
     }
     /*必须将剩余元素逐个插入C的头部才能得到最终的递减序列*/

     while (p!=NULL) {
         s = p;
         p = p -> next;
         s ->next = C->next;
         C->next = s;
     }
     while (q != NULL) {
         s = q;
         q = q->next;
         s->next = C->next;
         C->next = s;
     }

 }

 /*例2.4开始*/
 /*查找链表C中是否存在一个值为x的节点，若存在，则删除该节点并返回1，否则返回0*/

 int findAndDelete(LNode *C,int x) {
     LNode *p, *q; /*q用来接纳删除的元素 ，p用来指向C的节点*/
     p = C;
     while (p->next!=NULL) {

         if (p->next->data ==x) {/*查找的是要删除节点的额前驱节点*/
             break;
         }
         p = p->next; /*如果当前不是要找的节点 则p向后移*/
     }
     /*没找到*/
     if (p->next ==NULL) {
         return ;

     }
     else {
         /*删除部分开始*/
         q = p->next;
         p->next = p->next->next;
         free(q);
         /*删除部分结束*/
         return ;
     }

 }
 /*例2.4结束*/

 /*打印链表中的元素*/
 void showLNode(LNode *C) {
     LNode *p;
     p = C;
     while (p->next!=NULL) {
         printf("C的数据为：%d\n", p->next->data);
         p = p->next;
     }

 }

 void main() {

     LNode *C;
     int a[] = { ,,, };
     int n = ;
     createListF(C, a, n);
     showLNode(C);// 4 3 2 1
     findAndDelete(C, );
     showLNode(C);// 4 3 1

     LNode *D;
     int b[] = { ,,,,, };
     int m = ;
     createListR(D, b, m);
     showLNode(D); // 1 2 3 4 5 6

     findAndDelete(D, );
     showLNode(D);// 1 2 3 4 5 6
     printf("开始合并数组");

     LNode *M;
     int m1[] = { ,, };
     int m2 = ;
     createListR(M, m1, m2);
     LNode *N;
     int n1[] = { ,, };
     int n2 = ;
     createListR(N, n1, n2);
     LNode *O;
     mergeLNodeDesc(M, N,O);
     showLNode(O);// 6 5 4 3 2 1

     LNode *Q;
     int q1[] = { ,, };
     int q2 = ;
     createListR(Q, q1, q2);
     LNode *R;
     int r1[] = { ,, };
     int r2 = ;
     createListR(R, r1, r2);
     LNode *P;
     mergeLNodeAsc(Q, R, P);
     showLNode(P);// 1 2 3 4 5 6
 }