#if !defined(AFX_QUEUELIST_H__E1E0BFBA_9B05_4657_9A37_52A6FBFD596A__INCLUDED_)
#define AFX_QUEUELIST_H__E1E0BFBA_9B05_4657_9A37_52A6FBFD596A__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

class queuelist 
{
public:
 queuelist                                      ();
 virtual ~queuelist                             ();
 int JumpOut                                    ();
 int InserttheList                              (int element);
 void SetNull                                   ();
 bool ChargeEmpty                               ();
 bool ChargeFull                                ();
 int GetTotal_num                               ();
 int GetRear                                    () { return rear; }
 int GetFront                                   () { return front; }
private:
 int total_num;
 int Race_list[10];
 int front;
 int rear;
};

#endif // !defined(AFX_QUEUELIST_H__E1E0BFBA_9B05_4657_9A37_52A6FBFD596A__INCLUDED_)

 

#include "stdafx.h"
#include "queuelist.h"

#include <iostream>
using namespace std;

 

queuelist::queuelist()
{
 for(int i=0; i<9; i++)
 {
  Race_list[i] = i+1;
 }
 front = 9;
 rear = 8;
 total_num = 9;
}

queuelist::~queuelist()
{
}

int queuelist::InserttheList(int element)
{
 if(ChargeFull())
 {
  cout << "队列已满,不能再插入元素" << endl;
  return -1;
 }
 else
 {
  rear = (rear+1)%10;
  Race_list[rear] = element;
  total_num++;
  return Race_list[rear];
 }
}

int queuelist::JumpOut()
{
 if(ChargeEmpty())
 {
  cout << "队列为空,不能跳出元素" << endl;
  return -1;
 }
 else
 {
  front = (front+1)%10;
  total_num--;
  return Race_list[front];
 }
}

void queuelist::SetNull()
{
 front = 0;
 rear = 0;
}

bool queuelist::ChargeEmpty()
{
 if(rear == front)
  return true;
 else
  return false;
}

bool queuelist::ChargeFull()
{
 if(((rear+1)%10)==front)
  return true;
 else
  return false;
}

int queuelist::GetTotal_num()
{
 return total_num;
}

 

 

#include "stdafx.h"
#include "queuelist.h"

#include <iostream>
using namespace std;

typedef struct result{

 int Group_Record[9];

}RESULT;

 
typedef struct newr{

    int Crash_Record[9];
  
}NEWR;

//冲突矩阵//
 int R[][9] = {
  {0,1,0,0,0,0,0,0,0},
  {1,0,0,0,1,1,0,1,1},
  {0,0,0,0,0,1,1,0,0},
  {0,0,0,0,1,0,0,0,1},
  {0,1,0,1,0,1,1,0,1},
  {0,1,1,0,1,0,1,0,0},
  {0,0,1,0,1,1,0,0,0},
  {0,1,0,0,0,0,0,0,0},
  {0,1,0,1,1,0,0,0,0}};

 

bool ChargeQuarrel(int* crash, int* ending, int position, int groups)
{
 if(crash[position]==0)
 {
  ending[position] = groups;
  for(int i=0; i<9; i++)
  {
   crash[i] = crash[i] + R[position][i];
  }
  return false;
 }
 
 else
 {
  return true;
 }
}

int main(int argc, char* argv[])
{
 int g_row = 1;
 queuelist cq;
 RESULT Into_dif_group;
 NEWR of_Crash;
 
    // 初始化 result 和 newr 两个数组//
 for(int i=0; i<9; i++)
 {
  Into_dif_group.Group_Record[i] = 0;
  of_Crash.Crash_Record[i] = 0;
 }
 //划分子集//
 while(!cq.ChargeEmpty())
 {
  int num = cq.GetTotal_num();
  for(int k=0; k<num; k++)
  {
   int temp = cq.JumpOut();
  
      //判断是否冲突//
      if(ChargeQuarrel(of_Crash.Crash_Record, Into_dif_group.Group_Record, (temp-1), g_row))
   {
       cq.InserttheList(temp);
   }
  }
  //清空冲突数组newr//
  for(int q=0; q<9; q++)
  {
   of_Crash.Crash_Record[q] = 0;
  }
        //组序号加一//
  g_row++;
 }

 //输出//
 for(int m=1; m<g_row; m++)
 {
  cout << "第" << m << "组元素:" << endl;
   for(int n=0; n<9; n++)
  {
   if(Into_dif_group.Group_Record[n]==m)
    cout << (n+1) << " ";
  }
  cout << endl;
 }
 return 0;
}

 

 

