数据结构学习记录---天勤线性表综合应用题（2）

记录考研数据结构学习过程中的代码实现

（参考天勤书本）

（天勤P40T1(6)法一）删除链表中重复元素(常规方法发现与前相同则删除)

（天勤P40T1(6)法二）删除链表中重复元素（全部不重复元素移动到链表前，后整体删除重复部分）

（天勤P40T1(7)）删除链表中最小值

（天勤P40T1(8)）不建立新结点的情况下将单链表逆置,头插法

（天勤P40T1(9)）将头节点为A的单链表分解为两个单链表A，B。A只含奇数结点，B只含偶数结点

 在运行某一题代码时可注释掉主函数中其他功能部分

 特别注意   输出测试段代码   重复运行  需将头指针L  先归位！

#include
#include
#include
#define Maxsize 100
typedef struct LNode{
    int data;
    struct LNode *next;
}LNode;

//尾插法创建单链表
void createlistR(LNode *&L, int a[], int len){
    LNode *s, *r;
    int i;
    L = (LNode*)malloc(sizeof(LNode));
    L -> next = NULL;
    r = L;
    for(i = 0; i < len; i++){
        s = (LNode*)malloc(sizeof(LNode));
        s -> data = a[i];
        r -> next = s;
        r = r -> next;
    }
    r -> next = NULL;
}

//天勤P40T1(6)法一）删除链表中重复元素(常规方法发现与前相同则删除)
void delsl1(LNode *C){
    LNode *p, *q;
    p = C -> next;
    while(p -> next != NULL){
        if(p -> data == p -> next -> data){
            q = p -> next;
            p -> next = q -> next;
            free(q);
        }else{
            p = p -> next;

        }
    }
}

//   delsl2(L);//（天勤P40T1(6)法二）删除链表中重复元素（全部不重复元素移动到链表前，后整体删除重复部分）
void delsl2(LNode *C){
    LNode *p, *q, *r;
    p = C -> next;
    q = p -> next;
    while(q != NULL){
        while(q != NULL && q -> data == p -> data)
            q = q -> next;
        if(q != NULL){
            p = p -> next;
            p -> data = q -> data;
        }
    }
    q = p -> next;//断链，释放重复结点
    p -> next = NULL;
    while (q != NULL){
        r = q;
        q = q -> next;
        free(r);
    }
}

//   delmin(L);//（天勤P40T1(7)）删除链表中最小值
void delmin(LNode *C){
    LNode *premin, *pmin, *p;
    p = C; premin = C; pmin = premin -> next;
    while(p -> next != NULL){
        if(p -> next -> data < pmin -> data){
            premin = p;
            pmin = p -> next;
        }else{
            p = p -> next;
        }
    }
    premin -> next = pmin -> next;
}

//（天勤P40T1(8)）不建立新结点的情况下将单链表逆置,头插法
void reverse1(LNode *C){
    LNode *p, *q;
    p = C -> next;
    C -> next = NULL;
    while(p != NULL){
        q = p -> next;
        p -> next = C -> next;
        C -> next = p;
        p = q;
    }
}

//（天勤P40T1(9)）将头节点为A的单链表分解为两个单链表A，B。A只含奇数结点，B只含偶数结点
//其中A链表在主函数中已经创建为L, B链表需要在运行过程中从A链表中取下链接上，注意此时传参的区别
void split(LNode *A, LNode *&B){
    LNode *p, *q, *r;
    B = (LNode*)malloc(sizeof(LNode));
    B -> next = NULL;

    p = A ; r = B;
    while(p -> next != NULL){
        if((p -> next-> data) % 2){
            p = p -> next;
        }else{
            q = p -> next;
            p -> next = q -> next;
            q -> next = NULL;
            //特别注意！！此处不断链则取下的时q后的一整条
            //且由于每次测的数是p->next,所以此处无需p=p->next
            r -> next = q;
            r = q;
        }
    }
}



int main(){
    LNode *L, *B;
    int i, len = 0;
    int a[Maxsize];

    for(i = 0; i < Maxsize; i++){
        scanf("%d",&a[i]);
        len ++;
        if(getchar() == '\n')
            break;
    }

   createlistR(L, a, len);//尾插法创建单链表

 //   delsl1(L);//（天勤P40T1(6)法一）删除链表中重复元素(常规方法发现与前相同则删除)


 //   delsl2(L);//（天勤P40T1(6)法二）删除链表中重复元素（全部不重复元素移动到链表前，后整体删除重复部分）


 //   delmin(L);//（天勤P40T1(7)）删除链表中最小值

 //   reverse1(L);//（天勤P40T1(8)）不建立新结点的情况下将单链表逆置（头插法）

    split(L,B);//（天勤P40T1(9)）将头节点为A的单链表分解为两个单链表A，B。A只含奇数结点，B只含偶数结点

 //输出链表测试全部子函数需要
    while(L -> next != NULL){
        printf("%d", L -> next -> data);
        L = L -> next;
    }
    
 //输出链表测试仅split子函数测试需要   
    printf("\n");
    while (B -> next != NULL){
        printf("%d", B -> next -> data);
        B = B -> next;
    }

}