双向链表，链表求A与B差集，链表多项式相加，静态链表

双向链表

    #include<stdio.h>  
    #include<stdlib.h>  
    #define ELEMTP int  
    typedef struct Lnode  
    {  
        ELEMTP data;  
        struct Lnode *prior;  
        struct Lnode *next;  
    }Lnode;  
    Lnode *create()//尾插法建立双链表  
    {  
        Lnode *head, *p, *p2;  
        ELEMTP x;  
        head = (Lnode *)malloc(sizeof(Lnode));  
        head->next = NULL;  
        p = head;  
        scanf_s("%d", &x);  
        while (x != -1)  
        {  
            p2 = (Lnode *)malloc(sizeof(Lnode));  
            p2->data = x;  
    //      p2->next = p->next;  
          
            p2->prior = p;  
            p->next = p2;  
            p = p->next;  
            scanf_s("%d", &x);  
        }  
        p->next = NULL;  
        return head;  
    }  
    Lnode *insert(Lnode *head,int i,ELEMTP x)  
    {  
        Lnode *p, *s;//s为要插入的结点  
        p = head;  
        for (int k = 1; k <=i; k++)  
            p = p->next;  
      
        s = (Lnode *)malloc(sizeof(Lnode));  
        s->data = x;  
      
        s->prior = p->prior;//将p的前驱结点p1作为s的前驱结点  
        s->next = p;  
        p->prior->next = s;  
        p->prior = s;//注意顺序不能乱了  
        return head;  
    }  
    Lnode *del(Lnode *head,int i)  
    {  
        Lnode *p;  
        p = head;  
        for (int k = 1; k <= i; k++)  
            p = p->next;  
        if (p == NULL)printf("位置不合法\n");  
        else if (p->next == NULL)//最后一个结点做特殊处理  
        {  
            p->prior->next = NULL;  
            free(p);  
        }  
        else  
        {  
            p->prior->next = p->next;  
            p->next->prior = p->prior;  
            free(p);  
        }  
            return head;  
    }  
    void outline(Lnode *head)  
    {  
        Lnode *p;  
        p = head->next;  
        while (p != NULL)  
        {  
            printf(" %2d", p->data);  
            p = p->next;  
        }  
    }  
    int main()  
    {  
        Lnode *head; int i; ELEMTP x;  
        head = create();  
        outline(head);  
        printf("\n要插入的位置"); scanf_s("%d", &i);  
        printf("要插入的大小"); scanf_s("%d", &x);  
        head = insert(head,i,x);  
        outline(head);  
        printf("\n要删除的位置"); scanf_s("%d", &i);  
        head = del(head, i);  
        outline(head);  
        return 0;  
    }  

集合A用单链表La表示，集合B用单链表Lb表示，设计算法求A与B两个集合的差，即A-B

分析

A-B即属于A而不属于B的元素，对集合A的每个元素x，在集合B中进行查找，如果存在与x相同的元素，删除x在A中的结点。

#include<stdio.h>
#include<stdlib.h>

typedef struct Lnode
{
	int data;
	struct Lnode *next;
}Lnode;
struct Lnode *create()//尾插法建立链表，不熟悉的请见数据结构之链表基础
{
	Lnode *head, *p, *p2;
	head = (Lnode *)malloc(sizeof(Lnode));
	head->next = NULL;
	p = head;
	int x;
	scanf_s("%d", &x);
	while (x != -1)
	{
	p2= (Lnode *)malloc(sizeof(Lnode));
	p2->data = x;
	p->next = p2;
	p = p2;
	scanf_s("%d", &x);
	}
	p->next = NULL;
	return head;
}

void outline(Lnode *head)
{
	Lnode *p;
	p = head->next;
	while (p != NULL)
	{
		printf(" %2d", p->data);
		p = p->next;
	}
}
Lnode *chaji(Lnode *La, Lnode *Lb)//属于La而不属于Lb的元素
{
	Lnode *p, *prep,*q,*r;
	prep = La;
	p = La->next;//p是La中的某一结点，prep是p的前驱结点；
	while (p != NULL)
	{
		q = Lb->next;//依次扫描Lb看是否有与La表中p指向的结点相同的结点
		while (q && q->data != p->data)q = q->next;
		if (q != NULL)//在Lb中找到与La中p指向的结点相同的结点，删除p指向的结点
		{
			r = p;
			prep->next = p->next;//删除结点
			p = p->next;//指向下一个结点
			free(r);
		}
		else  //未找到相同结点，继续在La中找，p指向下一个，s指向p前驱
		{
			prep = p; p = p->next;
		}
	}
	return La;

}
int main()
{
	Lnode *La,*Lb;
	printf("输入La元素，-1结束\n");
	La= create();
	outline(La);
	printf("\n输入Lb元素，-1结束\n");
	Lb = create();
	outline(Lb);
	printf("\nLa与Lb的差集\n");
	La = chaji(La, Lb);
	outline(La);
}

