Công cụ bảo vệ mã nguồn .NET mạnh nhất, không thể unpack, miễn phí cho các khách hàng đầu tiên đăng ký.
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ông cụ bảo vệ mã nguồn .NET mạnh nhất hiện tại, miễn phí cho các khách hàng đầu tiên đăng ký.
    Đã đượ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ông cụ bảo vệ mã nguồn .NET mạnh nhất hiện tại, miễn phí cho các khách hàng đầu tiên đăng ký.

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