单链表增删改查代码实现/约瑟夫环代码实现

#include <stdio.h>

#include <stdlib.h>

//定义结点

struct node

{

    int data;

    struct node *next;

};

/***********************实现函数********************************/

//找单链表中值为key的结点

struct node *search(struct node *head,int key)

{

    struct node *p;                               //游标

    p = head->next;

    while (p!=NULL) {

        if (p->data==key) {

            return (p);

        }else

        {

            p=p->next;

        }

    }

    return NULL;

}

//单链表结点的插入,p结点后插入值为key的结点

void insert (struct node *p,int key)

{

    struct node *q;

    q = (struct node *)malloc(sizeof(struct node));

    if (!q) {

        printf("不能分配内存空间！");

        exit(0);

    }

    q->data = key;

    q->next = NULL;

    q->next = p->next;

    p->next = q;

}

//单链表结点的删除

int del(struct node *head,int key)

{

    struct node *p,*q;

    int flag = 0;

    p = head;

    while (p->next!=NULL) {

        if (p->next->data==key) {

            flag = 1;

            break;

        }else

            p = p->next;

    }//如果结点中存在值为key的结点，找到其前驱结点p，flag变量置1;

    if (flag==1) {

        q = p->next;

        p->next = q->next;

        free(q);

        return 1;

    }else

        return 0;

}

//逆序建链表

struct node *creat1(int n)

{

    struct node * head, * p;

    int i;

    head = (struct node *)malloc(sizeof(struct node));

    head->next = NULL;

    for (i=0; i<n; i++) {

        p = (struct node *)malloc(sizeof(struct node));

        scanf("%d",&p->data);

        p->next = head->next;

        head->next = p;

    }

    return (head);

}

//打印链表

void display(struct node *head, int n)

{

    int i;

    head=head->next;

    for (i=0; i<n; i++) {

        printf("%d ",head->data);

        head=head->next;

    }

    printf("\n");

}

//顺序建链表

struct node *creat2(int n)

{

    struct node  * head,* tail,* p;

    int i;

    head = (struct node *)malloc(sizeof(struct node));

    head->next = NULL;

    tail = head;

    for (i=0; i<n; i++) {

        p = (struct node *)malloc(sizeof(struct node));

        scanf("%d",&p->data);

        p->next = NULL;

        tail->next = p;

        tail = p;

    }

    return (head);

}

//单链表的逆置（带头结点）

void reverse(struct node * head)

{

    struct node * p,* q;

    p = head->next;

    head->next = NULL;

    q = p->next;

    while (p!=NULL) {

        p->next = head->next;

        head->next = p;

        p = q;

        if (q!=NULL) {

            q = q->next;

        }

    }

}

//两个带头结点的有序单链表的归并

struct node * merge(struct node *head1,struct node *head2)

{

    struct node *p1,*p2,*tail;

    p1 = head1->next;

    p2 = head2->next;

    tail = head1;

    free(head2);

    while (p1&&p2) {

        if (p1->data < p2->data) {

            tail->next = p1;

            tail = p1;

            p1 = p1->next;

        }else{

            tail->next = p2;

            tail = p2;

            p2 = p2->next;

        }

    }

    if (p1)

        tail->next = p1;

    else

        tail->next = p2;

    return (head1);

}

//单链表的拆分（拆分为负整数和非负整数）

struct node * split(struct node * head1)

{

    struct node *head2,*p,*q;

    head2 = (struct node *)malloc(sizeof(struct node));

    head2->next = NULL;

    p = head1->next;

    head1->next = NULL;

    q = p->next;

    while (p!=NULL) {

        if (p->data >= 0) {

            p->next = head1->next;

            head1->next = p;

        }else

        {

            p->next = head2->next;

            head2->next = p;

        }

        p = q;

        if (q!=NULL) {

            q = q->next;

        }

    }

    return (head2);

}

//循环链表创建，赋初始值

struct node *creat(int n)

{

    int i;

    struct node *p,*tail,*head;

    p = (struct node *)malloc(sizeof(struct node));

    p->data = 1;

    p->next = NULL;

    head = p;

    tail = p;

    for (i=2; i<=n; i++) {

        p = (struct node *)malloc(sizeof(struct node));

        p->data = i;

        tail->next = p;

        tail = p;

        p->next = NULL;

    }

    tail->next = head;//最后一个结点的指针域指向第一个结点

    return head;

}

//循环建链表、自定义数据

struct node *creat3(int n)

{

    int i;

    struct node *p,*tail,*head;

    p = (struct node *)malloc(sizeof(struct node));

    scanf("%d",&p->data);

    p->next = NULL;

    head = p;

    tail = p;

    for (i=0; i<n-1; i++) {

        p = (struct node *)malloc(sizeof(struct node));

        scanf("%d",&p->data);

        tail->next = p;

        tail = p;

        p->next = NULL;

    }

    tail->next = head;//最后一个结点的指针域指向第一个结点

    return head;

}

//约瑟夫环

int sel(struct node *head,int m,int n)//n个数m删除位置

{

    int num = 0;

    int count = 0;

    struct node *p,*q;

    q = head;

    while (q->next != head) {

        q = q->next;

    }

    printf("被删掉的序号为：");

    while (count < n-1) {

        p = q->next;

        num++;

        if (num%m==0) {

            q->next = p->next;

            printf("%3d",p->data);

            free(p);

            count++;

        }else

            q = p;

    }

    return q->data;//最后一个结点的数据域为所求的结果

}

/**************************主函数********************************/

int main(int argc, const char * argv[])

{

    int n,m;

    struct node *head;

//    scanf("%d %d",&n,&m);

//    head = creat3(n);

//    printf("\n%d\n",sel(head, m, n));

    scanf("%d",&n);

    head = creat2(n);

    display(head, n);

    return 0;

}