初学数据结构五

void MergeList(LinkList &ha, LinkList &hb, LinkList &hc)
{
    LinkList pa, pb;
    pa = ha;
    pb = hb;
    while (pa->next && pb->next)
    {
        pa = pa->next;
        pb = pb->next;
    }
    if (!pa->next)
    {
        hc = hb;
        while (pb->next)
            pb = pb->next;
        pb->next = ha->next;
    }
    else
    {
        hc = ha;
        while (pa->next)
            pa = pa->next;
        pa->next = hb->next;
    }
}


Status DeleteAndInsertSub(LinkList &la, LinkList &lb, int i, int j, int len)
{
    LinkList p, q, s, prev = NULL;
    int k = 1;
    if (i < 0 || j < 0 || len < 0)
        return INFEASIBLE;
    p = la;
    while (p && k < i)
    {
        prev = p;
        p = p->next;
        k++;
    }
    if (!p)
        return INFEASIBLE;
    q=p;
    k = 1;
    while (q && k < len)
    {
        q = p->next;
        k++;
    }
    if (!q)
        return INFEASIBLE;
    if (!prev)
        la = q->next;
    else
        prev->next = q->next;
    if (j = 1)
    {
        q->next = lb;
    lb = p;
    }
    else
    {
        s = lb;
        k = 1;
        while (s && k < j - 1)
        {
            s = s->next;
            k++;
        }
        if (!s)
            return INFEASIBLE;
        q->next = s->next;
        s->next = p;
    }
    return OK;
}


Status ListDelete_L(LinkList &L, ElemType mink, ElemType maxk)
{
    LinkList p, q, prev = NULL;
    if (mink > maxk)
        return ERROR;
    p = L
        prev = p;
    p = p->next;
    while (p && p-> data < maxk)
    {
        if (p->data <= mink)
            prev = p;
        p = p->next;
    }
    else
    {
        prev->next = p->next;
        q = p;
        p = p->next;
        free(q);
    }
    }
return OK;
}

Status ListOppose_Sq(SqList &L)
{
    int i;
    ElemType x;
    for (i = 0; i < L.length / 2; i++)
    {
        x = L.elem[i];
        L.elem[i] = L.elem[L.length - 1 - i];
        L.elem[L.length - 1 - i] = x;
    }
    return OK;
}

Status ListOppose_L(LinkList &L)
{
    linkList p, q;
    p = L;
    p = p->next;
    L - next = NULL;
    while (p)
    {
        q = p;
        p = p->next;
        q->next = L->next;
        L->next = q;
    }
    return OK;
}
Status ListOppose_L(LinkList&L)
{
    Linklist p, q;
    p = L;
    p = p->next;
    L->next = NULL;
    while (P)
    {
        q = p;
        p = p->next;
        q->next = L->next;
        L->next = q;
    }
    return OK;
}

#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;
}