درخواست کمک برای کلاس لیست

با سلام من یه کلاس برای لیست نوشتم اما چند تا مشکل داره ممنون میشم کمکم کنید:
1. تابع سارنده ای که تعریف کردم به این فرمه

کد:

---

list(int element = 0)
{
first = new ListNode ;
first->data = element;
first->link = NULL;
}

---

حالا وقتی یه شی می سازم تابع اضافه کردن را صدا میزنم یه گره با مقدار صفرم دارم که من نمی خوام .اگر سازنده رو بدون ارگومان (یعنی فقط خط سوم کد را داشته باشه)صدا بزنم تو خروجی یه ادرس نشون میده

2.تابع حذف هم مشکل داره به کد زیر نگاه کنید نمی تونه چیزی رو حذف کنه نه کد خودم کار می کنه نه کدی که از اینترنت گرفتم.موقع فراخوانی تابع میگه که del :indentifier not found

کد:

---

del( int num )
{
    node *q,*r;
  q = p;
  if( q->data == num )
  {
        p = q->link;
      delete q;
      return;
  }
  r = q;
  while( q!=NULL )
  {
        if( q->data == num )
      {
          r->link = q->link;
        delete q;
        return;
      }
      r = q;
      q = q->link;
  }
  cout<<"\nElement "<<num<<" not Found.";
}

---

3. یه تابع برای الحاق دو لیست نوشتم که اونم مشکل داره و تابعbreak میشه

کد:

---

void concatlist(list x)
{
listnode* t;
if(!first)
first=x.first;
else
for(t=first;t!=NULL;t->link)
{
  t=t->link;
}
t->link=x.first;
}

---

:41::19::19::41:

کد:

---

#include <iostream>
using namespace std;
class linklist
{
    private:
            struct node
        {
              int data;
            node *link;
        }*p;
  public:
            linklist();
        void append( int num );
        void add_as_first( int num );
        void addafter( int c, int num );
        void del( int num );
        void display();
        int count();
        ~linklist();
};
linklist::linklist()
{
    p=NULL;
}
void linklist::append(int num)
{
    node *q,*t;
  if( p == NULL )
  {
        p = new node;
      p->data = num;
      p->link = NULL;
  }
  else
  {
        q = p;
      while( q->link != NULL )
          q = q->link;
      t = new node;
      t->data = num;
      t->link = NULL;
      q->link = t;
  }
}
void linklist::add_as_first(int num)
{
    node *q;
  q = new node;
  q->data = num;
  q->link = p;
  p = q;
}
void linklist::addafter( int c, int num)
{
    node *q,*t;
  int i;
  for(i=0,q=p;i<c;i++)
  {
        q = q->link;
      if( q == NULL )
      {
          cout<<"\nThere are less than "<<c<<" elements.";
        return;
      }
  }
  t = new node;
  t->data = num;
  t->link = q->link;
  q->link = t;
}
void linklist::del( int num )
{
    node *q,*r;
  q = p;
  if( q->data == num )
  {
        p = q->link;
      delete q;
      return;
  }
  r = q;
  while( q!=NULL )
  {
        if( q->data == num )
      {
          r->link = q->link;
        delete q;
        return;
      }
      r = q;
      q = q->link;
  }
  cout<<"\nElement "<<num<<" not Found.";
}
void linklist::display()
{
    node *q;
  cout<<endl;
  for( q = p ; q != NULL ; q = q->link )
        cout<<endl<<q->data;
}
int linklist::count()
{
    node *q;
  int c=0;
  for( q=p ; q != NULL ; q = q->link )
        c++;
  return c;
}
linklist::~linklist()
{
    node *q;
  if( p == NULL )
        return;
  while( p != NULL )
  {
        q = p->link;
      delete p;
      p = q;
  }
}
int main()
{
    linklist ll;
  cout<<"No. of elements = "<<ll.count();
  ll.append(12);
  ll.append(13);
  ll.append(23);
  ll.append(43);
  ll.append(44);
  ll.append(50);
  ll.add_as_first(2);
  ll.add_as_first(1);
  ll.addafter(3,333);
  ll.addafter(6,666);
  ll.display();
  cout<<"\nNo. of elements = "<<ll.count();
  ll.del(333);
  ll.del(12);
  ll.del(98);
  cout<<"\nNo. of elements = "<<ll.count();
  return 0;
}

---

ممنون اما من ایراد کارم رو می خواستم.دوستان من کلاسمو به صورت کلاس پایه و مشتق تعریف کردم اما نمیدونم چرا برای دسترسی به عضوهای محافظت شده خطا میده اینم کدشه

کد:

---

class ListNode
{
protected:
 int      data1;
 float    data2;
 bool      action;
 ListNode* link;
public:
 ListNode(int &a,float &b,bool &c,ListNode*p=NULL):data1(a),data2(b),action(c),link(p){}
 void set(int a,float b,bool c)
 {
  data1=a;
  data2=b;
  action=c;
 }
};
class List : public ListNode
{
protected:
 ListNode* first;
 ListNode* newNode(int &a,float &b,bool &c,ListNode*p)
 {
  ListNode* q=new  ListNode(a,b,c,p);
  return q;
 }
public:
 int Inaction(int element)
 {
    ListNode* t=first;
      while(t->link != NULL)
  {
  if(t->data1 == element)
  t->action = false;
  return 1;
  else
    t = t->link;
  }
 }
};

