线性表---华山论剑篇

顺序表

例：已知线性表LA，LB中的数据元素按值非递减有序排列，现将LA，LB归并为一个新表LC，且LC数据元素值按非递减有序排列。

//一个简单地双表归并
void Merge_SqList(SqList *A,SqList *B,SqList *C)
{
	int i = 1,j = 1,k = 1;
	while(i<=A->length && j<=B->length){//两表未空
		if(A->elem[i]<=B->elem[j])
			C->elem[k++] = A->elem[i++];
		else  C->elem[k++] = B->elem[j++];
	}
	while（i<=A->length）//A表未空
		C->elem[k++] = A->elem[i++];
	while(j<=B->length)//B表未空
		C->elem[k++] = B->elem[j++];
	C->length = A->length + B->length;//长度
}

如果LA和LB是单链表呢？

LinkList Merge_LinkList(LinkList LA,LinkList LB)
{
	LinkList p = LA->next,q = LB->next;
	LA->next = NULL;
	LinkList r = LA;
	while(p && q)
	{
		if(p->data <= q->data)
		{
			r->next = p;
			r = p;
			p = p->next;
		}else{
			r->next = q;
			r = q;
			q = q->next;
		}
	}
	if(p)
		r->next = p;
	if(q)
		r->next = q;
	return LA;
}

约瑟夫（Josephus）排列问题Step1

编号为1，2，…，n的n个人按顺时针方向围坐在一张圆桌周围。给定一个正整数m≤n，从第一个人开始按顺时针方向自1开始报数，每报到m时就让其出列，从 他顺时针方向的下一个人开始重新从1报数，数到m的那个人又出列。如此下去，直至圆桌周围的人全部出列为止。每个人的出列次序定义了整数1，2，3，…，n的一个排列。这个 排列称为一个（n,m）Josephus排列。例如：（7，3）Josephus排列为3，6，2，7，5，1，4

#include <stdio.h>
#include <stdlib.h>
typedef struct LNode
{
    int index;
    struct LNode *next;
} person;

person *InitJosehus(int n)
{
    person *head = (person *)malloc(sizeof(person));
    head->next = NULL;
    head->index = 1;
    person *tail = head;
    for (int i = 2; i <= n; i++)
    {
        person *p = (person *)malloc(sizeof(person));
        p->index = i;
        p->next = NULL;
        tail->next = p;
        tail = p;
    }
    tail->next = head;
    return head;
}

void JosephusList(person *head, int m)
{
    person *p = head;
    person *q = head;
    while (q->next != head)
        q = q->next;
    while (p->next != p)
    {
        for (int i = 1; i < m; i++)
        {
            q = p;
            p = p->next;
        }
        q->next = p->next;
        printf("%d ", p->index);
        free(p);
        p = q->next;
    }
    printf("%d ", p->index);
    free(p);
}
int main(void)
{
    int n, m;
    scanf("%d%d", &n, &m);
    person *head = InitJosehus(n);
    JosephusList(head, m);
    return 0;
}

约瑟夫环（Josephus）问题

编号为1，2，…，n的n个人按顺时针方向围坐在一张圆桌周围，每人持有一个密码（正整数）。一开始任选一个正整数m作为报数上限值，从第一个人开始按顺时针方向自1开始报数，报到m时停止报数，报m的那个人出列，将他的密码作为新的m值，从他顺时针方向的下一个人开始重新从1报数，数到m的那个人又出列；如此下去，直至圆桌周围的人全部出列为止。要求按出列顺序输出n个人的编号。

#include <stdio.h>
#include <stdlib.h>
typedef struct LNode
{
    int num;
    int index;
    struct LNode *next;
} person;

person *InitJosehus(int n)
{
    person *head = (person *)malloc(sizeof(person));
    head->next = NULL;
    int x;
    scanf("%d", &x);
    head->num = x;
    head->index = 1;
    person *tail = head;
    for (int i = 2; i <= n; i++)
    {
        person *p = (person *)malloc(sizeof(person));
        scanf("%d", &x);
        p->num = x;
        p->index = i;
        p->next = NULL;
        tail->next = p;
        tail = p;
    }
    tail->next = head;
    return head;
}

void JosephusList(person *head, int m)
{
    person *p = head;
    person *q = head;
    while (q->next != head)
        q = q->next;
    int mm = m;
    while (p->next != p)
    {
        for (int i = 1; i < mm; i++)
        {
            q = p;
            p = p->next;
        }
        q->next = p->next;
        mm = p->num;
        printf("%d ", p->index);
        free(p);
        p = q->next;
    }
    printf("%d ", p->index);
    free(p);
}
int main(void)
{
    int n, m;
    scanf("%d%d", &n, &m);
    person *head = InitJosehus(n);
    JosephusList(head, m);
    return 0;
}

