【数据结构与算法】单链表操作（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 = 0; 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 = 0; 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 0;
    
    }
    else {
        /*删除部分开始*/
        q = p->next;
        p->next = p->next->next;
        free(q);
        /*删除部分结束*/
        return 1;
    }

}
/*例2.4结束*/

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

void main() {

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


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

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

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

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