C ++ Data Structure Single-chain table (Template Class)

Source: Internet
Author: User

C ++ Data Structure Single-chain table (Template Class)

Using the template class to implement a single-chain table and its Functions

Operations to be implemented:

[1] push_back [2] push_front
[3] show_list [0] quit_system
[4] pop_back [5] pop_front
[6] insert_val [7] delete_val
[8] find [9] length
[10] clear [11] destroy
[12] reserv [13] sort

Header file source code:

 

# Ifndef LIST_H_INCLUDED # define LIST_H_INCLUDED # include
 
  
Using namespace std; template
  
   
Class List; template
   
    
Class ListNode {friend class List
    
     
; Public: ListNode (): data (Type (), next (NULL) {} ListNode (Type d, ListNode
     
      
* N = NULL): data (d), next (n ){}~ ListNode () {} public: void SetData (Type d) {data = d;} Type GetData () const {return data;} private: Type data; ListNode
      
        * Next;}; template
       
         Class List {public: List () {first = last = Buynode ();}~ List () {List
        
          : Destroy ();} public: void push_back (const Type & x); void push_front (const Type & x); void show_list () const; void pop_back (); void pop_front (); void insert_val (const Type & x); void delete_val (const Type & x); bool find (const Type & x); Type length (); void clear (); void destroy (); // destroy the sequence table void reserv (); // reverse void sort (); protected: ListNode
         
           * Buynode (Type x = Type () {ListNode
          
            * P = new ListNode
           
             (X); return p;} private: ListNode
            
              * First; ListNode
             
               * Last;}; template
              
                Void List
               
                 : Push_back (const Type & x) {ListNode
                
                  * S = Buynode (x); last-> next = s; last = s; first-> data ++;} template
                 
                   Void List
                  
                    : Push_front (const Type & x) {ListNode
                   
                     * S = Buynode (x); s-> next = first-> next; first-> next = s; if (first = last) last = s; first-> data ++;} template
                    
                      Void List
                     
                       : Show_list () const {ListNode
                      
                        * P = first-> next; while (p! = NULL) {cout <
                       
                         Data <"; p = p-> next;} cout <
                        
                          Void List
                         
                           : Pop_back () {if (first-> data = 0) return; ListNode
                          
                            * P = first; while (p-> next! = Last) p = p-> next; ListNode
                           
                             * Q = p-> next; p-> next = NULL; last = p; delete q; first-> data --;} template
                            
                              Void List
                             
                               : Pop_front () {ListNode
                              
                                * P = first-> next; first-> next = p-> next; p = NULL; delete p; if (first-> data = 1) last = first; first-> data --;} template
                               
                                 Void List
                                
                                  : Insert_val (const Type & x) {ListNode
                                 
                                   * S = Buynode (x); ListNode
                                  
                                    * P = first-> next; if (p-> data> s-> data) {push_front (s-> data );} else if (last-> data <s-> data) {push_back (s-> data);} else {while (p-> data <x) & (p-> next-> data
                                   
                                     Next;} s-> next = p-> next; p-> next = s; first-> data ++;} template
                                    
                                      Void List
                                     
                                       : Delete_val (const Type & x) {ListNode
                                      
                                        * P = first-> next; ListNode
                                       
                                         * S = Buynode (x); if (x = p-> data) {pop_front ();} else {while (p-> data! = X) & (p-> next-> data! = X) {p = p-> next;} p-> next = p-> next; ListNode
                                        
                                          * Q = p-> next; delete q; first-> data --;} template
                                         
                                           Bool List
                                          
                                            : Find (const Type & x) {ListNode
                                           
                                             * P = first-> next; while (p! = NULL & p-> data! = X) p = p-> next; return p;} template
                                            
                                              Type List
                                             
                                               : Length () {cout <"length =" <
                                              
                                                Data <
                                               
                                                 Data;} template
                                                
                                                  Void List
                                                 
                                                   : Clear () {while (first-> data> 0) pop_front ();} template
                                                  
                                                    Void List
                                                   
                                                     : Destroy () // destroy this sequence table {clear (); delete first; first = last = NULL;} template
                                                    
                                                      Void List
                                                     
                                                       : Reserv () // reverse, setting the entire tablespace to {ListNode
                                                      
                                                        * P = first-> next; ListNode
                                                       
                                                         * Curr = p-> next; ListNode
                                                        
                                                          * Tmp = NULL; first-> next = NULL; while (curr) // direct the cursor to next {tmp = curr-> next; curr-> next = p; p = curr; curr = tmp;} first-> next = p;} template
                                                         
                                                           Void List
                                                          
                                                            : Sort () {ListNode
                                                           
                                                             * S = first-> next; while (s-> next) {ListNode
                                                            
                                                              * P = s; while (p-> next) {if (s-> data> p-> next-> data) {Type tmp = s-> data; s-> data = p-> next-> data; p-> next-> data = tmp;} p = p-> next ;} s = s-> next ;}# endif // LIST_H_INCLUDED
                                                            
                                                           
                                                          
                                                         
                                                        
                                                       
                                                      
                                                     
                                                    
                                                   
                                                  
                                                 
                                                
                                               
                                              
                                             
                                            
                                           
                                          
                                         
                                        
                                       
                                      
                                     
                                    
                                   
                                  
                                 
                                
                               
                              
                             
                            
                           
                          
                         
                        
                       
                      
                     
                    
                   
                  
                 
                
               
              
             
            
           
          
         
        
       
      
     
    
   
  
 

Main function:

 

 

 
# Include "List. h" int main () {List
 
  
Mylist; int select = 1; int Item; int pos; while (select) {cout <"*********************************** * ** "<
  
   
"; Cin> select; switch (select) {case 1: cout <" Enter the value to be inserted (-1 ends):> "; while (cin> Item, Item! =-1) {mylist. push_back (Item);} break; case 2: cout <"Enter the value to be inserted (-1 ended):>"; while (cin> Item, Item! =-1) {mylist. push_front (Item);} break; case 3: mylist. show_list (); break; case 4: mylist. pop_back (); break; case 5: mylist. pop_front (); break; case 6: cout <"Enter the value to insert:>"; cin> Item; mylist. insert_val (Item); break; case 7: cout <"Enter the value to delete:>"; cin> Item; mylist. delete_val (Item); break; case 8: cout <"Enter the value to be searched:>"; cin> Item; mylist. find (Item); break; case 9: mylist. length (); break; case 10: mylist. clear (); break; case 11: mylist. destroy (); break; case 12: mylist. reserv (); break; case 13: mylist. sort (); break; default: break ;}}}
  
 

 

 


 

 

Contact Us

The content source of this page is from Internet, which doesn't represent Alibaba Cloud's opinion; products and services mentioned on that page don't have any relationship with Alibaba Cloud. If the content of the page makes you feel confusing, please write us an email, we will handle the problem within 5 days after receiving your email.

If you find any instances of plagiarism from the community, please send an email to: info-contact@alibabacloud.com and provide relevant evidence. A staff member will contact you within 5 working days.

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

  • Sales Support

    1 on 1 presale consultation

  • After-Sales Support

    24/7 Technical Support 6 Free Tickets per Quarter Faster Response

  • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.