Từ 1 tới 7 trên tổng số 7 kết quả

Đề tài: DSLK các giải thuật sắp xếp và tìm kiếm

  1. #1
    Ngày gia nhập
    04 2007
    Bài viết
    128

    Mặc định DSLK các giải thuật sắp xếp và tìm kiếm

    C++ Code:
    1. #include<iostream.h>
    2. typedef int KieuDL;
    3. typedef struct Nut
    4. {
    5.     KieuDL duLieu;
    6.     struct Nut *tiep;
    7.     struct Nut(KieuDL duLieu)    {
    8.         this->duLieu=duLieu;
    9.         this->tiep=NULL;
    10.     };
    11. }NUT;
    12.  
    13. /////////////////////////////////////////////////////////////////////////////
    14. class DSLKD{
    15.     private:
    16.         Nut * dau;
    17.         Nut * cuoi;
    18.         void chiaNhoDSLKD(DSLKD *, DSLKD *);
    19.         void tronDS(DSLKD *dS1, DSLKD *dS2);
    20.     public:
    21.         DSLKD();
    22.         ~DSLKD();
    23.  
    24. /***************        cai dat cac hanh vi thuoc DSLKD      ***************/
    25.    
    26.         void themNutOCuoi(KieuDL);
    27.         void themNutPOCuoi(NUT *);
    28.         void themNutODau(KieuDL);
    29.         void themNutSauP(KieuDL,NUT *);
    30.         void themNutPSauQ(NUT *,NUT *);
    31.         KieuDL demSoNut(NUT *);
    32.         Nut *timNut(KieuDL);
    33.         Nut *nutMin();
    34.         void layNutP(NUT *);
    35.         void xoaNutP (NUT *);
    36.         void duyetDSLKD();
    37.         void huyDSLKD();
    38.         bool DSLKDRong();
    39.    
    40.  
    41.         //sap xep = cach thay doi noi dung
    42.         void sxChonTrucTiepND();
    43.        
    44.         //sap xep = cach thay doi dia chi
    45.         void sxChonTrucTiepDC();
    46.        
    47.         //Quick Sort
    48.         void quickSort();
    49.  
    50.         //Merge Sort
    51.         void mergeSort();
    52.    
    53. /***************      cai dat cac hanh vi thuoc tap hop      ***************/
    54.     friend DSLKD *giao(DSLKD *,DSLKD *);
    55.     friend DSLKD *hop(DSLKD *,DSLKD *);
    56.     friend DSLKD *hieu(DSLKD *,DSLKD *);
    57.     friend bool laTapCon(DSLKD *,DSLKD *);
    58.     friend void xuatTHop(DSLKD *,DSLKD *,NUT *,NUT *);
    59. };
    C++ Code:
    1. #include<conio.h>
    2. #include "dslkd.h"
    3. #include<iostream.h>
    4.  
    5. /////////////////////////////////////////
    6. DSLKD::DSLKD(){
    7.     dau=cuoi=NULL;
    8. }
    9.  
    10. /////////////////////////////////////////////////////////////////
    11. void DSLKD::themNutOCuoi(KieuDL duLieu)
    12. {
    13.     //xin vung nho
    14.     NUT *p=new NUT(duLieu);
    15.     if (dau==NULL) dau=cuoi=p;
    16.         else     {
    17.             cuoi->tiep=p;
    18.             cuoi=p;
    19.         }
    20. }
    21.  
    22. /////////////////////////////////////////////////////////////////
    23. void DSLKD::themNutPOCuoi(NUT *p){
    24.     if (dau==NULL) dau=cuoi=p;
    25.         else     {
    26.             p->tiep =NULL;
    27.             cuoi->tiep=p;
    28.             cuoi=p;
    29.         }
    30. }
    31.  
    32. /////////////////////////////////////////////////////////////////
    33. void DSLKD::themNutODau(KieuDL duLieu){
    34.     //xin vung nho
    35.     NUT *p=new NUT(duLieu);
    36.     if (dau==NULL) dau=cuoi=p;
    37.         else     {
    38.             p->tiep=dau;
    39.             dau=p;
    40.         }
    41. }
    42.  
    43. /////////////////////////////////////////////////////////////////
    44. void DSLKD::themNutSauP(KieuDL dLieuQ, NUT *p){
    45.     if (p==cuoi)    themNutOCuoi(dLieuQ);
    46.         else     {
    47.             NUT *q=new NUT(dLieuQ);
    48.             q->tiep=p->tiep;
    49.             p->tiep=q;
    50.         }
    51. }
    52.  
    53. /////////////////////////////////////////////////////////////////
    54. void DSLKD::themNutPSauQ(NUT *p, NUT *q){
    55.     q->tiep=p;
    56.     p->tiep=NULL;
    57.     if (q==this->cuoi)    cuoi =p;
    58. }
    59.  
    60. ///////////////////////////////////////////////////////////////// so nut cua DSLKD
    61. KieuDL DSLKD::demSoNut(NUT *p){
    62.     if(p==NULL)    return 0;
    63.         else     return (1+demSoNut(p->tiep));
    64. }
    65.  
    66. /////////////////////////////////////////////////////////////////
    67. Nut *DSLKD::timNut(KieuDL d)
    68. {
    69.     NUT *p=dau;
    70.     while (p!=NULL)    {
    71.         if (p->duLieu==d)        return p;
    72.             else    p=p->tiep;
    73.     }
    74.     return NULL;
    75. }
    76.  
    77. /////////////////////////////////////////////////////////////////
    78. Nut* DSLKD::nutMin(){
    79.     NUT *min=dau;
    80.     for(NUT *p=dau->tiep; p!=NULL; p=p->tiep)
    81.         if (p->duLieu < min->duLieu )        min=p;
    82.     return min;
    83. }
    84.  
    85. /////////////////////////////////////////////////////////////////
    86. void DSLKD::layNutP (Nut *p) {
    87.     if (DSLKDRong())    cout <<"Khong the lap nut P vi danh sach rong";
    88.     else {
    89.         if (p==dau && p==cuoi)    dau=cuoi=NULL;
    90.         else
    91.             if(p==dau)            dau=dau->tiep;
    92.             else{
    93.                 NUT *truocP=dau;
    94.                 while (truocP->tiep!=p)    truocP=truocP->tiep;
    95.                 truocP->tiep=p->tiep;
    96.                 if (p==cuoi)    cuoi=truocP;
    97.             }
    98.         p->tiep =NULL;
    99.     }
    100. }
    101.  
    102. /////////////////////////////////////////////////////////////////
    103. void DSLKD::xoaNutP (NUT *p){
    104.     if ( DSLKDRong() )    cout <<"Khong the xoa duoc vi DS da rong.";
    105.     else {
    106.         if (p==dau && p==cuoi)    dau=cuoi=NULL;
    107.         else
    108.             if(p==dau)            dau=dau->tiep;
    109.             else{
    110.                 NUT *truocP=dau;
    111.                 while (truocP->tiep!=p)    truocP=truocP->tiep;
    112.                 truocP->tiep=p->tiep;
    113.                 if (p==cuoi)    cuoi=truocP;
    114.                 }
    115.         delete p;
    116.     }
    117. }
    118.  
    119. /////////////////////////////////////////////////////////////////
    120. void DSLKD::duyetDSLKD() {
    121.     cout<<"Cac nut cua DS lien ket: "<<endl;
    122.     NUT *p=this->dau;
    123.     while (p!=NULL)    {
    124.         cout<<p->duLieu<<" -> ";
    125.         p=p->tiep;
    126.     }
    127.     cout<<"NULL"<<endl<<endl;
    128. }
    129.  
    130. /////////////////////////////////////////////////////////////////
    131. void DSLKD::huyDSLKD(){
    132.     NUT *p;
    133.     while (dau!=NULL)    {
    134.         p=dau;
    135.         dau=dau->tiep;
    136.         delete p;
    137.     }
    138.     dau=cuoi=NULL;
    139. }
    140.  
    141. /////////////////////////////////////////////////////////////////
    142. DSLKD::~DSLKD(){
    143.     huyDSLKD();
    144. }
    145.  
    146. /////////////////////////////////////////////////////////////////
    147. bool DSLKD::DSLKDRong(){
    148.     return (dau==NULL ? true:false);
    149. }
    150.  
    151. /////////////////////////////////////////////////////////////////
    152. void DSLKD::sxChonTrucTiepND(){
    153.     NUT *postMin;
    154.     KieuDL temp;
    155.     for(NUT *p=dau;p!=cuoi;p=p->tiep)    {
    156.         postMin=p;
    157.         for(NUT *q=p->tiep;q!=NULL;q=q->tiep)
    158.             if(q->duLieu < postMin->duLieu)        postMin=q;
    159.         temp=p->duLieu;
    160.         p->duLieu=postMin->duLieu;
    161.         postMin->duLieu=temp;
    162.     }
    163. }
    164.  
    165. /////////////////////////////////////////////////////////////////
    166. void DSLKD::sxChonTrucTiepDC(){
    167.     NUT *min;
    168.     DSLKD *dSMoi=new DSLKD();
    169.     while (this->dau!=NULL)    {
    170.         min=this->nutMin();
    171.         this->layNutP(min);
    172.         dSMoi->themNutPOCuoi(min);
    173.     }
    174.     this->dau=dSMoi->dau;
    175.     this->cuoi=dSMoi->cuoi;
    176. }
    177.  
    178.  
    179. /////////////////////////////////////////////////////////////////
    180. void DSLKD::quickSort (){
    181.     if (this->dau == this->cuoi) return;
    182.     DSLKD *dS1=new DSLKD();
    183.     DSLKD *dS2=new DSLKD();
    184.     NUT *x=this->dau;
    185.     NUT *p;
    186.     this->layNutP (x);
    187.     while(this->dau !=NULL)    {
    188.         p=this->dau ;
    189.         this->layNutP (p);
    190.         if (p->duLieu < x->duLieu)        dS1->themNutPOCuoi(p);
    191.          else dS2->themNutPOCuoi(p);
    192.     }
    193.     dS1->quickSort();
    194.     dS2->quickSort();
    195.     //noi 2 ds
    196.     if (dS1->dau == NULL)        this->dau=x;
    197.     else    {
    198.         this->dau=dS1->dau;
    199.         this->cuoi=dS1->cuoi;
    200.         this->cuoi->tiep=x;
    201.     }
    202.     x->tiep = dS2->dau;
    203.     if(dS2->dau == NULL)        this->cuoi=x;
    204.      else    this->cuoi=dS2->cuoi;
    205. }
    206.  
    207. ///////////////////////////////////////////////////////// chia thanh 2 danh sach
    208. void DSLKD::chiaNhoDSLKD(DSLKD *dS1, DSLKD *dS2) {
    209.     NUT *p;
    210.     do {
    211.         p=this->dau;
    212.         this->dau=p->tiep ;
    213.         p->tiep =NULL;
    214.         dS1->themNutPOCuoi (p);
    215.     }
    216.     while (this->dau !=NULL  &&  p->duLieu < this->dau->duLieu );
    217.     if (this->dau !=NULL) this->chiaNhoDSLKD(dS2, dS1);
    218. }
    219.  
    220. void DSLKD::tronDS(DSLKD *dS1, DSLKD *dS2) {
    221.     //tron 2 danh sach
    222.     NUT *p;
    223.     while (dS1->dau !=NULL  && dS2->dau !=NULL ){
    224.         if  (dS1->dau->duLieu < dS2->dau->duLieu ){
    225.             p=dS1->dau ;
    226.             dS1->layNutP (p);
    227.         }
    228.             else{
    229.                 p=dS2->dau ;
    230.                 dS2->layNutP (p);
    231.             }
    232.         this->themNutPOCuoi (p);
    233.     }
    234.  
    235.     while (dS1->dau != NULL) { //ds1 khong rong
    236.         p= dS1->dau ;
    237.         dS1->layNutP(p);
    238.         this->themNutPOCuoi (p);
    239.     }
    240.  
    241.     while (dS2->dau != NULL) { //ds2 khong rong
    242.         p= dS2->dau ;
    243.         dS2->layNutP(p);
    244.         this->themNutPOCuoi (p);
    245.     }
    246. }    
    247.    
    248. //////////////////////////////////////////////////////////
    249. void DSLKD::mergeSort (){
    250.     if (this->dau==this->cuoi)
    251.         return;
    252.     DSLKD *dS1=new DSLKD();
    253.     DSLKD *dS2=new DSLKD();
    254.     chiaNhoDSLKD (dS1, dS2);
    255.  
    256.     if (dS1->dau != NULL  && dS2->dau != NULL) { //co 1 day da sap xep
    257.         dS1->mergeSort();
    258.         dS2->mergeSort ();
    259.     }
    260.     this->tronDS(dS1, dS2);
    261.  
    262. }
    263.  
    264. ////////////////////////////////////////////////////////
    265. DSLKD *giao(DSLKD *s,DSLKD *t){
    266.     NUT *p = s->dau;
    267.     DSLKD *kQ=new DSLKD();
    268.     while(p!=NULL)    {
    269.         if (t->timNut(p->duLieu)!=NULL)    kQ->themNutOCuoi(p->duLieu);
    270.         p=p->tiep;
    271.     }
    272.     return kQ;
    273. }
    274. ////////////////////////////////////////////////////////
    275. DSLKD *hop(DSLKD *s,DSLKD *t){
    276.     NUT *p=s->dau;
    277.     DSLKD *kQ=new DSLKD();
    278.     while (p!=NULL)    {
    279.         kQ->themNutOCuoi(p->duLieu);
    280.         p=p->tiep;
    281.     }
    282.     p=t->dau;
    283.     while(p!=NULL)    {
    284.         if (s->timNut(p->duLieu)==NULL)    kQ->themNutOCuoi(p->duLieu);
    285.         p=p->tiep;
    286.     }
    287.     return kQ;
    288. }
    289. //////////////////////////////////////////////////////////
    290. DSLKD *hieu(DSLKD *s,DSLKD *t){
    291.     NUT *p=s->dau;
    292.     DSLKD *kQ=new DSLKD();
    293.     while (p!=NULL)    {
    294.         if (t->timNut(p->duLieu)==NULL)            kQ->themNutOCuoi(p->duLieu);
    295.         p=p->tiep;
    296.     }
    297.     return kQ;
    298. }
    299. //////////////////////////////////////////////////////////
    300. bool laTapCon(DSLKD *s,DSLKD *t){
    301.     NUT *p=s->dau;
    302.     while (p!=NULL)    {
    303.         if (t->timNut(p->duLieu)!=NULL)    p=p->tiep;
    304.         else return 0;
    305.     }
    306.     return 1;
    307. }
    308. //////////////////////////////////////////////////////////
    309. void xuatTHop (DSLKD *tHop1,DSLKD *tHop2,Nut *p,Nut *q){
    310.     while(p!=NULL || q!=NULL)    {
    311.         if ( p==NULL  &&  tHop1->demSoNut(p)  <  tHop2->demSoNut(q) )    cout<<" "<<"\t\t"<<q->duLieu<<endl;
    312.             else
    313.                 if (q==NULL && tHop1->demSoNut(p)>tHop2->demSoNut(q))    cout<<p->duLieu<<endl;
    314.                     else cout<<p->duLieu<<"\t\t"<<q->duLieu<<endl;
    315.         if(p!=NULL)        p=p->tiep;
    316.         if(q!=NULL)        q=q->tiep;
    317.     }
    318. }
    C++ Code:
    1. #include"dslkd.h"
    2. #include<iostream.h>
    3. #include<conio.h>
    4. #include<ctime>
    5. #include<cstdlib>
    6. #include<fstream>
    7. using namespace std;
    8. #include<string.h>
    9.  
    10. void main()
    11. {
    12.     int i,key;
    13.     int n;
    14.     KieuDL duLieuNhap;
    15.     DSLKD *ds=new DSLKD();
    16.  
    17. begin:
    18.     //cout<<"-----------------DANH SACH LIEN KET DON-----------------"<<endl;
    19. //Nhap danh sach
    20.     cout<<"Nhap du lieu cho DSLKD"<<endl;
    21.     cout<<"So NUT cua DSLKD:    n=";    cin>>n;        
    22.     cout<<endl;
    23.    
    24.     //cout<<"Moi ban chon cach nhap du lieu."<<endl;
    25.     cout<<"1.Tu nhap DSLKD"<<endl;
    26.     cout<<"2.Tao DSLKD ngau nhien"<<endl<<endl;
    27.     cout<<"Ban cach nhap ban muon chon:  ";
    28.     cin>>key;        cout<<endl;
    29.  
    30.     if (key==1){
    31.         cout<<"Nhap NUT"<<endl;
    32.         for (i=0;i<n;i++)    {
    33.             cout<<"Nut"<<i<<": "; cin>>duLieuNhap;
    34.             ds->themNutOCuoi(duLieuNhap);
    35.         }
    36.     }
    37.     else
    38.         if (key==2)    {    
    39.             srand(time(0));
    40.             for(i=0;i<n;i++)    ds->themNutOCuoi(rand()%n+1);
    41.         }
    42.             /*else {
    43.                 cout<<"khong hieu yeu cau"<<endl;
    44.                 key=getch();
    45.                 return;
    46.             }*/
    47.    
    48.  
    49.  
    50.     cout<<"Tao xong danh sach.";
    51.     do
    52.     {
    53.         cout<<"Moi ban chon tac vu thuc hien tren DSLKD:"<<endl;
    54.         cout<<"1.In DSLKD ra man hinh"<<endl;
    55.         cout<<"2.Sap xep DSLKD bang chonTrucTiepND"<<endl;
    56.         cout<<"3.Sap xep DSLKD bang chonTrucTiepDC"<<endl;
    57.         cout<<"4.Sap xep DSLKD bang quickSort"<<endl;
    58.         cout<<"5.Sap xep DSLKD bang mergeSort"<<endl;
    59.         cout<<"6.Khoi tao lai DSLKD"<<endl;
    60.         cout<<"7.Thoat khoi chuong trinh."<<endl<<endl;
    61.         cout<<"Ban chon: "; cin>>key;
    62.                        
    63.         switch (key)        {
    64.             case 1:    
    65.                 ds->duyetDSLKD();
    66.                 break;
    67.             case 2:
    68.                 ds->sxChonTrucTiepND();
    69.                 cout<<"DSLKD sau khi duoc sap xep:"<<endl;
    70.                 ds->duyetDSLKD();
    71.                 break;
    72.             case 3:                
    73.                 ds->sxChonTrucTiepDC();
    74.                 cout<<"DSLKD sau khi duoc sap xep:"<<endl;
    75.                 ds->duyetDSLKD();
    76.                 break;
    77.             case 4:
    78.                 ds->quickSort();
    79.                 cout<<"DSLKD sau khi duoc sap xep:"<<endl;
    80.                 ds->duyetDSLKD();
    81.                 break;
    82.             case 5:
    83.                 ds->mergeSort ();
    84.                 cout<<"DSLKD sau khi duoc sap xep:"<<endl;
    85.                 ds->duyetDSLKD ();
    86.                 break;
    87.             case 6:
    88.                 ds->huyDSLKD ();
    89.                 goto begin;
    90.             case 7:
    91.                 cout<<"Ban da yeu cau dong chuong trinh."<<endl;
    92.                 getch();
    93.                 return;
    94.         }
    95.         cout<<"Nhan 1 fim bat ki de tiep tuc.."<<endl<<endl;
    96.     }
    97.     while (key<7 && key>0);
    98. }
    bổ sung phần vừa chèn vừa sắp xếp nè, chắc chưa phải là tối ưu đâu. Cứ đóng góp thêm nhá!
    C++ Code:
    1. void DSLKD::chenSX(KieuDL duLieu)
    2. {
    3.     NUT *p=this->dau;
    4.     NUT *q=new NUT(duLieu);
    5.     NUT *truocP;
    6.     if(this->dau!=NULL)
    7.     {
    8.         if(duLieu<this->dau->duLieu)
    9.             this->themNutODau(duLieu);
    10.         else
    11.         {
    12.             while(p!=NULL && p->duLieu<=duLieu)
    13.                 p=p->tiep;
    14.             truocP=this->dau;
    15.             while (truocP->tiep!=p)    truocP=truocP->tiep;
    16.                 truocP->tiep=q;
    17.             q->tiep=p;
    18.  
    19.         }
    20.     }
    21.     else
    22.         this->themNutOCuoi(duLieu);
    23. }
    Đã được chỉnh sửa lần cuối bởi soda_chanhmuoi : 18-05-2007 lúc 10:57 AM.

  2. #2
    Ngày gia nhập
    04 2007
    Bài viết
    128

    DSLK vòng (đơn)
    C++ Code:
    1. #include<iostream.h>
    2. typedef int KieuDL;
    3. typedef struct Nut
    4. {
    5.     KieuDL duLieu;
    6.     struct Nut *tiep;
    7.     struct Nut(KieuDL duLieu)  
    8.     {
    9.         this->duLieu=duLieu;
    10.         this->tiep=NULL;
    11.     };
    12. }NUT;
    13.  
    14.  
    15. class DSLKV
    16. {
    17.     private:
    18.         Nut * dau;
    19.         Nut * cuoi;
    20.     public:
    21.         DSLKV();
    22.         ~DSLKV();
    23.  
    24.    
    25.         void themNutOCuoi(KieuDL);
    26.         void themNutPOCuoi(NUT *);
    27.         void themNutODau(KieuDL);
    28.         void themNutSauP(KieuDL,NUT *);
    29.         void themNutPSauQ(NUT *,NUT *);
    30.         KieuDL demSoNut(NUT *);
    31.         Nut *timNut(KieuDL);
    32.         Nut *nutMin();
    33.         void layNutP(NUT *);
    34.         void xoaNutP(NUT *);
    35.         void duyetDSLKV();
    36.         void huyDSLKV();
    37.         bool DSLKVRong();
    38.         void vong(int n);
    39.        
    40.  
    41. };
    C++ Code:
    1. #include<conio.h>
    2. #include "dslkv.h"
    3. #include<iostream.h>
    4.  
    5.  
    6. DSLKV::DSLKV()
    7. {
    8.     dau=cuoi=NULL;
    9. }
    10.  
    11. void DSLKV::themNutOCuoi(KieuDL duLieu)
    12. {
    13.     NUT *p=new NUT(duLieu);
    14.     if (dau==NULL)
    15.     {
    16.         dau=cuoi=p;
    17.         cuoi->tiep=dau;
    18.     }
    19.         else    
    20.         {
    21.             p->tiep =dau;
    22.             cuoi->tiep=p;
    23.             cuoi=p;
    24.         }
    25. }
    26.  
    27.  
    28. void DSLKV::themNutPOCuoi(NUT *p)
    29. {
    30.     if (dau==NULL)
    31.     {
    32.         dau=cuoi=p;
    33.         cuoi->tiep=dau;
    34.     }
    35.  
    36.     else    
    37.     {
    38.         p->tiep =dau;
    39.         cuoi->tiep=p;
    40.         cuoi=p;
    41.     }
    42. }
    43. void DSLKV::themNutODau(KieuDL duLieu)
    44. {
    45.    
    46.     NUT *p=new NUT(duLieu);
    47.     if (dau==NULL)
    48.     {
    49.         dau=cuoi=p;
    50.         cuoi->tiep=dau;
    51.     }
    52.         else    
    53.         {
    54.             p->tiep=dau;
    55.             cuoi->tiep=p;
    56.             dau=p;
    57.         }
    58. }
    59.  
    60.  
    61. void DSLKV::themNutSauP(KieuDL dLieuQ, NUT *p)
    62. {
    63.     if (p==cuoi)    themNutOCuoi(dLieuQ);
    64.         else    
    65.         {
    66.             NUT *q=new NUT(dLieuQ);
    67.             q->tiep=p->tiep;
    68.             p->tiep=q;
    69.         }
    70. }
    71.  
    72.  
    73. void DSLKV::themNutPSauQ(NUT *p, NUT *q)
    74. {
    75.     q->tiep=p;
    76.     p->tiep=NULL;
    77.     if (q==this->cuoi)  cuoi =p;
    78. }
    79.  
    80.  
    81. KieuDL DSLKV::demSoNut(NUT *p)
    82. {
    83.     if(p==NULL) return 0;
    84.         else    return (1+demSoNut(p->tiep));
    85. }
    86.  
    87. /////////////////////////////////////////////////////////////////
    88. Nut *DSLKV::timNut(KieuDL d)
    89. {
    90.     NUT *p=dau;
    91.     while (p!=NULL) {
    92.         if (p->duLieu==d)       return p;
    93.             else    p=p->tiep;
    94.     }
    95.     return NULL;
    96. }
    97.  
    98. /////////////////////////////////////////////////////////////////
    99. Nut *DSLKV::nutMin(){
    100.     NUT *min=dau;
    101.     for(NUT *p=dau->tiep; p!=NULL; p=p->tiep)
    102.         if (p->duLieu < min->duLieu )       min=p;
    103.     return min;
    104. }
    105.  
    106. /////////////////////////////////////////////////////////////////
    107. void DSLKV::layNutP (Nut *p) {
    108.     if (DSLKVRong())    cout <<"Khong the lap nut P vi danh sach rong";
    109.     else
    110.     {
    111.         if (p==dau && p==cuoi)  dau=cuoi=NULL;
    112.         else
    113.             if(p==dau)          dau=dau->tiep;
    114.             else
    115.             {
    116.                 NUT *truocP=dau;
    117.                 while (truocP->tiep!=p) truocP=truocP->tiep;
    118.                 truocP->tiep=p->tiep;
    119.                 if (p==cuoi)    cuoi=truocP;
    120.             }
    121.         p->tiep =NULL;
    122.     }
    123. }
    124.  
    125. /////////////////////////////////////////////////////////////////
    126. void DSLKV::xoaNutP (NUT *p){
    127.     if ( DSLKVRong() )  cout <<"Khong the xoa duoc vi DS da rong.";
    128.     else {
    129.         if (p==dau && p==cuoi)  dau=cuoi=NULL;
    130.         else
    131.             if(p==dau)
    132.             {
    133.                 dau=dau->tiep;
    134.                 cuoi->tiep=dau;
    135.             }
    136.             else
    137.             {
    138.                 NUT *truocP=dau;
    139.                 while (truocP->tiep!=p)
    140.                     truocP=truocP->tiep;
    141.                 truocP->tiep=p->tiep;
    142.                 if (p==cuoi)
    143.                 {
    144.                     truocP->tiep=dau;
    145.                     cuoi=truocP;
    146.                 }
    147.  
    148.             }
    149.         delete p;
    150.     }
    151. }
    152. /////////////////////////////////////////////////////////////////
    153. void DSLKV::duyetDSLKV()
    154. {
    155.     cout<<"Cac nut cua DS lien ket: "<<endl;
    156.     NUT *p=this->dau;
    157.     while (p!=this->cuoi)  
    158.     {
    159.         cout<<p->duLieu<<" -> ";
    160.         p=p->tiep;
    161.     }
    162.     cout<<cuoi->duLieu<<" -> "<<endl;
    163. }
    164.  
    165.  
    166. void DSLKV::huyDSLKV()
    167. {
    168.     NUT *p;
    169.     while (dau!=NULL)  
    170.     {
    171.         p=dau;
    172.         dau=dau->tiep;
    173.         delete p;
    174.     }
    175.     dau=cuoi=NULL;
    176. }
    177.  
    178.  
    179. DSLKV::~DSLKV()
    180. {
    181.     huyDSLKV();
    182. }
    183.  
    184.  
    185. bool DSLKV::DSLKVRong()
    186. {
    187.     return (dau==NULL ? true:false);
    188. }
    189.  
    190. void DSLKV::vong(int n)
    191. {
    192.     NUT *p=this->dau;
    193.     NUT *q=this->dau;
    194.     int dem;
    195.     while(this->dau!=this->cuoi)
    196.     {
    197.         dem=1;
    198.         p=q;
    199.         do
    200.         {
    201.             p=p->tiep;
    202.             dem++;
    203.         }
    204.         while(dem<n && this->dau!=this->cuoi);
    205.         q=p->tiep;
    206.         this->xoaNutP(p);
    207.    
    208.         this->duyetDSLKV();
    209.     }
    210.     cout<<"Phan tu con lai:"<<this->dau->duLieu<<endl;
    211. }
    C++ Code:
    1. #include"dslkv.h"
    2. #include<iostream.h>
    3. #include<conio.h>
    4. #include<ctime>
    5. #include<cstdlib>
    6. #include<fstream>
    7. using namespace std;
    8. #include<string.h>
    9.  
    10. void main()
    11. {
    12.     int i,key;
    13.     int n,t;
    14.     KieuDL duLieuNhap;
    15.     DSLKV *ds=new DSLKV();
    16.  
    17.     cout<<"Nhap du lieu cho DSLKV"<<endl;
    18.     cout<<"So NUT cua DSLKV:    n=";    cin>>n;    
    19.     cout<<endl;
    20.    
    21.     cout<<"Moi ban chon cach nhap du lieu."<<endl;
    22.     cout<<"1.Nhap tay DSLKD"<<endl;
    23.     cout<<"2.Nhap ngau nhien DSLKD"<<endl<<endl;
    24.     cout<<"Ban cach nhap ban muon chon:  ";
    25.     cin>>key;       cout<<endl;
    26.  
    27.     if (key==1)
    28.     {
    29.         cout<<"Nhap du lieu cho tung NUT"<<endl;
    30.         for (i=1;i<=n;i++) 
    31.         {
    32.             cout<<"Nut "<<i<<": "; cin>>duLieuNhap;
    33.             ds->themNutOCuoi(duLieuNhap);
    34.         }
    35.     }
    36.     else
    37.         if (key==2)
    38.         {  
    39.             srand(time(0));
    40.             for(i=0;i<n;i++)    ds->themNutOCuoi(rand()%n+1);
    41.         }
    42.             else
    43.             {
    44.                 cout<<"khong hieu yeu cau"<<endl;
    45.                 key=getch();
    46.                 return;
    47.             }
    48.     cout<<"Da tao xong danh sach.";
    49.    
    50.                 ds->duyetDSLKV();
    51.                 cout<<"nhap n";
    52.                 cin>>t;
    53.                 ds->vong(t);
    54.                 getch();
    55.                
    56. }
    Đã được chỉnh sửa lần cuối bởi soda_chanhmuoi : 18-05-2007 lúc 08:08 AM.

  3. #3
    Ngày gia nhập
    04 2007
    Bài viết
    128

    Xử lý số nguyên lớn bằng DSLK kép
    C++ Code:
    1. #include <time.h>
    2. #include <stdlib.h>
    3. typedef long KieuDL;
    4. typedef struct NUT
    5. {
    6.     struct NUT(long dl)
    7.     {
    8.         this->duLieu=dl;
    9.         this->tiep=NULL;
    10.         this->truoc=NULL;
    11.     }
    12.     KieuDL duLieu;
    13.     struct NUT* tiep;
    14.     struct NUT* truoc;
    15. }NUT;
    16. class DSLKK
    17. {
    18.     private:
    19.         int sign;
    20.         NUT *dau;
    21.         NUT *cuoi;
    22.     public:
    23.        
    24.         DSLKK();
    25.         ~DSLKK();
    26.         void themNutOCuoi(KieuDL);
    27.         void themNutPOCuoi(NUT *);
    28.         void themNutODau(KieuDL);
    29.         void themNutPODau(NUT *);
    30.         void themNutPTruocQ(NUT *,NUT *);
    31.         void themNutPSauQ(NUT *,NUT *);
    32.         KieuDL demNut(NUT *);
    33.         NUT *timNut(KieuDL);
    34.         NUT *nutMin();
    35.         void layNutP(NUT *);
    36.         void xoaNutP (NUT *);
    37.         void duyetDSLKKthuan();
    38.         void duyetDSLKKnghich();
    39.         void huyDSLKK();
    40.         bool DSLKKRong();
    41.         void quickSort();
    42.         void chuyen(char st[]);
    43.         void xuat();
    44. friend DSLKK* tongDuong(DSLKK *,DSLKK *);
    45. friend DSLKK* hieuDuong(DSLKK *,DSLKK *);
    46. friend DSLKK* tich_tam(DSLKK*,NUT *);
    47. friend DSLKK* tong(DSLKK *,DSLKK *,int );
    48. friend DSLKK* hieu(DSLKK *,DSLKK *,int);
    49. friend DSLKK* tich(DSLKK *,DSLKK *,int);
    50.  
    51. };
    52. int so_sanh_tam(char st1[],char st2[]);
    53. int so_sanh(char st1[],char st2[]);
    C++ Code:
    1. #include<conio.h>
    2. #include<stdio.h>
    3. #include<iostream.h>
    4. #include<stdlib.h>
    5. #include<string.h>
    6. #include"xlsn.h"
    7. /////////////////////////////////////////////////////////////////////////////////////
    8. DSLKK::DSLKK()
    9. {   dau=cuoi=NULL;}
    10. /////////////////////////////////////////////////////////////////////////////////////
    11. void DSLKK::huyDSLKK()
    12. {
    13.     NUT *p;
    14.     while (dau!=NULL)
    15.     {
    16.         p=dau;
    17.         dau=dau->tiep;
    18.         dau->truoc=NULL;
    19.         delete p;
    20.     }
    21.     cuoi=dau=NULL;
    22. }
    23. /////////////////////////////////////////////////////////////////////////////////////
    24. DSLKK::~DSLKK()
    25. { huyDSLKK();}
    26. /////////////////////////////////////////////////////////////////////////////////////
    27. bool DSLKK::DSLKKRong()
    28. {   return (dau==NULL ? true:false);  }
    29. /////////////////////////////////////////////////////////////////////////////////////
    30.  
    31. void DSLKK::duyetDSLKKthuan()
    32. {
    33.     NUT *p=dau;
    34.     while(p!=NULL)
    35.     {
    36.         cout<<p->duLieu<<"  ";
    37.         p=p->tiep;
    38.     }
    39. }
    40. /////////////////////////////////////////////////////////////////////////////////////
    41. void DSLKK::duyetDSLKKnghich()
    42. {
    43.     NUT *p=cuoi;
    44.     while(p!=NULL)
    45.     {
    46.         cout<<p->duLieu<<"  ";
    47.         p=p->truoc;
    48.     }
    49. }
    50. /////////////////////////////////////////////////////////////////////////////////////  
    51. void DSLKK::themNutOCuoi(KieuDL duLieu)
    52. {
    53.     NUT *p=new NUT(duLieu);
    54.     if(DSLKKRong())
    55.         dau=cuoi=p;
    56.     else
    57.     {
    58.         cuoi->tiep=p;
    59.         p->truoc=cuoi;
    60.         cuoi=p;
    61.     }
    62. }
    63. /////////////////////////////////////////////////////////////////////////////////////
    64. void DSLKK::themNutODau(KieuDL duLieu)
    65. {
    66.     NUT *p=new NUT(duLieu);
    67.     if(DSLKKRong())
    68.         dau=cuoi=p;
    69.     else
    70.     {
    71.         p->tiep=dau;
    72.         dau->truoc=p;
    73.         dau=p;
    74.     }
    75. }
    76. /////////////////////////////////////////////////////////////////////////////////////
    77. //chuyen tu mang kieu char vao DSLKK
    78. void DSLKK::chuyen(char st[])
    79. {  
    80.     int i;
    81.     if(st[0]=='-')
    82.     {
    83.         this->sign=-1;
    84.         i=1;
    85.     }
    86.     else
    87.     {
    88.         this->sign=1;
    89.         i=0;
    90.     }  
    91.     while(st[i]!='\0')
    92.     {
    93.         char x=st[i];
    94.         KieuDL tam=atoi(&x);
    95.         this->themNutOCuoi(tam);
    96.         i++;
    97.     }
    98. }
    99. /////////////////////////////////////////////////////////////////////////////////////
    100. void DSLKK::xuat()
    101. {
    102.     if(this->sign==-1)
    103.         cout<<"-";
    104.     NUT *p;
    105.     NUT *q=this->dau;
    106.     while(q!=NULL&&q->duLieu==0)
    107.         q=q->tiep;
    108.     if(q==NULL)
    109.         cout<<0;
    110.     for(p=q;p!=NULL;p=p->tiep)
    111.         cout<<p->duLieu;
    112.     cout<<endl;
    113. }
    114. /////////////////////////////////////////////////////////////////////////////////////
    115. DSLKK * tongDuong(DSLKK *l1,DSLKK *l2)
    116. {
    117.     NUT *p=l1->cuoi;
    118.     NUT *q=l2->cuoi;
    119.     DSLKK *l;
    120.     l=new DSLKK();
    121.     int s1,s2,sonho=0;
    122.     while(p!=NULL && q!=NULL)
    123.     {
    124.         s1=p->duLieu + q->duLieu+ sonho;
    125.         s2=s1%10;
    126.         if(p==l1->dau && q==l2->dau)
    127.         {
    128.             l->themNutODau(s1);
    129.         }
    130.         else
    131.         {
    132.             l->themNutODau(s2);
    133.         }
    134.         sonho=s1/10;
    135.         p=p->truoc;
    136.         q=q->truoc;
    137.     }
    138.     while(p!=NULL)
    139.     {
    140.         s1=p->duLieu+sonho;
    141.         s2=s1%10;
    142.         if(p==l1->dau)
    143.         {
    144.             l->themNutODau(s1);
    145.         }
    146.         else
    147.         {
    148.             l->themNutODau(s2);
    149.         }
    150.         sonho=s1/10;
    151.         p=p->truoc;
    152.     }
    153.     while(q!=NULL)
    154.     {
    155.         s1=q->duLieu+sonho;
    156.         s2=s1%10;
    157.         if(q==l2->dau)
    158.         {
    159.             l->themNutODau(s1);
    160.         }
    161.         else
    162.         {
    163.             l->themNutODau(s2);
    164.         }
    165.         sonho=s1/10;
    166.         q=q->truoc;
    167.     }
    168.     l->sign=1;
    169.     return l;
    170. }
    171. /////////////////////////////////////////////////////////////////////////////////////
    172.  
    173. DSLKK * hieuDuong(DSLKK *l1,DSLKK *l2)
    174. {
    175.     DSLKK *l=new DSLKK();
    176.     int g,h=0;
    177.     NUT *p=l1->cuoi;
    178.     NUT *q=l2->cuoi;
    179.     while(p!=NULL && q!=NULL)
    180.     {
    181.         g=p->duLieu - h- q->duLieu;
    182.         if(g<0)
    183.         {
    184.             l->themNutODau(10+g);
    185.             h=1;
    186.         }
    187.         else
    188.         {
    189.             l->themNutODau(g);
    190.             h=0;
    191.         }
    192.         p=p->truoc;
    193.         q=q->truoc;
    194.     }
    195.     while(p!=NULL)
    196.     {
    197.         g=p->duLieu-h;
    198.         if(g<0)
    199.         {
    200.             l->themNutODau(10+g);
    201.             h=1;
    202.         }
    203.         else
    204.         {
    205.             l->themNutODau(g);
    206.             h=0;
    207.         }
    208.         p=p->truoc;
    209.     }
    210.     return l;
    211. }
    212. /////////////////////////////////////////////////////////////////////////////////////
    213. DSLKK * tong(DSLKK *l1,DSLKK *l2,int SST)
    214. {
    215.     DSLKK *l=new DSLKK();
    216.     if(l1->sign==-1 &&l2->sign==-1)
    217.     {
    218.         l=tongDuong(l1,l2);
    219.         l->sign=-1;
    220.     }
    221.     if(l1->sign==1 && l2->sign==1)
    222.     {
    223.         l=tongDuong(l1,l2);
    224.         l->sign=1;
    225.     }
    226.     if(l1->sign==1 && l2->sign==-1)
    227.     {
    228.         if(SST==1)
    229.         {
    230.             l=hieuDuong(l1,l2);
    231.             l->sign=1;
    232.         }
    233.         else
    234.             if(SST==-1)
    235.             {  
    236.                 l=hieuDuong(l2,l1);
    237.                 l->sign=-1;
    238.             }
    239.             else
    240.                 if(SST==0)
    241.                 {          
    242.                     l->sign=1;
    243.                     l=hieuDuong(l1,l2);
    244.                 }
    245.     }
    246.     if(l1->sign==-1 && l2->sign==1)
    247.     {
    248.         if(SST==1)
    249.         {
    250.             l=hieuDuong(l1,l2);
    251.             l->sign=-1;
    252.         }
    253.         else
    254.         {                      
    255.             l=hieuDuong(l2,l1);
    256.             l->sign=1;
    257.         }
    258.     }
    259.     return l;
    260. }
    261. /////////////////////////////////////////////////////////////////////////////////////
    262. DSLKK * hieu(DSLKK *l1,DSLKK *l2,int SST)
    263. {  
    264.     DSLKK *l=new DSLKK();
    265.     DSLKK *l3=new DSLKK();
    266.     NUT *p;
    267.     int sign;
    268.     sign=l2->sign;
    269.     for(p=l2->cuoi;p!=NULL;p=p->truoc)
    270.         l3->themNutODau(p->duLieu);
    271.     l3->sign=-sign;
    272.     l=tong(l1,l3,SST);
    273.     return l;
    274. }
    275. /////////////////////////////////////////////////////////////////////////////////////
    276. DSLKK * tich_tam(DSLKK *l,NUT *A)
    277. {
    278.     int h=0,t;
    279.     DSLKK *lst=new DSLKK();
    280.     NUT *p;
    281.     for(p=l->cuoi;p!=NULL;p=p->truoc)
    282.     {
    283.         t=p->duLieu* A->duLieu+ h;
    284.         lst->themNutODau(t%10);
    285.         h=t/10;
    286.     }
    287.     if(h!=0)
    288.     {
    289.         lst->themNutODau(h);
    290.     }
    291.     lst->sign=1;
    292.     return lst;
    293. }
    294. /////////////////////////////////////////////////////////////////////////////////////
    295. DSLKK * tich(DSLKK *l1,DSLKK *l2,int SST)
    296. {
    297.     DSLKK *lst=new DSLKK();
    298.     DSLKK *temp=new DSLKK();
    299.     NUT *run;
    300.     NUT *k;
    301.     for(k=l2->cuoi;k!=NULL;k=k->truoc)
    302.     {
    303.         run=l2->cuoi;
    304.         temp=tich_tam(l1,k);
    305.         while(run!=k)
    306.         {
    307.             temp->themNutOCuoi(0);
    308.             run=run->truoc;
    309.         }
    310.         lst=tongDuong(lst,temp);
    311.     }
    312.     if((l1->sign*l2->sign)==1)
    313.         lst->sign=1;
    314.     else
    315.         lst->sign=-1;
    316.     return lst;
    317. }
    318. /////////////////////////////////////////////////////////////////////////////////////
    319. int so_sanh_tam(char st1[],char st2[])
    320. {
    321.     int len1,len2,i=0,j=0;
    322.     if(st1[0]=='-')
    323.         i=1;
    324.     if(st2[0]=='-')
    325.         j=1;
    326.     len1=strlen(st1)-i;
    327.     len2=strlen(st2)-j;
    328.     if(len1>len2)
    329.         return 1;
    330.     else
    331.         if(len1<len2)
    332.             return -1;
    333.         else
    334.         {
    335.             for(int k=0;k<len1;k++)
    336.                 if(atoi(&st1[k+i])>atoi(&st2[k+j]))
    337.                     return 1;
    338.                 else
    339.                     if(atoi(&st1[k+i])<atoi(&st2[k+j]))
    340.                         return -1;         
    341.             return 0;
    342.         }
    343. }
    344. /////////////////////////////////////////////////////////////////////////////////////
    345. int so_sanh(char st1[],char st2[])
    346. {  
    347.     if(st1[0]!='-' && st2[0]=='-')
    348.         return 1;
    349.     if(st1[0]=='-' && st2[0]!='-')
    350.         return -1;
    351.     if(st1[0]=='-' && st2[0]=='-')
    352.     {
    353.         if(so_sanh_tam(st1,st2)==1)
    354.             return -1;
    355.         else
    356.             if(so_sanh_tam(st1,st2)==0)
    357.                 return 0;
    358.             else
    359.                 if(so_sanh_tam(st1,st2)==-1)
    360.                     return 1;
    361.     }      
    362.     if(st1[0]!='-' &&st2[0]!='-')
    363.     {
    364.         if(so_sanh_tam(st1,st2)==1)
    365.             return 1;
    366.         else if(so_sanh_tam(st1,st2)==0)
    367.             return 0;
    368.         else if(so_sanh_tam(st1,st2)==-1)
    369.             return -1;
    370.     }      
    371.     return 0;
    372. }
    C++ Code:
    1. #include<conio.h>
    2. #include<stdio.h>
    3. #include<iostream.h>
    4. #include<stdlib.h>
    5. #include<string.h>
    6. #include"xlsn.h"
    7.  
    8. void main()
    9. {
    10.     DSLKK *l1=new DSLKK();
    11.     DSLKK *l2=new DSLKK();
    12.     DSLKK *l=new DSLKK();
    13.     char st1[1001],st2[1001];
    14.     Nhap:
    15.         cout<<"Nhap so nguyen thu nhat: ";
    16.         cin>>st1;
    17.         cout<<"Nhap so nguyen thu hai:  ";
    18.         cin>>st2;
    19.         int ssc=so_sanh_tam(st1,st2);
    20.         int ss=so_sanh(st1,st2);
    21.         l1->chuyen(st1);
    22.         cout<<"Nhap so thu nhat: ";
    23.         l1->xuat();
    24.         l2->chuyen(st2);
    25.         cout<<"Nhap so thu hai:  ";
    26.         l2->xuat();
    27.         int k=-1;
    28.     while(k<5)
    29.     {
    30.         cout<<"Chon tu 1 den 5"<<endl;
    31.         cout<<"1:Cong"<<endl;
    32.         cout<<"2:Tru"<<endl;
    33.         cout<<"3:Nhan"<<endl;
    34.         cout<<"4:So sanh"<<endl;
    35.         cout<<"5:Thoat"<<endl;
    36.         cout<<"Ban chon:";
    37.         cin>>k;
    38.         switch(k)
    39.         {
    40.         case 1:
    41.             {
    42.                 cout<<" Tong hai so la:";
    43.                 l=tong(l1,l2,ssc);
    44.                 l->xuat();
    45.             }
    46.             break;
    47.         case 2:
    48.             {
    49.                 cout<<" Hieu hai so la:";
    50.                 l=hieu(l1,l2,ssc);
    51.                 l->xuat();
    52.             }
    53.             break;
    54.         case 3:
    55.             {
    56.                 cout<<" Tich hai so la:";
    57.                 l=tich(l1,l2,ssc);
    58.                 l->xuat();
    59.             }
    60.             break;
    61.         case 4:
    62.             {
    63.                 if(ss==1)
    64.                     cout<<" So thu nhat > so thu hai";
    65.                 if(ss==-1)
    66.                     cout<<" So thu nhat < so thu hai";
    67.                 if(ss==0)
    68.                     cout<<" So thu nhat = so thu hai";
    69.                 cout<<endl;
    70.             }  
    71.             break;
    72.         }
    73.     }
    74.     getch();
    75. }

  4. #4
    Ngày gia nhập
    01 2007
    Nơi ở
    Somewhere I belong
    Bài viết
    168

    Ui hoa hết cả mắt. Thank bác nhá, nhưng em nhìn toét mắt mà hông thấy thuật toán vừa chèn vừa xắp xếp đâu.

  5. #5
    Ngày gia nhập
    04 2007
    Bài viết
    128

    cái đầu tiên hàm sxchontructiepND() ; chontructiepDC(); MergeSort(); QuickSort();,(ko có cái "vừa chèn vừa sắp xếp" nên bác khỏi tìm),hàm tìm kiếm: NUT* timNut(KieuDL). Còn có dùng stack khử đệ quy cho quicksort trên DSLK nhưng ai cần thì mình mới post
    Đã được chỉnh sửa lần cuối bởi soda_chanhmuoi : 18-05-2007 lúc 08:13 AM.

  6. #6
    Ngày gia nhập
    04 2007
    Bài viết
    128

    Mặc định DSLK các giải thuật sắp xếp và tìm kiếm

    này này!! bổ sung roài đó!!tui để nó nằm riêng trong 1 khung luôn đó, bác khỏi tìm toét mắt nhá!! hè hè

  7. #7
    Ngày gia nhập
    11 2011
    Bài viết
    14

    đúng là hoa mắt thật!