约瑟夫（Josephus）排列问题Step2

对于给定的1，2，3，…，n中的k个数，Josephus想知道是否存在一个正整数m(m≤n),使得Josephus（n,m）排列的最后k个数恰好为事先指定的k个数。例如当n为7，k为4，指定排列的最后k个数为7,5,1,4时；由于（7,3）Josephus排列为3,6,2,7,5,1,4；所以求得m值为3。

#include <stdio.h>
#include <stdlib.h>
typedef struct LNode
{
    int index;
    struct LNode *next;
} person;

person *InitJosehus(int n)
{
    person *head = (person *)malloc(sizeof(person));
    head->next = NULL;
    head->index = 1;
    person *tail = head;
    int i;
    for (i = 2; i <= n; i++)
    {
        person *p = (person *)malloc(sizeof(person));
        p->index = i;
        p->next = NULL;
        tail->next = p;
        tail = p;
    }
    tail->next = head;
    return head;
}

int JosephusList(int k, int n)
{
    int jose[1000];
    int i;
    for (i = 0; i < k; i++)
        scanf("%d", &jose[i]);

    int m;
    person *head;
    person *p;
    person *q;
    for (m = 1; m <= m; m++)
    {
        head = InitJosehus(n);
        p = head;
        q = head;
        while (q->next != head)
            q = q->next;
        int count = 0, c = 1;

        while (p->next != p)
        {
            for (i = 1; i < m; i++)
            {
                q = p;
                p = p->next;
            }
            q->next = p->next;
            count++;
            if (count > n - k)
            {
                jose[1000 - c] = p->index;
                c++;
            }
            free(p);
            p = q->next;
        }
        jose[1000 - k] = p->index;
        int flage = 0;
        for (i = 0; i < k; i++)
        {
            if (jose[i] != jose[1000 - i - 1])
            {
                flage = 1;
                break;
            }
        }
        if (!flage)
            return m;
        free(p);
    }
}
int main(void)
{
    int n, k;
    scanf("%d%d", &n, &k);
    int m = JosephusList(k, n);
    printf("%d", m);
    return 0;
}

一元多项式运算器——加法

一元多项式运算器——加法(by Yan)实现两个一元多项式相加运算。

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

typedef struct LNode
{
    int val;
    int index;
    struct LNode *next;
} Node, *PNode;
PNode Init(int n);
PNode Count(PNode head1, PNode head2);
void Print(PNode head);
int main(void)
{
    int n, m;
    scanf("%d", &n);
    char a = getchar();
    PNode head1 = Init(n);
    a = getchar();
    scanf("%d", &m);
    a = getchar();
    PNode head2 = Init(m);
    PNode p = Count(head1, head2);
    Print(p);
    return 0;
}
PNode Init(int n)
{
    PNode head = (PNode)malloc(sizeof(Node));
    PNode rear = head;
    int i;
    for (i = 0; i < n; i++)
    {
        PNode p = (PNode)malloc(sizeof(Node));
        scanf("(%d,%d)", &p->val, &p->index);
        rear->next = p;
        rear = p;
    }
    rear->next = NULL;
    return head;
}
PNode Count(PNode head1, PNode head2)
{
    PNode tmp = head1;
    PNode p = head1->next, q = head2->next;
    PNode rear = head1;
    head1->next = NULL;
    while (p && q)
    {
        //	printf("a\n");
        if (p->index == q->index)
        {
            p->val = p->val + q->val;
            rear->next = p;
            rear = p;
            p = p->next;
            q = q->next;
        }
        else if (p->index < q->index)
        {
            rear->next = p;
            rear = p;
            p = p->next;
        }
        else
        {
            rear->next = q;
            rear = q;
            q = q->next;
        }
    }
    if (p)
        rear->next = p;
    if (q)
        rear->next = q;
    return tmp;
}
void Print(PNode head)
{
    Node *p = head->next;
    while (p)
    {
        if (p->val == 0)
        {
            p = p->next;
            continue;
        }
        if (p->val)
        {
            if (p->index == 0)
                printf("%d", p->val);
            else if (p->index == 1)
                printf("%dX", p->val);
            else
                printf("%dX^%d", p->val, p->index);
        }
        if (p->next)
            printf("+");
        p = p->next;
    }
}