多项式相加

#include<stdio.h>
#include<stdlib.h>
#define OK 1
#define Status int
typedef struct Lpoly
{
	int coef; //系数
	int exp; //指数
	struct Lpoly *next;
}Lpoly;
Lpoly *CreatList(Lpoly *head,int n)
{
	Lpoly  *p, *p2;
	head = (Lpoly *)malloc(sizeof(Lpoly));
	head->next = NULL;
	p = head;
	for (int i = 0; i < n; i++)
	{
		p2 = (Lpoly *)malloc(sizeof(Lpoly));
		printf("coef：");
		scanf("%d", &(p2->coef));
		printf("exp：");
		scanf("%d", &(p2->exp));
		p->next = p2;
		p = p2;
	}
	p->next = NULL;
	return head;
}
void Print(Lpoly *head)
{
	Lpoly *p;
	p = head->next;
	while (p)
	{
		printf("%dX^%d",p->coef,p->exp);
		if (p->next)printf("+");
		p = p->next;
	}
	printf("\n");
}
Lpoly *AddPolyn(Lpoly *La, Lpoly *Lb)
{
	Lpoly *pa, *pb,*pc,*Lc;
	pa = La->next; pb = Lb->next;
	Lc = pc = La;
	while (pa&&pb)
	{
		if (pa->exp > pb->exp)
		{
			pc->next = pa;
			pc = pa;
			pa = pa -> next;
		}
		else if (pa->exp < pb->exp)
		{
			pc->next = pb;
			pc = pb;
			pb = pb->next;
		}
		else
		{
			if (pa->coef + pb->coef != 0)
			{
				pa->coef = pa->coef + pb->coef;//注意是改变pa的系数，然后接在pc后面
				pc = pa;
			}
				pa = pa->next;
				pb = pb->next;
		}
	}
	pc->next = pa ? pa : pb;
	return Lc;
}
int main()
{
	Lpoly *La, *Lb,*Lc;
	int na, nb;
	La = Lb = NULL;
	printf("创建La,降序,输入项数na：\n");
	scanf("%d", &na);
	La=CreatList(La, na);
	printf("创建Lb,降序，输入项数nb：\n");
	scanf("%d", &nb);
	Lb = CreatList(Lb, nb);
	printf("La为：");
	Print(La);
	printf("Lb为：");
	Print(Lb);
	Lc = AddPolyn(La, Lb);
	Print(Lc);
	return 0;
}

静态链表

/*用数组描述的链表称为静态链表*/  
#include <stdio.h>    
#include <stdlib.h>    
  
#define MAX 100    
#define OK 1    
#define Status int    
typedef struct  
{  
    int data;  
    int cur;  
}StackLinkList[MAX];  
int av = -1, h = -1;  
Status Initlist(StackLinkList space)//初始化    
{  
    int i;  
    for (i = 0; i<MAX - 1; i++)  
        space[i].cur = i + 1;  
    space[MAX - 1].cur = -1;//静态链表为空，最后一个元素的cur为-1；  
    av = 0;  
    return OK;  
}  
  
Status Insert(StackLinkList L, int x)  
{  
    if (av == -1)printf("没有空位置\n");  
    else  
    {  
        int i;  
        i = av;  
        av = L[i].cur;  
        L[i].data = x;  
        L[i].cur = h;  
        h = i;  
    }  
    return OK;  
}  
  
int Delete(StackLinkList L,int *x)  
{  
    int i;  
    if (h != -1)//h=-1表示静态链表全有元素  
    {  
        *x = L[h].data;  
        i = h;  
        h = L[h].cur;  
        L[i].cur = av;  
        av = i;  
    }  
    return OK;  
}  
  
void Outline(StackLinkList L)  
{  
    int H = h;//把h的值给H，否则会改变h的值  
    while (H != -1)  
    {  
        printf("%2d ", L[H].data);  
        H = L[H].cur;  
    }  
}  
  
int main()  
{  
    StackLinkList L;  
    int cord, result;  
    do  
    {  
        printf("\n1.初始化静态链表\n");  
        printf("2.插入新元素\n");  
        printf("3.删除元素\n");  
        printf("4.显示\n");  
        scanf_s("%d", &cord);  
        switch (cord)  
        {  
        case 1:  
        {  
                  result = Initlist(L);  
                  if (result == OK)printf("成功初始化\n");  
        }break;  
        case 2:  
        {  
                  int x;  
                  printf("输入要插入的元素x: ");  
                  scanf_s("%d", &x);  
                  Insert(L, x);  
        }break;  
        case 3:  
        {  
                  int x;  
                  if (Delete(L, &x))  printf("成功删除元素 %d\n", x);  
        }break;  
        case 4:  
        {  
                  Outline(L);  
        }break;  
        }  
  
    } while (cord<5);  
  
    return 0;  
}