Các đề tài tương tự

  1. Kỹ thuật C Bài tập DSLK, mọi người test và cho mình xin ý kiến
    Gửi bởi nguoirung1.6 trong diễn đàn Thắc mắc lập trình C/C++/C++0x
    Trả lời: 1
    Bài viết cuối: 03-12-2010, 08:45 AM
  2. Các giải thuật sắp xếp trong DSLK. Giúp mình với?
    Gửi bởi thai.co trong diễn đàn Thắc mắc lập trình C/C++/C++0x
    Trả lời: 6
    Bài viết cuối: 26-10-2010, 10:48 PM
  3. Tìm kiếm trên file! Tìm kiếm xâu mẫu dùng giải thuật Naive | Giúp mình code sai ở đâu
    Gửi bởi totoise trong diễn đàn Thắc mắc lập trình C/C++/C++0x
    Trả lời: 1
    Bài viết cuối: 19-04-2009, 08:22 PM
  4. Giải thuật MergeSort bằng DSLK
    Gửi bởi thesun140188 trong diễn đàn Thắc mắc lập trình C/C++/C++0x
    Trả lời: 5
    Bài viết cuối: 16-04-2009, 12:31 PM
  5. giải thuật trên cây nhị phân tìm kiếm?!?
    Gửi bởi gauconchuabityeu trong diễn đàn Thắc mắc lập trình C/C++/C++0x
    Trả lời: 2
    Bài viết cuối: 08-03-2008, 06:29 PM

Quyền hạn của bạn

  • Bạn không thể gửi đề tài mới
  • Bạn không thể gửi bài trả lời
  • Bạn không thể gửi các đính kèm
  • Bạn không thể chỉnh sửa bài viết của bạn