8---------单链表算法的简单应用和巩固

单链表算法主要注意处理好指针的指向问题
链表的逆置
两个链表的交集合问题(链表初始无序)
两个链表的并集问题(链表初始无序)
链表A-链表B差集问题(链表初始无序)
找到单链表倒数第k个结点并打印

#include <stdio.h>
#include <stdlib.h>
/**带头结点的单链表
* 链表的逆置
* 两个链表的交集合问题(链表初始无序)
* 两个链表的并集问题(链表初始无序)
* 链表A-链表B差集问题(链表初始无序)
* 找到单链表倒数第k个结点并打印
*/

//链表结点结构体定义
typedef struct Node{
    int data;
    struct Node * next;
}Node;

//链表的逆置
void inverse(Node * node){
    Node * q,* p;
    q = node -> next;
    while(q){
        p = q->next;
        q->next = node->next;
        node -> next = q;
        q = p;
    }
}

//链表的交集合问题,AnB=C,不破坏原本A和B链表结构
void itersection(Node * A,Node * B,Node * C){
    Node * q = A->next;
    Node * p = B->next;
    Node * c = C;   //c本身是带头结点的单链表
    Node * s;
    while(q){
        while(p){
            if(p->data == q->data){
                s = (Node *)malloc(sizeof(Node));
                s -> data = q->data;
                s -> next = NULL;
                c ->next = s;
                c = c->next;
            }
            p = p->next;
        }
        q = q->next;
    }
}

//两个链表的并集问题，AuB = C,思路，先将一个链表的所有数据线存到C，然后再B链表中的结点一一于C中的结点比较，如果有相同的就不加入
void combine(Node * A,Node * B,Node * C){
    Node * q = A->next;
    Node * p = B->next;
    Node * justc;
    Node * c = C;   //C本身是带头结点
    Node * s;
    int flag = 0;
    while(q){
        flag = 0;
        justc = C->next;
        while(justc){   //重复的就不加入到该C链表中
            if(q->data == justc ->data){
                flag = 1;
                justc = justc ->next;
            }
        }
        if(!flag){
            s = (Node *)malloc(sizeof(Node));
            s ->data = q->data;
            s->next = NULL;
            c -> next = s;
            c = c->next;
        }
        q = q->next;
    }
    while(p){
        flag = 0;
        justc = C->next;
        while(justc){
            if(c->data == p->data){
                flag = 1;
            }
        }
        if(!flag){
            s = (Node *)malloc(sizeof(Node));
            s -> data = p->data;
            s -> next = NULL;
            c-> next = s;
            c = c->next;
        }
        p = p->next;
    }
}

//计算A-B = C
void cut(Node * A,Node * B,Node * C){
    Node * p = A->next;
    Node * q = B->next;
    Node * c = C;
    Node * s;
    int flag;
    while(p){
        flag = 0;
        while(q){
            if(q -> data == p -> data){
                flag = 1;
            }
            q = q->next;
        }
        if(!flag){
            s = (Node *)malloc(sizeof(Node));
            s -> data = p -> data;
            s -> next = NULL;
            c -> next = s;
            c = c->next;
        }
        p = p->next;
    }
}

//找到单链表倒数第k个结点并打印，可以开始计数，当记时到链表的n个位置的时候，就让一个指针指向初始位置的结点，然后后移
struct Node * getInverseV(Node * node,int v){
    Node * p = node -> next;
    Node * q = NULL;
    int n = 0;
    while(p){
        n++;
        if(v == n){
            q = node -> next;
        }else if(n > v){
            q = p -> next;
        }
        p = p->next;
    }
    return q;
}

int main(){
    return 0;
}