链表-约瑟夫

#include <stdio.h>
#include <stdlib.h>
struct _Node
{
    int data;
    struct _Node *next;
};
typedef struct _Node node_t;//
typedef struct _Linklist
{
    node_t * phead;//就算下面那个结构体有一个尾指针，也不是双向,尾指针只能用来索引尾节点，没法往前索引了。只有单向,主要看方向
    //不是看头结点那个表头单向可以用双向也可以用
    node_t * ptail;
    int len;
}Linklist;
static node_t * GetNode(int i)    // 新建并初始化节点
{
    node_t *pNode;
    pNode = (node_t *) malloc(sizeof(node_t));
    if (!pNode)
    {
        printf("Error,the memory is not enough!
");
        exit(-1);
    }
    pNode->data = i;
    pNode->next = NULL;
    return pNode;
}
void init_list(Linklist *plist)    // 用第一个节点初始化循环单链表
{
    node_t *p;
    p = GetNode(1);
    //  printf("The New Node is: %d
", p -> data);   // **** TEST ****
    plist->phead = p;
    plist->ptail = p;
    p->next = plist->phead;
    plist->len = 1;
}
static void Create_List(Linklist *plist, int n)    // 把其余数据添加到循环单链表中
{
    int i = 0;
    node_t *pNew;
    for (i = 2; i <= n; i++)
    {
        pNew = GetNode(i);
        /******** TEST ********
        printf("The New Node is: %d
", pNew -> data);
        ******** TEST ********/
        plist->ptail->next = pNew;
        plist->ptail = pNew;
        pNew->next = plist->phead;
        plist->len++;
    }
    printf("Completes the e-way circulation chain table the foundation!
");
}
void Print_List(Linklist *plist)    // 输出链表内容
{
    node_t *pCur = plist->phead;//
    do
    {
        printf("The %d person.
", pCur->data);
        pCur = pCur->next;
    } while (pCur != plist->phead);
    printf("The length of the List: %d
", plist->len);
}
void joseph(Linklist *plist, int m)    //约瑟夫回环函数实现
{
    node_t *pPre = plist->ptail;
    node_t *pCur = plist->phead;
    int i;
    while (plist->len != 1)
    {
        i = 0;
        while (i < m - 1)
        {
            pPre = pPre->next;
            i++;
        }
        pCur = pPre->next;
        pPre->next = pCur->next;
        free(pCur);
        plist->len--;
    }
    printf("The last one is: %d
", pPre->data);
}
int main()
{
    int n = 0;
    printf("Please input the Length of the Circle list: ");
    scanf_s("%d", &n);
    int m = 0;
    printf("Please input the Stop point: ");
    scanf_s("%d", &m);
    Linklist pList;
    init_list(&pList);
    Create_List(&pList, n);
    Print_List(&pList);
    joseph(&pList, m);
    system("pause");
    return 0;
}

#include<iostream>
using namespace std;
struct node{
    int data;
    node*next;
};

node*header()
{
    node *head, *n;
    int a;
    head = NULL;
    cout << "首节点插入法产生链表，输入数据（-1结束）：" << endl;

    for (cin >> a; a != -1; cin >> a)
    {
        n = new node;
        n->data = a;
        if (!head)
            head = n, n->next = NULL;
        else 
            n->next = head, head = n;
    }
    return head;
}
int va(node *head)
{
    node *a, *b;
    a = head;
    b = head->next;

    for (; b != NULL; a = a->next, b = b->next)
    {
        if (a->data > b->data)
            return 0;
    }
    return 1;
}

int main()
{
    node *p1;
    p1 = header();
    node *cp = p1;//先弄个副本,p1指针要始终指向人为的head,这样循环完内存都不能回收了已经没有指针指向申请的那段内存了.head始终指向当前节点, 也就是最后申请的一个
    while (cp)
    {
        cout << cp->data << "  ";
        cp = cp->next;
    }
    if (va(p1) == 1)
        cout << "递增单链表元素！" << endl;
    else cout << "非递增单链表元素！" << endl;
    system("pause");
    return 0;
}