---

روش استفاده از اعضای محافظت شده را کامل متوجه نشده اید

به مثال زیر یک نگاهی بیندازید :

کد:

---

class Parent
{
protected :
int data;
};
class Child : public Parent
{
public :
Child * head;
Parent * Parenthead;
void AddFirst();
};
void Child::AddFirst()
{
//قابل دسترس
int i1= this->data;
// قابل دسترس
int i2=this->head->data;
// غیر قابل دسترس
int i3=this->Parenthead->data;
Parent * p=new Parent();
// غیر قابل دسترس
int i4=p->data;
}

---

ممنون دوست عزیز،اگه بخوام به تعدادی که کاربر اونو وارد میکنه از یک کلاس شی تولید کنم چیکار باید بکنم؟

نقل قول:

---

نوشته شده توسط MIG [ برای مشاهده لینک ، با نام کاربری خود وارد شوید یا ثبت نام کنید ]

ممنون دوست عزیز،اگه بخوام به تعدادی که کاربر اونو وارد میکنه از یک کلاس شی تولید کنم چیکار باید بکنم؟

---

با آرایه ها ...

نقل قول:

---

نوشته شده توسط MIG [ برای مشاهده لینک ، با نام کاربری خود وارد شوید یا ثبت نام کنید ]

ممنون دوست عزیز،اگه بخوام به تعدادی که کاربر اونو وارد میکنه از یک کلاس شی تولید کنم چیکار باید بکنم؟

---

اگر سوالتون در امتداد برنامه ای که دارید می نویسید باشه منظورتون اینه که کاربر تعداد گره های لیست پیوندی را وارد می کند و شما میخواهید لیست را ایجاد کنید درسته؟ اگر این طوره باید از یک حلقه استفاده کنید.

اگر منظورتون چیز دیگری است توضیح بیشتری بدهید.

من یه گراف رو با لیست مجاورتی از کاربر گرفتم که هر گره تو این گراف نیاز داره لیست گره های غیرهمسایه اش را داشته باشه .از این کلاس به عنوان پایه برای یه کلاس دیگه استفاده کردم که هر شی این کلاس مشتق باید لیست گره های غیرهمسایه اش و چند تا چیز دیگه را داشته باشه .حالا می خوام به تعدادی که کاربر وارد می کنه از کلاس مشتق شده شی بسازم .تو سازنده کلاس، لیست گره های غیر همسایه اش بر اساس شناسه شی می تونه بگیره پس باید شناسه ای که کاربر وارد میکنه شماره یکی از گره هایی باشه که تو لیست مجاورتی وارد کردیم.امیدوارم منطورم را رسونده باشم

شما می خواین کاربر تعداد گره ها رو وارد کنه و شما به تعداد اون لیست پیوندی تعریف شده توسط خودتون ایجاد کنین ؟ که یه گراف رو ذخیره کنین ؟ اگه این جوری هست باز هم می گم استفاده از آرایه ها .

نه این چیزی که شما می گید رو من انجام دادم و گراف را گرفتم ،حالا می خوام از کلاس دیگه ای که از کلاس گراف مشتق شده چند تا شی بسازم که سازنده هر گره لیست گره های غیر همسایه اون گره و... موقع ایجاد اون شی بهش نسبت می ده .میشه من برنامه ای که نوستم رو براتون ارسال کنم با صورت مساله. ببخشید من زیادی مبتدیم

صورت مساله و برنامه رو بزار ببینیم قضیه چیه!

چشم اما خواهش می کنم یکی کمکم کنه اینو باید 9 روز دیگه تحویل بدم.نمی خوام که برام بنویسید فقط گام به گام منو راهنمایی کنید بنویسمش.من دانشگاه هر چی برنامه تحویل می دادم دستی بود چون اون موقع سیستم نداشتم بلد نیستم ایراد برنامه مو پیدا کنم.اول کلاس ها رو با دوست نوستم بعد اومدم از مشتق استفاده کنم اما حالا برنامه که قبلا حداقل کار می کرد حالا نمی کنه
برنامه اول:

کد:

---

// link list.cpp : Defines the entry point for the console application.

---

کد:

---

//

#include "stdafx.h"

#include "link list.h"
#include <iostream>
#include<conio.h>
#ifdef _DEBUG
#define new DEBUG_NEW
#endif

 

// The one and only application object