#if !defined(AFX_SEQUEUE_H__29A28262_0EBE_4813_BAAF_FDA1156DFABD__INCLUDED_)
#define AFX_SEQUEUE_H__29A28262_0EBE_4813_BAAF_FDA1156DFABD__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

class sequeue 
{
public:
 sequeue                         ();
 virtual ~sequeue                ();
 void SetNullSequeue             ();
 bool ChargeEmpty                ();
 bool ChargeFull                 ();
 int& GetFrontELe                ();
 int& InsertSequeue              ();
 int& InsertZero                 ();
 int& InsertZero                 (int meaningless);
 int& JumpOut                    ();
private:
 int data[10];
 int front;
 int rear;
};

#endif // !defined(AFX_SEQUEUE_H__29A28262_0EBE_4813_BAAF_FDA1156DFABD__INCLUDED_)

 

 

// sequeue.cpp// 

#include "stdafx.h"
#include "sequeue.h"
#include <iostream>
using namespace std;

 

sequeue::sequeue()                      //构造队列//
{
 front = 10 - 1;
 data[0] = 0;
 data[1] = 1;
    data[2] = 1;
 data[3] = 0;
 rear = 3;
 cout << "1" << endl;
 cout << "1" << " " << "1" << endl;
}

sequeue::~sequeue()
{
}

bool sequeue::ChargeEmpty()            //判断队列是否为空//
{
 if(rear==front)
  return true;
 else
  return false;
}

bool sequeue::ChargeFull()                 //判断队列是否为满//
{
 if((rear+1)%10 == front)
  return true;
 else
  return false;
}

int& sequeue::GetFrontELe()               //取出队列头元素//
{
 if(data[front]!=0)
  cout << data[front] << " ";
 return data[front];
}

int& sequeue::InsertSequeue()                      //插入队列//
{
 int x;
 if(ChargeFull())
 {
  cout << "数组溢出" << endl;
  exit(0);
 }
 else
 {
  x = GetFrontELe() + JumpOut();
  rear = (rear+1)%10;
  data[rear] = x;
  return data[rear];
 }
}

int& sequeue::InsertZero()          //插入队列前的零//
{
 if(ChargeFull())
 {
  cout << "数组溢出" << " ";
  exit(0);
 }
 else
 {
  JumpOut();
  rear = (rear+1)%10;
  data[rear] = 0;
  return data[rear];
 }
}

int& sequeue::InsertZero(int meaningless)                  //插入队列后的零//
{
 if(ChargeFull())
 {
  cout << "数组溢出" << " ";
  exit(0);
 }
 else
 {
  rear = (rear+1)%10;
  data[rear] = 0;
  return data[rear];
 }
}

int& sequeue::JumpOut()                     //跳出队列//
{
 int x;
 if(ChargeEmpty())
 {
  cout << "数组为空" << endl;
  exit(0);
 }
 else
 {
  x = front;
  front = (front+1)%10;
     return data[front];
 }
}

void sequeue::SetNullSequeue()                 //置空队列//
{
 rear = front;
}

 

 

#include "stdafx.h"
#include "sequeue.h"
#include <iostream>
using namespace std;

int main(int argc, char* argv[])
{
 sequeue Queue;

 for(int i=2; i<7; i++)
 {
  Queue.InsertZero();
  for(int j=1; j<=(i+1); j++)
   Queue.InsertSequeue();
  Queue.InsertZero(1);
  cout << endl;
 }
 return 0;
}