约瑟夫环问题-循环链表VS数组

2013-08-18 21:27:50

循环链表、数组解决约瑟夫环问题的比较

注意几点：

1. 循环链表的建立不难，在删除循环链表中元素时，用pCur->next != pCur判断结束；
2. 每一轮计数开始，将计数器归1，counter = 1; 
3. 并将指针指向下一个元素，pCur = pCur->next;  //从下一个元素开始计数

---

代码（测试暂未发现错误，欢迎交流指正）：

#include <iostream>
#include <cassert>
using namespace std;

typedef int DataType; 

typedef struct node
{
    DataType data;
    struct node *next;
}LNode,*PLNode;


//头插法建立循环链表
PLNode CreatCircularLink(PLNode &pHead,size_t n)
{
    pHead = NULL;
    PLNode pTail = NULL;
    PLNode pNew = NULL;
    size_t counter = n;

    while (counter >= 1)
    {
        pNew = new LNode;
        pNew->data = counter;
        pNew->next = pHead;
        pHead = pNew;

        if (NULL == pTail)
        {
            pTail = pNew;
        }
        --counter;
    }

    pTail->next = pHead;
    return pHead;
}

//利用循环链表，显示出队序列
void DisplaySequenceOfDequeue(PLNode &pHead,size_t n,size_t m)
{
    CreatCircularLink(pHead,n);

    assert( n > 0 && m > 0 && n > m );

    PLNode pCur = pHead;
    PLNode pNodeToDelete = NULL;
    size_t counter = 0;

    while (pCur->next != pCur)
    {
        counter = 1;    //新一轮计数，计数值归1
        while (counter < m - 1)
        {
            pCur = pCur->next;
            ++counter;
        }
        pNodeToDelete = pCur->next;
        pCur->next = pCur->next->next;
        cout<<pNodeToDelete->data<<"	";
        delete pNodeToDelete;

        pCur = pCur->next;  //从下一个元素开始计数
    }

    cout<<pCur->data<<"	";
    delete pCur;
    cout<<endl;
}

//显示循环链表
void DisplayCircularLink(PLNode &pHead)
{
    PLNode pCur = pHead;
    PLNode pTail = pHead;

    while (pCur->next != pTail)
    {
        cout<<pCur->data<<"	";
        pCur = pCur->next;
    }
    cout<<pCur->data<<"	";
    cout<<endl;
}

typedef struct JRnode
{
    size_t id;
    bool flag;
}JRNode,*PJRNode;
//
//void JosephRing(size_t n,size_t m,size_t *(&outQueue))
//{
//    JRNode *inQueue = new JRNode[n];
//    size_t counter = 0;
//    size_t step = 0;
//    int index = 0;
//
//    for (index = 0;index < n;++index)
//    {
//        inQueue[index].id = index + 1;
//        inQueue[index].flag = true;
//    }
//
//    index = 0;
//    while (counter < n)
//    {
//        step = 0;
//        while (step < m)
//        {
//            while (!inQueue[index].flag)
//            {
//                index = (index + 1) % n;
//            }
//            index = (index + 1) % n;
//            ++step;
//        }
//
//        inQueue[index].flag = false;
//        outQueue[counter++] = index;   
//
//        /*if (index == n)
//        {
//        index = n - 1;
//        }*/
//        
//    }
//
//    delete [] inQueue;
//}

//用数组解决
void Circle_out(size_t n, size_t s, size_t m, size_t *p)
{
    int i;
    int *circle = new int[n];
    int pos = s-1;
    int cnt = 0;
    int p_cnt = 0;
    int N = n;
    for(i=0;i<n;++i)
        circle[i] = 0;
    while(n--)
    {
        cnt = m;
        while(cnt)
        {
            if(circle[pos]==0)        //如果该位置未出圈，将该位置计入
                cnt--;
            pos++;
            if(pos==N)        //注意：不是if(pos==n)，因为n在执行的过程中是变化的，是临时变量
                pos = 0;
        }
        //cout<<"pos = "<<pos<<endl;
        if(pos==0)            //此处必须对pos为0的情况进行特殊处理
        {
            circle[N-1] = 1;
            p[p_cnt++] = N;
        }
        else
        {
            circle[pos-1] = 1;        //circle[pos-1]，not circle[pos]
            p[p_cnt++] = pos;    //pos,not (pos-1)
        }    
    }
    delete [] circle;
}

void DisplayArray(size_t *array,size_t len)
{
    assert(NULL != array && len > 0);
    size_t index = 0;

    while (index < len)
    {
        cout<<array[index]<<"	";
        index++;
    }
    cout<<endl;

}

//测试约瑟夫环
void TestCircularLink()
{
    PLNode pHead = NULL;
    size_t n = 0;
    size_t m = 0;

    cout<<"Please enter n and m : "<<endl;
    while (cin>>n>>m)
    {
        //CreatCircularLink(pHead,n);
        //DisplayCircularLink(pHead);
        cout<<"(DisplaySequenceOfDequeue)The Sequence Of Dequeue is :"<<endl;
        DisplaySequenceOfDequeue(pHead,n,m);

        size_t *outQueue = new size_t[n];
        Circle_out(n, 0, m, outQueue);

        cout<<"(Circle_out)The Sequence Of Dequeue is :"<<endl;
        DisplayArray(outQueue,n);

        delete [] outQueue;

        cout<<"Please enter n and m : "<<endl;
    }
}

int main()
{
    TestCircularLink();
    return 0;
}

测试结果：

Please enter n and m :
5 2
(DisplaySequenceOfDequeue)The Sequence Of Dequeue is :
2       4       1       5       3
(Circle_out)The Sequence Of Dequeue is :
2       4       1       5       3
Please enter n and m :
5 3
(DisplaySequenceOfDequeue)The Sequence Of Dequeue is :
3       1       5       2       4
(Circle_out)The Sequence Of Dequeue is :
3       1       5       2       4
Please enter n and m :
^Z
请按任意键继续. . .