CWinApp theApp;
using namespace std;
class List;
class ListIterator;
class ListNode;
class Graph;
/////////////////////////////////////////
class ListNode
{
friend class List;
friend class Graph;
friend class LA;
int data;
ListNode* link;
};                  // end class ListNode
class ListNode2
{
friend class List;
friend class Graph;
friend class LA;
int data1;
float data2;
ListNode2* link;
};                // end class ListNode2
class List
{
friend class ListIterator;
friend class Graph;
friend class LA;
ListNode*  first;
ListNode2* First;

 

public:

List(int element=0)
{
first = new ListNode;
first->data = element;
first->link = NULL;
}
//List(int element1=0,float element2=0)
//{
// First = new ListNode2;
// First->data1 = element1;
// First->data2 = element2;
// First->link = NULL;
//}

 

////////////////////////////////////////////end fo constructor

void InsertFirst(int element)
{
ListNode* t;
t = new ListNode;
t->data = element;
t->link = first;
first=t;

 

}       

//////////////////////////////////////// end of  InsertFirst
/* void InsertIn( int element,ListNode* befor)
{
ListNode* t;
t = new ListNode;
if(first)
{
 t->data = element;
 t->link = befor->link;
 befor->link = t;
}
else
 t->data = element;
 t->link = NULL;
 first= t;
} */ 
//////////////////////////////////////// end of Insert
void InsertEnd( int element)
{    ListNode* t,* s;
t = new ListNode;
if(!first)
{
 t->data = element;
 t->link = NULL;
}
else
{  s = first;
while(s->link != NULL)
 s = s->link;
    t->data = element;
 s->link = t;
 t->link = NULL;
}
}
//////////////////////////////////// end of Insert
void deleteNode(int element)
{
/*ListNode* t,* x;
t=first;
if(t->data == element)
{
first = t->link;
delete t;
return;
}
while(t->data != element)
{
t = x;
t=t->link ;
}

 

x->link = t->link;*/

ListNode* t,* h;
t = first;
if(t->data == element)
{
first = t->link;
delete t;
return;
}
h=t;
while(t != NULL)
{
if(t->data == element)
{
 h->link = t->link ;
 delete t;
 return;
}
h=t;
t=t->link ;
}
cout<<"\n element" <<" "<<element<<" "<<"Not found"<<endl;

 

}

/////////////////////////////////////////end of deleteNode
List Inaction(List t)
{

 

}               

///////////////////////////////////////// end of Inaction
int count()
{
ListNode *t;
int count=0;
for(t=first;t!=NULL;t=t->link)
{
count++;

 

}

return count-1;
}               
//////////////////////////////////////////// end of count
void ConcatList(List x)
{
ListNode* t;
if(!first)
{
first = x.first;
return;
}
if(x.first)
{
for(t = first;t->link;t = t->link);
t->link = x.first;
/*t=first;
while(t!=NULL)
{
 t = t->link;
}
t->link = x.first;*/
}
}
//////////////////////////////////////////////end of ConcatList
void Display()
{
ListNode*  current;
  current = first;

 

while(current != NULL)

{
cout<<current->data<<endl;
 current = current->link;
}
}
/////////////////////////////////////////end of display
~List()
{
ListNode* t,* h;
t = first;
while(t != NULL)
{
h = t;
t = t->link ;
delete h;
}
}
};//end class link list
////////////////////////////////////////////////////////////////////////////////////////
class Graph
{
friend class LA;
  List* headNodes;
int v,ID,num,temp,number,count;
public:
Graph(int v=0)
{
headNodes = new List[v+1];
}
///////////////////////////////////////end of constractor
void getANDset(int vertex)
{
List AllNodes;
cout<<"Please repeat follow steps for each node"<<endl<<endl;
for(int i=0;i<vertex;i++)
{
cout<<"1. enter vertex ID:";
cin>>ID;
AllNodes.InsertEnd(ID);
cout<<"2. enter number of neghbour vertice:";
cin>>num;
for(int j=0;j<num;j++)
{
 cout<<"enter neghbour vertex"<<" "<<(j+1)<<" "<<":";
    cin>>number;
 temp = number;
 headNodes[ID].InsertFirst(temp);
}//end for j

 

}//end for i

AllNodes.Display();
//return AllNodes;
}
//////////////////////////////////////////end of getANDset
int CountNeghbourNodes(int v)
{ int count=0;
ListNode* t;
t = headNodes[v].first;
for(t; t->link; t = t->link)
{
count++;
}
return count;
}
///////////////////////////////////////end of CountNeghbourNode
void DisplayNeighbourNodes(int v)
{
ListNode* t;
t = headNodes[v].first;
cout<<"[";
for(t; t->link; t=t->link)
{cout<< t->data <<" ";}
cout<<"]";
}
///////////////////////////////////////end of DisplayNeighbourNodes
void Display(int v)
{  int i;
for(i=1;i<=v;i++)
{
cout<<"node "<<i<<" adjacent: ";
DisplayNeighbourNodes(i);
cout<<endl;
}
}
////////////////////////////////////////
//void Display(List x)
//{  ListNode* s;
//  s= x.first;
// while(s!= NULL)
// {
//  cout<<s->data;
//  s=s->link;
// }
// }
//}
///////////////////////////////////////end of Display
ListNode operator = (ListNode* x)
{
ListNode* t;
t->data = x->data;
t->link = x->link ;
}
////////////////////////////////////////////////////end of operator =
List  operator = (List  x)
{ int k=x.count();// felan
List t;
ListNode* s;
t =(x.first)->data;
s = x.first;
for(int i=1; i<k; i++)
{
 s = s->link;
 t.InsertEnd(s->data);
}
return  t;
}
////////////////////////////////////////////end of operator =
List AllNodesList()
{  int v=2;
List AllNodes;
for(int i=1;i<v;i++)
{
AllNodes.InsertEnd(i);
}
return AllNodes;
}
///////////////////////////////////////////end of ggg
//void noneNeighborNodes(int v)
//{
//
//}
ListNode* NeighborNodes(int v)
{
ListNode* t;

 

t = headNodes[v].first;

 

return t ;

}
/////////////////////////////////////////////////
void Didplay(ListNode* s)
{
while(s!=NULL)
{
cout<<s->data;
s=s->link;
}
}
////////////////////////////////////////////
};//end class Graph

 

