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

Đề tài: Tại sao chọn xóa n lại xóa tại n + 1 - Linked List trong lập trình C

  1. #1
    Ngày gia nhập
    11 2007
    Nơi ở
    Biết để làm gì?
    Bài viết
    827

    Mặc định Tại sao chọn xóa n lại xóa tại n + 1 - Linked List trong lập trình C

    C++ Code:
    1. #include <conio.h>
    2. #include <iostream.h>
    3. #include <malloc.h>
    4. #include <iomanip.h>
    5. struct Node
    6. {
    7.     int gt;
    8.     Node*next;
    9. };
    10. struct Node *L=NULL;//khai bao 1 ds rong
    11. void menu()
    12. {
    13.     cout<<"\n";
    14.     cout<<"\n\t\tCAC THAO TAC TREN DSLK DON\n";
    15.     cout<<"\n\t\t1.Nhap";
    16.     cout<<"\n\t\t2.Hien thi";
    17.     cout<<"\n\t\t3.Dem so Node";
    18.     cout<<"\n\t\t4.Tim node cuoi";
    19.     cout<<"\n\t\t5.Xoa";
    20.     cout<<"\n\t\t6.Thoat\n";
    21. }
    22. void Nhap(int x,Node**f)
    23. {
    24.     Node*p,*q;
    25.     p=new Node;
    26.     p->gt=x;
    27.     p->next=NULL;
    28.     if (*f==NULL)//danh sach ban dau rong
    29.     {
    30.         *f=p;
    31.     }
    32.     else
    33.     {
    34.         q=*f;
    35.         while (q->next!=NULL)
    36.         {
    37.             q=q->next;
    38.         }
    39.         q->next=p;
    40.     }
    41. }
    42. void HienThi(Node**f)
    43. {
    44.     Node*q;
    45.     q=*f;
    46.     while (q!=NULL)
    47.     {
    48.         cout<<setw(3)<<q->gt;
    49.         q=q->next;
    50.     }
    51. }
    52. void Dem(Node**f)
    53. {
    54.     Node *q;int dem=0;
    55.     q=*f;
    56.     while (q!=NULL)
    57.     {
    58.         dem++;
    59.         q=q->next;
    60.     }
    61.     cout<<"So node cua dslk:"<<dem;
    62. }
    63. void NutCuoi(Node**f)
    64. {
    65.     Node *p;
    66.     p=*f;
    67.     while (p!=NULL&& p->next!=NULL)
    68.     {
    69.         p=p->next;
    70.     }
    71.     cout<<"Node cuoi cua DSLK:"<<p->gt;
    72. }
    73. void Xoa(Node**f,int n)
    74. {
    75.     Node*p,*q;
    76.     int i=0;
    77.     p=*f;
    78.     while (i<=n && p->next!=NULL)
    79.     {
    80.         q=p;
    81.         i++;
    82.         p=p->next;
    83.     }
    84.     if (p==NULL)
    85.         cout<<"\nVi tri nhap sai";
    86.     else
    87.     {
    88.         if(q==NULL)
    89.         {
    90.             (*f)=(*f)->next;
    91.             p->next=NULL;delete(p);
    92.         }
    93.         else if (p->next==NULL)
    94.         {
    95.             while (p->next!=NULL)
    96.             {
    97.                 q=p;
    98.                 p=p->next;
    99.             }
    100.             q->next=NULL;
    101.             delete(p);
    102.         }
    103.         else
    104.         {
    105.             q=(*f)->next;
    106.             (*f)->next=q->next;
    107.         }
    108.     }
    109. }
    110. void main()
    111. {
    112.     int lc,x,n;
    113.     do
    114.     {
    115.         menu();
    116.         cout<<"\t\tNhap lua chon cua ban:";
    117.         cin>>lc;
    118.         switch(lc)
    119.         {
    120.         case 1:
    121.             cout<<"Nhap cac gia tri,nhap -1 de ket thuc:"<<endl;
    122.             do
    123.             {
    124.                 cin>>x;
    125.                 if (x!=-1)
    126.                 {
    127.                     Nhap(x,&L);
    128.                 }
    129.             } while(x!=-1);
    130.             break;
    131.         case 2:
    132.             cout<<"\nDanh sach lien ket da nhap:"<<endl;
    133.             HienThi(&L);
    134.             break;
    135.         case 3:
    136.             Dem(&L);
    137.             break;
    138.         case 4:
    139.             NutCuoi(&L);
    140.             break;
    141.         case 5:
    142.             cout<<"Nhap vi tri can xoa:";
    143.             cin>>n;
    144.             cout<<"Danh sach truoc khi xoa:\n";
    145.             HienThi(&L);
    146.             Xoa(&L,n);
    147.             cout<<"\nDanh sach sau khi xoa:"<<endl;
    148.             HienThi(&L);
    149.             break;
    150.         }
    151.     } while(lc!=6);
    152. }
    Tất cả đều ổn,chỉ tại ở phần xóa,tại sao khi nhập vị trí cần xóa vào là n chẳng hạn thì nó xóa ở n+1?test mãi mà không được!Mọi người hướng dẫn cho cái nhé
    Cánh Chym ứ mỏi

  2. #2
    Ngày gia nhập
    12 2006
    Nơi ở
    US
    Bài viết
    1,917

    Để có gì chiều về tui sẽ coi giúp, có điều hàm del của bạn diecay viết quá rối :
    PHP Code:
    void Xoa(Node**f,int n)
    {
        
    Node*p,*q;
        
    int i=0;
        
    p=*f;
        while (
    i<=&& p->next!=NULL)
        {
            
    q=p;
            
    i++;
            
    p=p->next;
        }
        if (
    p==NULL)
            
    cout<<"\nVi tri nhap sai";
        else
        {
            if(
    q==NULL)
            {
                (*
    f)=(*f)->next;
                
    p->next=NULL;delete(p);
            }
            else if (
    p->next==NULL)
            {
                while (
    p->next!=NULL)
                {
                    
    q=p;
                    
    p=p->next;
                }
                
    q->next=NULL;
                
    delete(p);
            }
            else
            {
                
    q=(*f)->next;
                (*
    f)->next=q->next;
            }
        }

    Đây là single link list, hàm xóa khủng đến vậy tui mới thấy lần đầu. Nên có 1 hàm giữ vị trí node.

  3. #3
    Ngày gia nhập
    11 2007
    Nơi ở
    Biết để làm gì?
    Bài viết
    827

    Trích dẫn Nguyên bản được gửi bởi rox_rook Xem bài viết
    Để có gì chiều về tui sẽ coi giúp, có điều hàm del của bạn diecay viết quá rối :
    PHP Code:
    void Xoa(Node**f,int n)
    {
        
    Node*p,*q;
        
    int i=0;
        
    p=*f;
        while (
    i<=&& p->next!=NULL)
        {
            
    q=p;
            
    i++;
            
    p=p->next;
        }
        if (
    p==NULL)
            
    cout<<"\nVi tri nhap sai";
        else
        {
            if(
    q==NULL)
            {
                (*
    f)=(*f)->next;
                
    p->next=NULL;delete(p);
            }
            else if (
    p->next==NULL)
            {
                while (
    p->next!=NULL)
                {
                    
    q=p;
                    
    p=p->next;
                }
                
    q->next=NULL;
                
    delete(p);
            }
            else
            {
                
    q=(*f)->next;
                (*
    f)->next=q->next;
            }
        }

    Đây là single link list, hàm xóa khủng đến vậy tui mới thấy lần đầu. Nên có 1 hàm giữ vị trí node.
    Thực ra trong single linked lits,khi muốn xóa thường chia ra 3 trường hợp xóa ở vị trí đầu,cuối hoặc ở giữa.Mình muốn trong hàm có thể thỏa mãn 3 trường hợp này nên mới viết vậy.
    Tôi ko hiểu tại sao bạn nói lại cần có hànm giữ vị trí node,con trỏ**f luôn chỉ vào node đầu tiên rồi mà
    Cánh Chym ứ mỏi

  4. #4
    Ngày gia nhập
    12 2006
    Nơi ở
    US
    Bài viết
    1,917

    Ý tui là ví dụ hàm đó sẽ move tới position cần thiết nào đó để xóa hẳn 1 vị trí như vậy sẽ đỡ phức tạp hơn, tui còn 1 class nữa. Tí tui về tui coi lại vì bây h tui không check được T_T !

  5. #5
    Ngày gia nhập
    12 2006
    Nơi ở
    US
    Bài viết
    1,917

    Sorry là bây h tui debug cho bạn không nổi, code bạn đặt tên tui đọc vào tui khủng quá. Với lại theo tui đoán bạn viết theo kiểu của C, mà kiểu này thì tui không quen cho lắm. Nếu đã implement link list thì tui thường dùng cả class List, chứ không xài only struct như vậy. Mấy cái thư viện của bạn cũng thừa rất nhiều :
    #include <malloc.h>
    Bạn dùng C++ mà dùng malloc làm gì ? new và delete ?
    Tui không phải chê bạn nhưng có lẽ bài này viết nhanh quá, bạn nên viết lại cẩn thận đặt tên + comment rõ ràng thì rất khó bug. Link list single cài đặt cũng dễ dàng.
    Đây là cái lớp Link list tui viết năm ngoái, bạn đọc rùi tham khảo nhé. Chắc khi nào rảnh thì tui cũng thử viết kiểu pass List vào hàm coi sao, do từ trước h tui tự học Data Structure toàn implement theo class và tui nghĩ cái kiểu viết trên thì chắc là của C rùi.
    C++ Code:
    1. #include <iostream>
    2. #include <iomanip>
    3.  
    4. using namespace std;
    5. enum Error_code{fail, success, overflow, underflow, range_error};
    6.  
    7. template <class Node_entry> class Node;
    8. template <class Node_entry> class List;
    9.  
    10. template <class Node_entry>
    11. class Node{
    12.   public :
    13.   Node_entry data;
    14.   Node<Node_entry> *next;
    15.   Node(Node_entry item);  
    16.   Node(Node_entry item, Node<Node_entry> *add_on);
    17. };
    18.  
    19. template <class Node_entry>
    20. Node<Node_entry>::Node(Node_entry item, Node<Node_entry>* add_on){
    21.    
    22.   data = item;
    23.   next = add_on;
    24. }
    25.  
    26.  
    27. //Overloading construct II*/
    28. template <class Node_entry>
    29. Node<Node_entry>::Node(Node_entry item){
    30.   data = item;
    31. }
    32.  
    33.  
    34. template <class Node_entry>
    35. class List  
    36. {
    37.   protected :
    38.     int count; /*The number of element in the List*/
    39.     Node<Node_entry> *link;
    40.     Node<Node_entry> *set_position(int position) const;
    41.    
    42.   public :
    43.     List();
    44.     List(const List<Node_entry> &copy);                                  
    45.     ~List();
    46.     const List &operator = (const List &original);
    47.     Error_code insert(int position, const Node_entry &item);
    48.     Error_code add(const Node_entry &item);
    49.     void sort();
    50.     void search(const Node_entry &item)const;
    51.     void traverse() const;
    52.     void clear();
    53.     void remove(int position);
    54.     int size() const;
    55.     bool empty() const;
    56.    
    57. };
    58.  
    59. template <class Node_entry>
    60. List<Node_entry>::List(){
    61.    
    62.    link = NULL;
    63.    count = 0;
    64. }
    65.  
    66. template <class Node_entry>
    67. List<Node_entry>::~List(){
    68.  
    69.    Node<Node_entry> *temp;
    70.    while(link != NULL){
    71.      temp = link;
    72.      link = link->next;
    73.      delete temp;
    74.    }
    75. }
    76.  
    77. /*Utility function*/
    78. template <class Node_entry>
    79. Node<Node_entry> *List<Node_entry>::set_position(int position) const{
    80.  
    81.   Node<Node_entry> *_q = link;
    82.   for(int x = 0; x < position; x++)
    83.     _q = _q->next;
    84.   return _q;
    85. }
    86.  
    87. /*Copy constructor*/
    88. template <class Node_entry>
    89. List<Node_entry>::List(const List<Node_entry> &copy){
    90.  
    91.   Node<Node_entry> *new_copy,
    92.                    *previous = copy.link;
    93.   if(link == NULL) link = NULL;
    94.   else{
    95.     link = new_copy = new Node<Node_entry>(previous->entry);
    96.     while(previous->next != NULL){
    97.       previous = previous->next;
    98.       new_copy->next = new Node<Node_entry>(previous->entry);
    99.       new_copy = new_copy->next;
    100.     }
    101.   }
    102. }  
    103.  
    104. /*Overloading operator '=' */
    105. template <class Node_entry>
    106. const List<Node_entry> &List<Node_entry>::operator = (const List<Node_entry> &original){
    107.  
    108.   Node<Node_entry> *previous = original.link;
    109.   Node<Node_entry> *new_link;
    110.   if(previous == NULL){
    111.     link = NULL;
    112.   }
    113.   else{  
    114.     new_link = previous = new Node<Node_entry>(previous->data);
    115.     while(previous->next != NULL){
    116.       previous = previous->next;
    117.       new_link->next = new Node<Node_entry>(previous->data);
    118.       new_link = new_link->next;
    119.     }
    120.     link->next = link;
    121.     clear();
    122.     link = new_link;
    123.     return *this;//enable cascading
    124.   }
    125. }
    126.  
    127. /*Insert function*/
    128. template <class Node_entry>
    129. Error_code List<Node_entry>::insert(int position, const Node_entry &item){
    130.  
    131.   if(position < 0 || position > count){
    132.     return range_error;
    133.   }
    134.  
    135.   Node<Node_entry> *new_node, *previous, *following;
    136.   if(position > 0){
    137.     previous = set_position(position - 1);
    138.     following = previous->next;
    139.   }
    140.   else{
    141.     following = link;
    142.   }
    143.    
    144.   new_node = new Node<Node_entry>(item, following);
    145.   if(new_node == NULL)
    146.     return overflow;
    147.  
    148.   if(position == 0)
    149.     link = new_node;
    150.   else
    151.     previous->next = new_node;
    152.  
    153.   count++;
    154.   return success;
    155. }
    156.  
    157. /*Add an item at front of LIST*/
    158. template <class Node_entry>
    159. Error_code List<Node_entry>::add(const Node_entry &item){
    160.  
    161.   Node<Node_entry> *new_link = new Node<Node_entry>(item, link);
    162.   if(new_link == NULL) return overflow;
    163.   link = new_link;
    164.   count++;
    165.   return success;
    166. }
    167.  
    168.  
    169. template <class Node_entry>
    170. bool List<Node_entry>::empty() const{
    171.    
    172.   return (link == NULL);
    173. }
    174.  
    175. template <class Node_entry>
    176. void List<Node_entry>::search(const Node_entry &item)const{
    177.            
    178.   bool is_existed = false;
    179.   Node<Node_entry> *temp = link;
    180.   while(temp != NULL && (!is_existed)){
    181.     if(temp->data == item){
    182.       cout << "[" << item << "]"
    183.            << "is in List. \n" << endl;
    184.       temp = NULL;
    185.       is_existed = true;
    186.     }
    187.     else{
    188.       temp = temp->next;
    189.     }
    190.   }  
    191.   if(!is_existed){
    192.     cout << "[" << item << "]"
    193.          << "is not in List.\n" << endl;
    194.   }
    195. }
    196.  
    197. template <class Node_entry>
    198. int List<Node_entry>::size() const{
    199.  
    200.   return count;
    201. }
    202.  
    203. template <class Node_entry>
    204. void List<Node_entry>::traverse() const{
    205.      
    206.   Node<Node_entry> *tour;
    207.   for(int x = 0; x < count; x++){
    208.     tour = set_position(x);    
    209.     cout << tour->data << " -> ";
    210.   }
    211.   cout << tour->next << endl;
    212.   delete tour;
    213. }
    214.  
    215.  
    216. template <class Node_entry>
    217. void List<Node_entry>::clear(){
    218.  
    219.   Node<Node_entry> *temp;
    220.   while(link != NULL){
    221.     temp = link;
    222.     link = link->next;
    223.     delete temp;
    224.   }
    225.   link = NULL;
    226. }
    227.  
    228.  
    229. template <class Node_entry>
    230. void List<Node_entry>::remove(int position){
    231.  
    232.   if(position > count || position < 0){
    233.         cout << "Out of range.";
    234.   }
    235.   else{
    236.     Node<Node_entry> *temp, *previous;
    237.     previous = set_position(position - 1);
    238.     temp = set_position(position);
    239.     previous->next = temp->next;
    240.     delete temp;
    241.   }
    242.   count--;
    243. }
    244.  
    245. template <class Node_entry>
    246. void List<Node_entry>::sort(){
    247.  
    248.   if(empty()){
    249.     cout << "List is unavailable.";
    250.   }    
    251.   else{
    252.     Node<Node_entry> *swap = link;
    253.     while(swap->next != NULL){
    254.       Node<Node_entry> *temp = swap->next;
    255.       while(temp != NULL){
    256.         if((swap->data) > (temp->data)){
    257.           /*Implement like swap function*/
    258.           int hold_value = swap->data;
    259.           swap->data = temp->data;
    260.           temp->data = hold_value;
    261.         }
    262.         temp = temp->next;
    263.       }
    264.       swap = swap->next;
    265.     }
    266.   }
    267. }
    268.  
    269.  
    270. int main()
    271. {
    272.   List<int> L;
    273.   int a = 29, b = 7, c = 3, d = 5;
    274.   L.add(a);
    275.   L.add(b);
    276.   L.add(c);
    277.   L.add(d);
    278.   L.sort();
    279.   L.traverse();
    280.  
    281.   return 0;
    282. }
    Còn cái hàm chuyển vị trí node mà tui nói là đây, có hàm này thì xoá chỗ nào insert chỗ nào cũng cực kì dễ dàng. Hàm cũng cực kì đơn giản.
    PHP Code:
    template <class Node_entry>
    Node<Node_entry> *List<Node_entry>::set_position(int position) const{
      
      
    Node<Node_entry> *_q link;
      for(
    int x 0positionx++)
        
    _q _q->next;
      return 
    _q;

    Do tui tự học nên code này chẳng có thầy cô nào sữa cho tui hết, nếu có bug thì thông cảm, báo cho tui tui sẽ fix cho.
    Và bạn coi đây là hàm delete :
    PHP Code:
    template <class Node_entry>
    void List<Node_entry>::remove(int position){

      if(
    position count || position 0){
            
    cout << "Out of range.";
      }
      else{
        
    Node<Node_entry> *temp, *previous;
        
    previous set_position(position 1);
        
    temp set_position(position);
        
    previous->next temp->next;
        
    delete temp;
      }
      
    count--;

    Cần vị trí nào thì move tới cực kì thuận tiện, tui có 1 biến count dữ số node. bạn cũng nên viết theo cách này cho dẽ xử lý.
    Đã được chỉnh sửa lần cuối bởi rox_rook : 02-03-2008 lúc 02:51 AM.

  6. #6
    Ngày gia nhập
    11 2007
    Nơi ở
    Biết để làm gì?
    Bài viết
    827

    Mặc định Tại sao chọn xóa n lại xóa tại n + 1 - Linked List trong lập trình C

    Trích dẫn Nguyên bản được gửi bởi rox_rook Xem bài viết
    Sorry là bây h tui debug cho bạn không nổi, code bạn đặt tên tui đọc vào tui khủng quá. Với lại theo tui đoán bạn viết theo kiểu của C, mà kiểu này thì tui không quen cho lắm. Nếu đã implement link list thì tui thường dùng cả class List, chứ không xài only struct như vậy. Mấy cái thư viện của bạn cũng thừa rất nhiều :
    #include <malloc.h>
    Bạn dùng C++ mà dùng malloc làm gì ? new và delete ?
    Tui không phải chê bạn nhưng có lẽ bài này viết nhanh quá, bạn nên viết lại cẩn thận đặt tên + comment rõ ràng thì rất khó bug. Link list single cài đặt cũng dễ dàng.
    Đây là cái lớp Link list tui viết năm ngoái, bạn đọc rùi tham khảo nhé. Chắc khi nào rảnh thì tui cũng thử viết kiểu pass List vào hàm coi sao, do từ trước h tui tự học Data Structure toàn implement theo class và tui nghĩ cái kiểu viết trên thì chắc là của C rùi.
    PHP Code:
    #include <iostream>
    #include <iomanip>

    using namespace std;
    enum Error_code{failsuccessoverflowunderflowrange_error};

    template <class Node_entry> class Node;
    template <class Node_entry> class List;

    template <class Node_entry>
    class 
    Node{
      public :
      
    Node_entry data;
      
    Node<Node_entry> *next;
      
    Node(Node_entry item);  
      
    Node(Node_entry itemNode<Node_entry> *add_on);
    };

    template <class Node_entry>
    Node<Node_entry>::Node(Node_entry itemNode<Node_entry>* add_on){
        
      
    data item;
      
    next add_on;



    //Overloading construct II*/
    template <class Node_entry>
    Node<Node_entry>::Node(Node_entry item){
      
    data item;
    }


    template <class Node_entry>
    class List  
    {
      protected : 
        
    int count/*The number of element in the List*/
        
    Node<Node_entry> *link;
        
    Node<Node_entry> *set_position(int position) const;
        
      public :
        List();
        List(const List<
    Node_entry> &copy);                                   
        ~List();
        const List &
    operator = (const List &original);
        
    Error_code insert(int position, const Node_entry &item);
        
    Error_code add(const Node_entry &item);
        
    void sort();
        
    void search(const Node_entry &item)const;
        
    void traverse() const;
        
    void clear();
        
    void remove(int position);
        
    int size() const;
        
    bool empty() const;
        
    };

    template <class Node_entry>
    List<
    Node_entry>::List(){
       
       
    link NULL;
       
    count 0;
    }

    template <class Node_entry>
    List<
    Node_entry>::~List(){

       
    Node<Node_entry> *temp;
       while(
    link != NULL){
         
    temp link;
         
    link link->next;
         
    delete temp;
       }
    }

    /*Utility function*/
    template <class Node_entry>
    Node<Node_entry> *List<Node_entry>::set_position(int position) const{
      
      
    Node<Node_entry> *_q link;
      for(
    int x 0positionx++)
        
    _q _q->next;
      return 
    _q;
    }

    /*Copy constructor*/
    template <class Node_entry>
    List<
    Node_entry>::List(const List<Node_entry> &copy){
      
      
    Node<Node_entry> *new_copy,
                       *
    previous copy.link;
      if(
    link == NULLlink NULL;
      else{
        
    link new_copy = new Node<Node_entry>(previous->entry);
        while(
    previous->next != NULL){
          
    previous previous->next;
          
    new_copy->next = new Node<Node_entry>(previous->entry);
          
    new_copy new_copy->next;
        }
      }
    }  

    /*Overloading operator '=' */
    template <class Node_entry>
    const List<
    Node_entry> &List<Node_entry>::operator = (const List<Node_entry> &original){
      
      
    Node<Node_entry> *previous original.link;
      
    Node<Node_entry> *new_link;
      if(
    previous == NULL){
        
    link NULL;
      }
      else{   
        
    new_link previous = new Node<Node_entry>(previous->data);
        while(
    previous->next != NULL){
          
    previous previous->next;
          
    new_link->next = new Node<Node_entry>(previous->data);
          
    new_link new_link->next;
        }
        
    link->next link;
        
    clear();
        
    link new_link;
        return *
    this;//enable cascading
      
    }
    }

    /*Insert function*/
    template <class Node_entry>
    Error_code List<Node_entry>::insert(int position, const Node_entry &item){

      if(
    position || position count){
        return 
    range_error;
      }
      
      
    Node<Node_entry> *new_node, *previous, *following;
      if(
    position 0){
        
    previous set_position(position 1);
        
    following previous->next;
      }
      else{
        
    following link;
      }
        
      
    new_node = new Node<Node_entry>(itemfollowing);
      if(
    new_node == NULL
        return 
    overflow;
      
      if(
    position == 0)
        
    link new_node;
      else
        
    previous->next new_node;
      
      
    count++;
      return 
    success;
    }

    /*Add an item at front of LIST*/
    template <class Node_entry>
    Error_code List<Node_entry>::add(const Node_entry &item){
      
      
    Node<Node_entry> *new_link = new Node<Node_entry>(itemlink);
      if(
    new_link == NULL) return overflow;
      
    link new_link;
      
    count++;
      return 
    success;
    }

      
    template <class Node_entry>
    bool List<Node_entry>::empty() const{
        
      return (
    link == NULL);
    }

    template <class Node_entry>
    void List<Node_entry>::search(const Node_entry &item)const{
                
      
    bool is_existed false;
      
    Node<Node_entry> *temp link;
      while(
    temp != NULL && (!is_existed)){
        if(
    temp->data == item){
          
    cout << "[" << item << "]" 
               
    << "is in List. \n" << endl;
          
    temp NULL;
          
    is_existed true;
        }
        else{
          
    temp temp->next;
        }
      }  
      if(!
    is_existed){
        
    cout << "[" << item << "]"
             
    << "is not in List.\n" << endl;
      }
    }

    template <class Node_entry>
    int List<Node_entry>::size() const{

      return 
    count;
    }

    template <class Node_entry>
    void List<Node_entry>::traverse() const{
         
      
    Node<Node_entry> *tour;
      for(
    int x 0countx++){
        
    tour set_position(x);     
        
    cout << tour->data << " -> ";
      }
      
    cout << tour->next << endl;
      
    delete tour;
    }


    template <class Node_entry>
    void List<Node_entry>::clear(){

      
    Node<Node_entry> *temp;
      while(
    link != NULL){
        
    temp link;
        
    link link->next;
        
    delete temp;
      }
      
    link NULL;
    }


    template <class Node_entry>
    void List<Node_entry>::remove(int position){

      if(
    position count || position 0){
            
    cout << "Out of range.";
      }
      else{
        
    Node<Node_entry> *temp, *previous;
        
    previous set_position(position 1);
        
    temp set_position(position);
        
    previous->next temp->next;
        
    delete temp;
      }
      
    count--;
    }
      
    template <class Node_entry>
    void List<Node_entry>::sort(){

      if(empty()){
        
    cout << "List is unavailable.";
      }     
      else{
        
    Node<Node_entry> *swap link;
        while(
    swap->next != NULL){
          
    Node<Node_entry> *temp swap->next;
          while(
    temp != NULL){
            if((
    swap->data) > (temp->data)){
              
    /*Implement like swap function*/
              
    int hold_value swap->data;
              
    swap->data temp->data;
              
    temp->data hold_value;
            }
            
    temp temp->next;
          }
          
    swap swap->next;
        }
      }
    }


    int main()
    {
      List<
    intL;
      
    int a 29735;
      
    L.add(a);
      
    L.add(b);
      
    L.add(c);
      
    L.add(d);
      
    L.sort();
      
    L.traverse();

      return 
    0;

    Còn cái hàm chuyển vị trí node mà tui nói là đây, có hàm này thì xoá chỗ nào insert chỗ nào cũng cực kì dễ dàng. Hàm cũng cực kì đơn giản.
    PHP Code:
    template <class Node_entry>
    Node<Node_entry> *List<Node_entry>::set_position(int position) const{
      
      
    Node<Node_entry> *_q link;
      for(
    int x 0positionx++)
        
    _q _q->next;
      return 
    _q;

    Do tui tự học nên code này chẳng có thầy cô nào sữa cho tui hết, nếu có bug thì thông cảm, báo cho tui tui sẽ fix cho.
    Và bạn coi đây là hàm delete :
    PHP Code:
    template <class Node_entry>
    void List<Node_entry>::remove(int position){

      if(
    position count || position 0){
            
    cout << "Out of range.";
      }
      else{
        
    Node<Node_entry> *temp, *previous;
        
    previous set_position(position 1);
        
    temp set_position(position);
        
    previous->next temp->next;
        
    delete temp;
      }
      
    count--;

    Cần vị trí nào thì move tới cực kì thuận tiện, tui có 1 biến count dữ số node. bạn cũng nên viết theo cách này cho dẽ xử lý.
    Thanks RR nhé,đúng là tôi viết theo C,đang dịnh chuyển sang OOP.Tôi cũng định thắc mắc là tại sao RR lại dùng delete hay cout mà không cần <malloc.h> hay <iostream.h> . Có lẽ vì có cái using namespace std phải không,cái này dùng trong C++.Net ?,.Net mình chỉ quan tâm tới C# nên ko rõ cái này lắm
    Cánh Chym ứ mỏi

  7. #7
    Ngày gia nhập
    10 2006
    Nơi ở
    In Your Bugs
    Bài viết
    823

    C++ cũng có cái này chứ cần gì .net . Cậu coi lại thử nào

  8. #8
    Ngày gia nhập
    11 2007
    Nơi ở
    Biết để làm gì?
    Bài viết
    827

    Trích dẫn Nguyên bản được gửi bởi kidkid Xem bài viết
    C++ cũng có cái này chứ cần gì .net . Cậu coi lại thử nào
    Sao tớ làm trên VC6.0 khi using namespace std; vào thì nó bảo lỗi hả bạn?
    Cánh Chym ứ mỏi

  9. #9
    Ngày gia nhập
    05 2007
    Nơi ở
    UNS
    Bài viết
    9

    Trích dẫn Nguyên bản được gửi bởi dieucay555 Xem bài viết
    Sao tớ làm trên VC6.0 khi using namespace std; vào thì nó bảo lỗi hả bạn?
    Muốn using namespace std, thì phải #include <iostream> và bỏ đi #include "iostream.h" ko đc để chung nó sẽ báo ambiguos

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

  1. Hàm trong C Giúp sửa hàm xóa trong list
    Gửi bởi taphoc_c trong diễn đàn Nhập môn lập trình C/C++
    Trả lời: 3
    Bài viết cuối: 12-05-2013, 12:31 PM
  2. Con trỏ trên C Hàm Sắp xếp nổi bọt trong Linked List
    Gửi bởi itviapro trong diễn đàn Nhập môn lập trình C/C++
    Trả lời: 2
    Bài viết cuối: 05-01-2013, 03:33 PM
  3. Cách xóa dữ liệu(đã nhập) và xuất list trong C++?
    Gửi bởi Minh Nhat trong diễn đàn Thảo luận, góp ý code C/C++ của bạn
    Trả lời: 6
    Bài viết cuối: 03-06-2012, 09:25 PM
  4. Xóa một phần tử trong mảng array list C# như thế nào?
    Gửi bởi tuanvi261 trong diễn đàn Thắc mắc lập trình C#
    Trả lời: 3
    Bài viết cuối: 20-05-2012, 09:39 PM
  5. Bài tập C++ xóa sinh viên trong dssv , ai test dùm em , xóa sv thứ 3 mà nó toàn xóa sv thứ 4
    Gửi bởi prt_awm 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-11-2010, 02:24 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