////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////
int main()
{
int vertex,num,i,v;
List l,s,m;
l.InsertFirst(3);
l.InsertFirst(5);
l.InsertFirst(9);
l.InsertEnd(7);
l.Display();
v=l.count();
cout<<v;

 

cin>>num;

Graph g(num);
g.getANDset(num);
g.Didplay(g.NeighborNodes(3));
getch();
return 0;

}

---

برنامه دوم:

کد:

---

#include "stdafx.h"
#include "LA.h"
#include <iostream>
#include<conio.h>
using namespace std;
class ListNode
{
public:
int      data1;
float    data2;
bool      action;
ListNode* link;
ListNode(int &a,float &b,bool &c,ListNode* p=NULL):data1(a),data2(b),action(c),link(p){}
};
class List :public ListNode
{
protected:
ListNode* newNode(int &a,float &b,bool &c,ListNode* p)
{
 ListNode* q=new ListNode(a,b,c,p);
 return q;
}
public:
ListNode*  first;
List(int element1=0,float element2=0,bool element3=true,ListNode* p=NULL):ListNode(element1,element2,element3,p){}
///////////////////////
void InsertFirst(int element1,float element2=0,bool element3=true)
{
 ListNode* p=newNode(element1,element2,element3,first);
 first=p;
}
//////////////////////
 void deleteNode(int element)
 {
  ListNode* t,* h;
  t = first;
  if(t->data1 == element)
  {
  first = t->link;
  delete t;
  return;
  }
  h=t;
  while(t != NULL)
  {
  if(t->data1 == element)
  {
    h->link = t->link ;
    delete t;
    return;
  }
  h=t;
  t=t->link ;
  }
  cout<<"\n element" <<" "<<element<<" "<<"Not found"<<endl;
 }
 //////////////////////
 int Count()
  {
  ListNode *t;
  int count=0;
    for(t=first;t!=NULL;t=t->link)
    {
    count++;

    }
    return count-1;
 }
//////////////////////
void Display()
 {
    ListNode*  current;
  current = first;

  while(current != NULL)
  {
  cout<<current->data1<<endl;
    current = current->link;
  }
 }
/////////////////////
 ~List()
{
 ListNode* t,* h;
 t = first;
 while(t != NULL)
 {
  h = t;
  t = t->link ;
  delete h;
 }
}
};
/////////////////////////////////////////////////////////////////////////
class Graph:public List
{
protected:
int num,number,temp,ID,NV;
List* headNodes;
public:
Graph(int v=0)
{
 headNodes = new List[v+1];
}
/////////////////
int CountNeighborNodes(int v)
{
 int count=0;
 ListNode* t;
 t = headNodes[v].first;
 for(t; t->link; t = t->link)
 {
  count++;
 }
 return count;
}
void DisplayNeighbourNodes(int v)
{
 ListNode* t;
 t = headNodes[v].first;
 cout<<"[";
 for(t; t->link; t=t->link)
 {cout<< t->data1 <<" ";}
 cout<<"]";
}
/////////////////////
void Display()
{ 
 int i;
 for(i=1;i<=NV;i++)
 {
  cout<<"node "<<i<<" adjacent: ";
  DisplayNeighbourNodes(i);
  cout<<endl;
    }
}
////////////////////
ListNode operator = (ListNode* x)
{
 ListNode* t;
 t->data1  = x->data1;
 t->data2  = x->data2;
 t->action = x->action;
 t->link  = x->link ;

}
///////////////////////////////////////////////////////end of operator =
List  operator = (List  x)
{ int k =x.Count();// felan
 List t((x.first)->data1,(x.first)->data2);
 ListNode* s;
 s = x.first;
 for(int i=1; i<k; i++)
 {
  s = s->link;
  t.InsertFirst(s->data1,s->data2,s->action);
 }
 return  t;
}
 ///////////////////////////////////////////////////////end of operator =
ListNode* NeighborNodes(int v)
{
 ListNode* t;

t = headNodes[v].first;

return t ;
}
 ///////////////////////////////////////////////////////end of NeighborNodes with poniter
void Display(ListNode* s)
{
while(s!=NULL)
{
 cout<<s->data1;
 s=s->link;
}
}
 ///////////////////////////////////////////////////////end of Display with poniter
List AllNodesList()
{ 
List AllNodes;
for(int i=1;i<NV;i++)
{
 AllNodes.InsertFirst(i);
}
return AllNodes;
}
 //////////////////////////////////////////////////////end of AllNodesList
List NoneNeighborNodes(int v)
{
 List NNeighbor;
 ListNode* s;
    NNeighbor = AllNodesList();
 s = NeighborNodes(v);
 for(s;s!=NULL;s=s->link)
 {
  NNeighbor.deleteNode(s->data1);
 }
 return NNeighbor;
}
 ///////////////////////////////////////////////////////end of NoneNeighborNodes
};
class LA:public Graph
{
public:
LA(int ID)
{
 int k;
 ListNode* t;
 t=first;
 List alphaANDp;
    alphaANDp = NoneNeighborNodes(ID);
 k=NoneNeighborNodes(ID).Count();
 for(t;t->link;t=t->link)
  t->data2= 1/k;
}
List operator = (List x)
{
 List t;
 ListNode* s;
 int k = x.Count();
 s = x.first;
 for(int i=1;i<=k;i++)
 {
  t.InsertFirst(s->data1,s->data2,s->action);
  s = s->link;
 }
 return t;
}
 ////////////////////////////////////////////////////end of operator =
void Reward(int ID,int actionselect,float a)
{
 ListNode* t;
 List temp;
 temp = headNodes[ID];
 t = temp.first;
 for(t;t->link;t=t->link)
 {
  if(t->data1 == ID)
  t->data2 = t->data2 + a*(1-t->data2);
  else
  t->data2 = t->data2 * (1-a);
 }
}
 ////////////////////////////////////////////////////end of Reward
void Penalty(int ID,int actionselect,float b)
{
 int r;
 ListNode* t;
 r = NoneNeighborNodes(ID).Count();
 t = headNodes[ID].first;
 for(t;t->link;t=t->link)
 {
  if(t->data1 == ID)
  t->data2 = t->data2 * (1-b);
  else
  t->data2 = b/(1-r) + t->data2 * (1-b);
 }
}
 ////////////////////////////////////////////////////end of Penalty
int GetNextNode(int ID)
{
 float A=0;
 ListNode* t;
 t = headNodes[ID].first;
 while(t!=NULL)
 {
  if((t->data2) >= A && t->action == true)
  {
    A = t->data2;
      ID = t->data1;
      }
 }
 return ID;
}
};

int main()
{

return 0;
}

---

ممکنه یکی جواب منو بده
من کد زیر رو نوشتم اما خطا می ده

کد:

---

int Count()
    {
    List *t;
    t=first
    int count=0;
    for(t;t!=NULL;t=t->link)
    {
      count++;
     
    }

---

اینم خطاشه

کد:

---

'=':cannot convert from ListNode* to List*

---

من هنوز متنظرم ممنون میشم یکی راهنمایی کنه.

نقل قول:

---

نوشته شده توسط MIG [ برای مشاهده لینک ، با نام کاربری خود وارد شوید یا ثبت نام کنید ]

ممکنه یکی جواب منو بده
من کد زیر رو نوشتم اما خطا می ده

کد:

---

int Count()
    {
    List *t;
    t=first
    int count=0;
    for(t;t!=NULL;t=t->link)
    {
      count++;
     
    }

---

اینم خطاشه

کد:

---

'=':cannot convert from ListNode* to List*

---

---

خب برای اینکه دارین یه Node رو تو یه لیست پیوندی قرار می دین .

می خواین کدتون چیکار کنه ؟

می خوام یه لیست رو پیمایش کنه و تعداد اونو برگردونه.

نقل قول:

---

خب برای اینکه دارین یه Node رو تو یه لیست پیوندی قرار می دین .

---

بله حرف شما درسته ! به نظر شما باید در کلاس Listode تابع هایی برای get مقادیر محافظت شده بنویسم اگه اینطوره برای اینکه لینک رو برگردونه چی باید بنویسم و تو کد بالا چطور ازش استفاده کنم؟من کد زیر رو تو کلاس پایه نوشتم درسته به نظرتون؟

کد:

---

class ListNode
{
 protected:
 int      data1;
 float    data2;
 bool      action;
 ListNode* link;
    public:
        int      getdata1()const{return data1};
        float    getdata2()const{return data2};
        bool      getaction()const{return action};
        ListNode* getlink()const{return link};
};

---

سلام
من قبلاً برای یک تاپیک دیگر یک نمونه list نوشتم، یک نگاهی بیاندازید شاید کمکی کند:
تاپیک:
[ برای مشاهده لینک ، با نام کاربری خود وارد شوید یا ثبت نام کنید ]

دانلود:
support.h02.ir/fwlink/?LinkId=1006755647

در مفابل هر خطی که تغییر دادم اسم خودم رو نوشتم. خط هایی هم که اضافه بودند را کامنت کردم. از جمله overload کردن operator =
نیازی نیست که کلاس List از کلاس ListNode مشتق شود (ساختار داده برای نمایش لیست پیوندی)
همچنین نیازی نیست که کلاس Graph از کلاس List مشتق شود (ساختار داده برای نمایش گراف به صورت لیست های مجاورتی )
اما کلاس LA چون سر در نیاوردم که هدفش چیه چیزی نمی تونم بگم.
در تابع اصلی برنامه برای کلاس های لیست و گراف چند خط کد برای تست نمودن عملیات انها نوشتم.

کد:

---

#include<iostream>
#include<conio.h>
usingnamespace std;
class ListNode
{
public:
int data1;
float data2;
bool action;
ListNode* link;
ListNode(int a,float b,bool c,ListNode* p=NULL):data1(a),data2(b),action(c),link(p){} //karim_medusa
};
class List //:public ListNode
{
protected:
ListNode* newNode(int a,float b,bool c,ListNode* p) //karim_medusa
{
ListNode* q=new ListNode(a,b,c,p);
return q;
}
public:
ListNode* first;
List(int element1=0,float element2=0,bool element3=true,ListNode* p=NULL)//:ListNode(element1,element2,element3,p)
{
if(element1==0 && element2==0 && element3==true && p==NULL) //karim_medusa
first=NULL; //karim_medusa
else//karim_medusa
first=newNode(element1,element2,element3,p); //karim_medusa
}
///////////////////////
void InsertFirst(int element1,float element2=0,bool element3=true)
{
ListNode* p=newNode(element1,element2,element3,first);
first=p;
}
//////////////////////
void deleteNode(int element)
{
ListNode* t=NULL,* h=NULL; // karim_medusa
t = first;

if(first==NULL) //karim_medusa
{
cout<<"delete a ction error : The list is empty!"<<endl; //karim_medusa
return; //karim_medusa
}

if(t->data1 == element)
{
first = t->link;
delete t;
return;
}
h=t;
while(t != NULL)
{
if(t->data1 == element)
{
h->link = t->link ;
delete t;
return;
}
h=t;
t=t->link ;
}
cout<<"delete action error : element" <<" "<<element<<" "<<"Not found"<<endl;
}
//////////////////////
int Count()
{
ListNode *t=NULL;
int count=0;
for(t=first;t!=NULL;t=t->link)
count++;
return count; //karim_medusa
}
//////////////////////
void Display()
{
ListNode* current=NULL; //karim_medusa
current = first;
while(current != NULL)
{
cout<<current->data1<<" ";
current = current->link;
}
}
/////////////////////
~List()
{
ListNode* t=NULL,* h=NULL;
t = first;
while(t != NULL)
{
h = t;
t = t->link ;
delete h;
}
}
};
 
class Graph:public List
{
protected:
int num,number,temp,ID,NV;
public:
List* headNodes; //karim_medusa
Graph(int v=0)
{
if(v>0) //karim_medusa
headNodes = new List[v];
else
headNodes =NULL; //karim_medusa
NV=v; //karim_medusa
}
/////////////////
int CountNeighborNodes(int v)
{
int count=0;
//ListNode* t;
//t = headNodes[v].first;

count= headNodes[v].Count(); //karim_medusa

//for(t; t!=NULL; t = t->link)
//count++;
return count;
}
void DisplayNeighbourNodes(int v)
{
//ListNode* t;
//t = headNodes[v].first;
cout<<"[";
headNodes[v].Display(); //karim_medusa
//for(t; t!=NULL; t=t->link)
// cout<< t->data1 <<" ";
cout<<"]";
}
/////////////////////
void Display()
{
int i;
for(i=0;i<NV;i++) //karim_medusa
{
cout<<"node "<<i<<" adjacent: ";
DisplayNeighbourNodes(i);
cout<<endl;
}
}
//////////////////////
//ListNode operator = (ListNode* x)
//{
// ListNode* t;
// t->data1 = x->data1;
// t->data2 = x->data2;
// t->action = x->action;
// t->link = x->link ;
//}
/////////////////////////////////////////////////////////end of operator =
//List operator = (List x)
//{
// int k =x.Count();// felan
// List t((x.first)->data1,(x.first)->data2);
// ListNode* s;
// s = x.first;
// for(int i=1; i<k; i++)
// {
// s = s->link;
// t.InsertFirst(s->data1,s->data2,s->action);
// }
// return t;
//}
///////////////////////////////////////////////////////end of operator =
ListNode* NeighborNodes(int v)
{
ListNode* t;
t = headNodes[v].first;
return t ;
}
///////////////////////////////////////////////////////end of NeighborNodes with poniter
//void Display(ListNode* s)
//{
//while(s!=NULL)
//{
// cout<<s->data1;
// s=s->link;
//}
//}
///////////////////////////////////////////////////////end of Display with poniter
List* AllNodesList() // karim_medusa
{
List* AllNodes=new List(); // karim_medusa
for(int i=0;i<NV;i++) // karim_medusa
AllNodes->InsertFirst(i); // karim_medusa
return AllNodes;
}
//////////////////////////////////////////////////////end of AllNodesList
List* NoneNeighborNodes(int v)
{
List *NNeighbor; //karim_medusa
ListNode* s;
NNeighbor = AllNodesList();
s = NeighborNodes(v);
for(s;s!=NULL;s=s->link)
NNeighbor->deleteNode(s->data1); //karim_medusa

return NNeighbor;
}
///////////////////////////////////////////////////////end of NoneNeighborNodes
};
 
class LA:public Graph
{
public:
LA(int ID)
{
int k;
ListNode* t;
t=first;
List *alphaANDp; //karim_medusa
alphaANDp = NoneNeighborNodes(ID);
k=NoneNeighborNodes(ID)->Count(); //karim_medusa
for(t;t!=NULL;t=t->link) //karim_medusa
t->data2= 1/k;
}
//List operator = (List x)
//{
// List t;
// ListNode* s;
// int k = x.Count();
// s = x.first;
// for(int i=1;i<=k;i++)
// {
// t.InsertFirst(s->data1,s->data2,s->action);
// s = s->link;
// }
// return t;
//}
////////////////////////////////////////////////////end of operator =
void Reward(int ID,int actionselect,float a)
{
ListNode* t;
List temp;
temp = headNodes[ID];
t = temp.first;
for(t;t->link;t=t->link)
{
if(t->data1 == ID)
t->data2 = t->data2 + a*(1-t->data2);
else
t->data2 = t->data2 * (1-a);
}
}
////////////////////////////////////////////////////end of Reward
void Penalty(int ID,int actionselect,float b)
{
int r;
ListNode* t;
r = NoneNeighborNodes(ID)->Count(); //karim_medusa
t = headNodes[ID].first;
for(t;t->link;t=t->link)
{
if(t->data1 == ID)
t->data2 = t->data2 * (1-b);
else
t->data2 = b/(1-r) + t->data2 * (1-b);
}
}
////////////////////////////////////////////////////end of Penalty
int GetNextNode(int ID)
{
float A=0;
ListNode* t;
t = headNodes[ID].first;
while(t!=NULL)
{
if((t->data2) >= A && t->action == true)
{
A = t->data2;
ID = t->data1;
}
}
return ID;
}
};
 
int main()
{
//List class Test
List testList; // first is NULL
List testList2(1,2,false,NULL); // first not NULL
cout <<"testlist.count() : "<<testList.Count()<<endl;
cout <<"testlist2.count() : "<<testList2.Count()<<endl;
testList.deleteNode(2);
testList.InsertFirst(1);
testList.InsertFirst(2);
testList.InsertFirst(3);
cout <<"test list count : "<<testList.Count()<<endl;
cout<<"--------------testList.Display()--------------"<<endl;
testList.Display();
testList.deleteNode(3); // first node
cout<<"--------------testList.Display()--------------"<<endl;
testList.Display();
 
//Graph class Test
int n;
int data;
cout<<"enter number of graph nodes:"<<endl;
cin>>n;
Graph graph(n);
for(int i=0;i<n;i++)
{
cout<<"enter neighbor nodes for node ("<<i<<") <<enter -1 to end>> :"<<endl;
cin>>data;
while(data>=0 && data<n)
{
graph.headNodes[i].InsertFirst(data);
cin>>data;
}
}

cout<<"graph.CountNeighborNodes(0):"<<graph.CountNeighborNodes(0)<<endl;
cout<<"--------------graph.Display()--------------"<<endl;
graph.Display();
cout<<"--------------graph.NoneNeighborNodes(0)->Display()--------------"<<endl;
graph.NoneNeighborNodes(0)->Display();

getch();
return 0;
}


---

نمونه خروجی کد های تست به صورت زیر است :

کد:

---

testlist.count() : 0
testlist2.count() : 1
delete a ction error : The list is empty!
test list count : 3
--------------testList.Display()--------------
3 2 1 --------------testList.Display()--------------
2 1 enter number of graph nodes:
6
enter neighbor nodes for node (0) <<enter -1 to end>> :
1 2 3 -1
enter neighbor nodes for node (1) <<enter -1 to end>> :
0 -1
enter neighbor nodes for node (2) <<enter -1 to end>> :
0 3 5 -1
enter neighbor nodes for node (3) <<enter -1 to end>> :
0 4 5 -1
enter neighbor nodes for node (4) <<enter -1 to end>> :
3 -1
enter neighbor nodes for node (5) <<enter -1 to end>> :
2 3 -1
graph.CountNeighborNodes(0):3
--------------graph.Display()--------------
node 0 adjacent: [3 2 1 ]
node 1 adjacent: [0 ]
node 2 adjacent: [5 3 0 ]
node 3 adjacent: [5 4 0 ]
node 4 adjacent: [3 ]
node 5 adjacent: [3 2 ]
--------------graph.NoneNeighborNodes(0)->Display()--------------
5 4 0

---

کد:

---


class L//:public Graph
{
protected:
float k;
int flag; //karim_medusa
List* alpahANDp;
public:
L(Graph *graph,int ID) //karim_medusa
{
flag=0; //karim_medusa
alpahANDp=NULL; //karim_medusa
ListNode* t=NULL; //karim_medusa
alpahANDp=graph->NoneNeighborNodes(ID); //karim_medusa
t=alpahANDp->first;
k=alpahANDp->Count(); // karim_medusa
for(t;t!=NULL;t=t->link) //karim_medusa
t->data2=1/k;
cout<<"la constractor "<<ID;
}
//----------------------------------------
int selectNextNode(int ID)
{
int NN;
if(flag==0)
{
NN=selectRandomAction(ID);
flag=1;
return NN;
}
else
NN=selectBestAction(ID);
return NN;
}
//------------------------------------------
int selectRandomAction(int ID)
{
ListNode* t=NULL; //karim_medusa
//List *NNB=NULL;
int NewID,k,s;
//NNB=NoneNeighborNodes(ID);
t=alpahANDp->first;
s=alpahANDp->Count(); //karim_medusa
k=GenRandom(s);
while(k!=0 && t!=NULL) //karim_medusa
{
k--;
t=t->link;
}
if(t!=NULL)//karim_medusa
{
NewID=t->data1;
return NewID;//karim_medusa
}
return -1;//karim_medusa
}
//---------------------------------------
int selectBestAction(int ID)
{
int NewID=-1; //karim_medusa
float a=0;
ListNode* t=NULL; //karim_medusa
//List *NNB;
//NNB=NoneNeighborNodes(ID);
t=alpahANDp->first;
while(t!=NULL)
{
if(t->data1>=a && t->action==true)
{
a = t->data2;
NewID = t->data1;
}
t=t->link; //karim_medusa
}
return NewID;
}
//-----------------------------------------
int GenRandom(int lenght)
{
int Rand;
srand(time(0));
return Rand=1+rand()%lenght;
}
//------------------------------------------
void rewardANDpenalty(int ID,int act,int response,float a,float b)
{
int r;
//List *NNB;
ListNode* t=NULL; //karim_medusa
//NNB=NoneNeighborNodes(ID);
t=alpahANDp->first; //karim_medusa
r=alpahANDp->Count(); //karim_medusa
if(response==0)
{
if(t->data1==act)
t->data2 += a*(1-t->data2);
else
t->data2 = t->data2 *(1-a);
}
else
{
if(t->data1==act)
t->data2=t->data2 *(1-b);
else
t->data2=b/(r-1) + t->data2*(1-b);
}
}
};

---

سلام
با توضیحاتی که داده بودید، یک نمونه ساده حاضر کردم، نمیدانم چقدر به چیزی که میخواهید شبیه است.
نمونه دو کلاس با نام CNode و CArrayList دارد.

هر گره میتواند شامل تعداد نامحدودی زیر گره باشد که به صورت پیوندی نگاه داشته میشود.
یعنی هر گره یک پیوند از گره والد و یک پیوند از اولین گره فرزند و یک پیوند از گره بعدی خودش در لیست والد دارد.

متد Insert هم وجود دارد که اگر آرگومان index صفر داده شود در اول گره و اگر هم 0x7fffffff داده شود در آخر گره میتواند Insert کند و در محل خاص و مشخص هم که میتواند Insert کند.

اپراتور [] هم باز تعریف شده تا در هر گره بتوانید با ایندکس به زیر گره هایش دسترسی داشته باشید، همچنان از 0x7fffffff میتوانید برای دسترسی به آخرین گره استفاده کنید.

=====

خود کلاس CNode مجهز به متدی به نام RefreshFarList است که میتواند لیست گره های غیر مجاور برای همه گره ها تولید و refresh کند و در متغییر m_NFar نگاه دارد.
برای ذخیره لیست گره های غیر مجاور از CArrayList به جای لیست پیوندی استفاده است.
(اگر لیست گره های غیر مجاور هم با لیست پیوندی انجام میشد کلاس CArrayList هم نیازی نبود ولی اینطوری به نظرم بهتر و پربازده تر است)

میتوان مجدد گره های جدید را در محل های دلخواه درج (Insert) کرد و در نهایت با اجرای متد RefreshFarList از یکی از گره ها، لیست گره های غیر مجاور همه درخت بازتولید و refresh میشود.

=====

لازم به ذکر است که من تاپیک را درست مطالعه نکردم و فقط با توضیحات خودتان این را نوشتم و نمیدانم چقدر به چیزی که میخواستید نزدیک است.
شاید نیاز نباشد بگویم که کدها با VC++2008 نوشته و تست شده اند، هم کامپایل بدون خطا و هشدار انجام شده و هم تست عملی با 5 گره تو در تو نمونه درست جواب داد.

=====

کد به راحتی قابل تبدیل به C#.Net و VB.Net است و اگر دوستان تمایل داشتند و وقت داشتم میتوانم نمونه دقیقاً مشابه این دو زبان را هم قرار دهم.

موفق باشید.