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

Đề tài: Giúp với nhá - LinkedList - NhânViên - C++

  1. #1
    Ngày gia nhập
    11 2008
    Bài viết
    0

    Red face Giúp với nhá - LinkedList - NhânViên - C++

    Mình đang dc học Linked List. Nhưng chán quá mấy bạn ơi! 'Ông thầy' dạy theo C++, cũng hay! nhưng mà ổng chưa từng có kinh nghiệm về Linked List bằng C++. Theo mình thấy thì ông thầy ổng đuối lắm rồi - chỉ giải quyết được những vấn để cơ bản của Linked List thôi, chẳng có bài mẫu viết bằng c++, c thì có đầy nhưng mình chuyển qua khó quá! giúp mình đi. Lớp mình sắp thi tới nơi rồi, bây giờ không lẽ giật ngược sang c thì mệt quá. Nếu không ai giúp chắc có lẽ mình và lớp sẽ die nhiều môn này đấy.

    bài của mình đây:

    NhanVienH.h
    Code:
    #ifndef NHANVIENH_H
    #define NHANVIENH_H
    
    struct NV {
    	char MaNV[5];
    	char HoTen[30];
    	char SoDT[10];
    	char ChucVu[20];
    };
    
    typedef NV T;
    
    class NhanVien {
    public:
    	NhanVien(void);
    	~NhanVien(void);
    	void ThemNV(T item);
    	void XuatNV();
    	void TimNV(char cChucVu[20]);
    	void XoaNV(char cMaNV[5]);
    	bool TimMaNV(char cMaNV[5]);
    	bool isEmpty();
    	void DeleteList();
    private:
    	struct Node {
    		T value;
    		struct Node *next;
    	};
    	Node *head;
    };
    
    #endif
    NhanVienF.cpp
    Code:
    #include "NhanVienH.h"
    #include <iostream>
    #include <conio.h>
    using namespace std;
    
    NhanVien::NhanVien(void) {
    	head = 0;
    }
    
    NhanVien::~NhanVien(void) {
    	
    }
    
    void NhanVien::ThemNV(T item) {
    	Node *current;
    	current=new Node;
    	current->value=item;
    	if(isEmpty()) {
    		head=current;
    		head->next=0;
    	}else{
    		current->next=head;
    		head=current;
    	}
    }
    
    void NhanVien::XuatNV() {
    	Node *current;
    	current=head;
    	cout<<"MaNV \t HoTen \t SoDT \t ChucVu"<<endl;
    	while(current!=0) {
    		cout<<current->value.MaNV<<"\t"
    			<<current->value.HoTen<<"\t"
    			<<current->value.SoDT<<"\t"
    			<<current->value.ChucVu<<endl;
    		current=current->next;
    	}
    }
    
    void NhanVien::TimNV(char cChucVu[20]) {
    	Node *current;
    	current=head;
    	cout<<"MaNV \t HoTen \t SoDT \t ChucVu"<<endl;
    	while(current!=0) {
    		if(strcmp(current->value.ChucVu, cChucVu)==0) {
    			cout<<current->value.MaNV<<"\t"
    				<<current->value.HoTen<<"\t"
    				<<current->value.SoDT<<"\t"
    				<<current->value.ChucVu<<endl;
    		}
    		current=current->next;
    	}
    }
    
    void NhanVien::XoaNV(char cMaNV[5]) {
    	//Help
    }
    
    bool NhanVien::TimMaNV(char cMaNV[5]) {
    	Node *current;
    	current=head;
    	while(current!=0) {
    		if(strcmp(current->value.MaNV, cMaNV)==0) {
    			return true;
    		}
    		current=current->next;
    	}
    	return false;
    }
    
    bool NhanVien::isEmpty() {
    	if(head==0) return true;
    	else return false;
    }
    
    void NhanVien::DeleteList() {
    	Node *current;
    	current=head;
    	while(!isEmpty()) {
    		head=head->next;
    		delete current;
    		current=head;
    	}
    }
    NhanVienM.cpp
    Code:
    #include "NhanVienH.h"
    #include <iostream>
    #include <conio.h>
    using namespace std;
    
    void showMenu(char &chon);
    
    void main() {
    	char cchon,tiep;
    	NV info;
    	NhanVien mylist;
    	char mChucVu[20],mMaNV[5];
    	do {
    		showMenu(cchon);
    		switch(cchon) {
    			case '1': //Nhap Nhan vien
    				cout<<"Nhap MaNV: "; fflush(stdin);
    				cin.getline(info.MaNV, 5);
    				cout<<"Nhap HoTen: "; fflush(stdin);
    				cin.getline(info.HoTen, 30);
    				cout<<"Nhap SoDT: "; fflush(stdin);
    				cin.getline(info.SoDT, 10);
    				cout<<"Nhap ChucVu: "; fflush(stdin);
    				cin.getline(info.ChucVu, 20);
    				mylist.ThemNV(info);
    				cout<<"Mot nhan vien da duoc them! ";
    				break;
    			case '2':
    				cout<<"Danh sach nhan vien: "<<endl;
    				mylist.XuatNV();
    				break;
    			case '3':
    				cout<<"Nhap MaNV muon xoa: "; fflush(stdin);
    				cin.getline(mMaNV, 5);
    				mylist.XoaNV(mMaNV);
    				break;
    			case '4': //Xoa danh sach
    				mylist.DeleteList();
    				break;
    			case '5': //Tim kiem theo ChucVu
    				cout<<"Nhap ChucVu muon tim: "; fflush(stdin);
    				cin.getline(mChucVu, 20);
    				mylist.TimNV(mChucVu);
    				break;
    			case '6':
    				return;
    		}
    		cout<<"Ban muon la tiep ko (y/n)? ";
    		do {
    			tiep=getch();
    		} while(tiep!='y' && tiep!='n');
    		cout<<endl;
    	} while(tiep=='y');
    }
    
    void showMenu(char &chon) {
    	cout<<"+------[ CHUONG TRINH QUAN LY NHAN VIEN ]-----+"<<endl;
    	cout<<"| 1. Nhap nhan vien moi                       |"<<endl;
    	cout<<"| 2. Xuat danh sach nhan vien                 |"<<endl;
    	cout<<"| 3. Xoa nhan vien (theo MaNV)                |"<<endl;
    	cout<<"| 4. Xoa tat ca nhan vien                     |"<<endl;
    	cout<<"| 5. Tim nhan vien (theo ChucVu)              |"<<endl;
    	cout<<"| 6. Quit                                     |"<<endl;
    	cout<<"+---------------------------------------------+"<<endl;
    	cout<<"Chon: ";
    	do {
    		chon=getch();
    	} while(
    		chon!='1' &&
    		chon!='2' &&
    		chon!='3' &&
    		chon!='4' &&
    		chon!='5' &&
    		chon!='6');
    	cout<<endl;
    }
    Các bạn làm giúp mình phần Thêm (đầu, cuối, giữa); Xóa (Đầu, cuối, giữ- nhập MaNV)

    Dành tí thời gian giúp mình nha! không chỉ giúp mình mà còn giúp cả lớp mình nữa đấy! hix

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

    Ghê, giúp cả lớp cậu cơ đấy à ! Đùa chứ ! Ví dụ này khá cơ bản trong C++ đây, nếu thắc mắc chỗ nào cứ post tui sẽ giải thích
    C++ Code:
    1. #include <stdexcept>  // for all exception typename
    2. #include <string>     // for string
    3. #include <new>        // for bad_alloc
    4.  
    5. using std::string;
    6. using std::out_of_range;
    7. using std::logic_error;
    8. using std::bad_alloc;
    9. using std::endl;
    10.  
    11.  
    12. class ListIndexOutOfRangeException : public out_of_range
    13. {
    14. public :
    15.     ListIndexOutOfRangeException( const string& mess = "" )
    16.         :out_of_range( mess.c_str() )
    17.     {   }
    18. };
    19.  
    20. class ListException : public logic_error
    21. {
    22. public :
    23.     ListException( const string& mess = "" )
    24.         :logic_error( mess.c_str() )
    25.     {   }
    26. };
    27.  
    28. class DuplicateException : public logic_error
    29. {
    30. public :
    31.     DuplicateException( const string& mess = "" )
    32.         :logic_error( mess.c_str() )
    33.     {   }
    34. };
    35.  
    36.  
    37. #include <cstddef>
    38. #include <iostream>
    39.  
    40. using std::cout;
    41. using std::ostream;
    42.  
    43. /*
    44.     -----------------------
    45.     - Description of data -
    46.     -----------------------
    47.     Constant global variables :
    48.         + the value of position we could not find
    49.         data
    50. */
    51. const int INVALID_POSITION = -1;
    52.  
    53.  
    54.  
    55. template< typename Type > class SortedLinkedList;
    56.  
    57. template< typename Type >
    58. class ListNode
    59. {
    60. private :
    61.     ListNode( const Type& item = Type(), ListNode* next = NULL )
    62.         :item( item ), next( next )
    63.     {   }
    64.  
    65. private :
    66.     Type      item;
    67.     ListNode* next;
    68.  
    69.     friend class SortedLinkedList< Type >;
    70. };
    71.  
    72.  
    73. template< typename Type >
    74. class SortedLinkedList
    75. {
    76. public :
    77.     /* Public constructor & destructor #1 */
    78.     SortedLinkedList();
    79.     /* Public constructor & destructor #2 */
    80.     SortedLinkedList( const SortedLinkedList< Type >& );
    81.     /* Public constructor & destructor #3 */
    82.     virtual ~SortedLinkedList();
    83.  
    84. public :
    85.     /* Public method #1 */
    86.     virtual ostream&          printList( ostream& ) const;
    87.     /* Public method #2 */
    88.     virtual bool              isEmpty() const;
    89.     /* Public method #3 */
    90.     virtual void              insertItemByIndex( int , const Type& )
    91.         throw( ListIndexOutOfRangeException, ListException );
    92.     /* Public method #4 */
    93.     virtual void              removeItem( int )
    94.         throw( ListIndexOutOfRangeException );
    95.     /* Public method #5 */
    96.     virtual void              removeAllItem();
    97.     /* Public method #6 */
    98.     virtual void              insertAnItem( const Type& )
    99.         throw( DuplicateException );
    100.     /* Public method #7 */
    101.     virtual int               getSize() const;
    102.     /* Public method #8*/
    103.     virtual int               findInsertPosition( const Type& , bool& );
    104.     /* Public method #9 */
    105.     virtual void              retrieveItem( int, Type& ) const
    106.         throw( ListIndexOutOfRangeException );
    107.     /* Public method #10 */
    108.     virtual void              changeItem( int, Type& )
    109.         throw( ListIndexOutOfRangeException );
    110.  
    111. public :
    112.     /* Public overloading operator #1 */
    113.     virtual const SortedLinkedList& operator =( const SortedLinkedList< Type >& );
    114.     /* Public overloading operator #2 */
    115.     virtual bool operator ==( const SortedLinkedList< Type >& ) const;
    116.     /* Public overloading operator #3 */
    117.     virtual bool operator !=( const SortedLinkedList< Type >& ) const;
    118.  
    119. public :
    120.     /* Public friend method #1   */
    121.     template< typename PrintType >
    122.     friend ostream& operator <<( ostream& , const SortedLinkedList< PrintType >& );
    123.  
    124. protected :
    125. /*
    126.     --------------------
    127.     - Data description -
    128.     --------------------
    129.         - size will be the size of the current list.
    130.         - head will be the head pointer to the list,
    131.         all operations will via this pointer.
    132. */
    133.     int                size;
    134.     ListNode< Type >*  head;
    135.  
    136. private :
    137.     /*  Private method #1  */
    138.     void                      cloneNode( const ListNode< Type >* const );
    139.     /*  Private method #2  */
    140.     ListNode< Type >*         findItem( int ) const;
    141.     /*  Private method #3  */
    142.     virtual ListNode< Type >* getHeadPointer() const;
    143. };
    144.  
    145.  
    146. /*
    147.     ----------------------
    148.     - Method description -
    149.     ----------------------
    150.     Public constructor & destructor #1 :
    151.         - This is default constructor.
    152. */
    153. template< typename Type >
    154. SortedLinkedList< Type >::SortedLinkedList()
    155.     :size( 0 ), head( NULL )
    156. {   }
    157.  
    158.  
    159. /*
    160.     ----------------------
    161.     - Method description -
    162.     ----------------------
    163.     Public constructor & destructor #2 :
    164.         - This is copy constructor.
    165. */
    166. template< typename Type >
    167. SortedLinkedList< Type >::SortedLinkedList( const SortedLinkedList< Type >& rhs )
    168.     :size( rhs.size )
    169. {
    170.     cloneNode( rhs.head );
    171. }
    172.  
    173.  
    174. /*
    175.     ----------------------
    176.     - Method description -
    177.     ----------------------
    178.     Public constructor & destructor #3 :
    179.         - This is destructor.
    180. */
    181. template< typename Type >
    182. SortedLinkedList< Type >::~SortedLinkedList()
    183. {
    184.     removeAllItem();
    185. }
    186.  
    187.  
    188. /*
    189.     ----------------------
    190.     - Method description -
    191.     ----------------------
    192.     Public method #1 :
    193.         - This method will print the entire list.
    194. */
    195. template< typename Type >
    196. ostream& SortedLinkedList< Type >::printList( ostream& out ) const
    197. {
    198.     ListNode< Type >* ptr;
    199.     for( ptr = head; ptr != NULL; ptr = ptr->next )
    200.     {
    201.         out << ptr->item;
    202.     }
    203.     return out;
    204. }
    205.  
    206.  
    207. /*
    208.  
    209.     ----------------------
    210.     - Method description -
    211.     ----------------------
    212.     Public method #2 :
    213.         - This method will check whether
    214.         or not the list is empty.
    215. */
    216. template< typename Type >
    217. bool SortedLinkedList< Type >::isEmpty() const
    218. {
    219.     return size == 0;
    220. }
    221.  
    222.  
    223. /*
    224.     ----------------------
    225.     - Method description -
    226.     ----------------------
    227.     Public method #3 :
    228.         - This method will insert an item
    229.         based on its position.
    230.         - Two exception will be thrown :
    231.             + ListException ( bad allocation ).
    232.             + ListIndexOutOfRangeException( access
    233.             the position is not valid.
    234. */
    235. template< typename Type >
    236. void SortedLinkedList< Type >::insertItemByIndex( int index, const Type& new_item )
    237.     throw( ListIndexOutOfRangeException, ListException )
    238. {
    239.     // insert new item so increase the size
    240.     int new_length = getSize() + 1;
    241.     // check for out of range
    242.     if( index < 1  || index > new_length )
    243.     {
    244.         throw
    245.             ListIndexOutOfRangeException
    246.             (
    247.                 "ListIndexOutOfRangeException : " \
    248.                 "insert index out of range ! "
    249.             );
    250.  
    251.     }
    252.     else
    253.     {
    254.         // create a new node with new_item as data
    255.         ListNode< Type >* new_ptr = new ListNode< Type >( new_item );
    256.         // change the current size( i.e increase the size by 1 )
    257.         size                      = new_length;
    258.  
    259.         try
    260.         {
    261.             // if index = 1, plug it right into head
    262.             // save a function call findItem
    263.             if( index == 1 )
    264.             {
    265.                 new_ptr->next = head;
    266.                 head          = new_ptr;
    267.             }
    268.             // otherwise call find to find the previous node
    269.             else
    270.             {
    271.                 // find the previous node
    272.                 ListNode< Type >* prev = findItem( index - 1 );
    273.                 // new node link to the the previous link to next
    274.                 new_ptr->next          = prev->next;
    275.                 // prev link to next now point to new node
    276.                 prev->next             = new_ptr;
    277.             }
    278.         }
    279.         catch( bad_alloc ex )
    280.         {
    281.             throw ListException( "ListException : insert can't allocate memory");
    282.         }
    283.     }
    284. }
    285.  
    286.  
    287. /*
    288.     ----------------------
    289.     - Method description -
    290.     ----------------------
    291.     Public method #4 :
    292.         - This method will remove an item
    293.         based on its position.
    294.         - One exception will be thrown :
    295.             + ListIndexOutOfRangeException( access
    296.             the position is not valid.
    297. */
    298. template< typename Type >
    299. void SortedLinkedList< Type >::removeItem( int index )
    300.     throw( ListIndexOutOfRangeException )
    301. {
    302.     // If it's invalid position
    303.     // throw an exception
    304.     if( index < 1  || index > getSize() )
    305.     {
    306.         throw
    307.             ListIndexOutOfRangeException
    308.             (
    309.                 "ListIndexOutOfRangeException : " \
    310.                 "remove index out of range ! "
    311.             );
    312.     }
    313.     else
    314.     {
    315.         // create a current node
    316.         ListNode< Type >* cur;
    317.         // decrease the size
    318.         size--;
    319.         // if index = 1, plug it right into head
    320.         // save a function call findItem
    321.         if( index == 1 )
    322.         {
    323.             cur = head;
    324.             head = head->next;
    325.         }
    326.         // otherwise call find to find the previous node
    327.         else
    328.         {
    329.             ListNode< Type >* prev = findItem( index - 1 );
    330.             // save current node
    331.             cur                    = prev->next;
    332.             // skip that node ( i.e remove it )
    333.             prev->next             = cur->next;
    334.         }
    335.         // return node to system
    336.         cur->next = NULL;
    337.         // delete it
    338.         delete cur;
    339.         // assign it to NULL
    340.         cur       = NULL;
    341.     }
    342. }
    343.  
    344.  
    345. /*
    346.     ----------------------
    347.     - Method description -
    348.     ----------------------
    349.     Public method #5 :
    350.         - This method will destroy all the
    351.         nodes by calling remove( 1 ) as
    352.         a helper method.
    353. */
    354. template< typename Type >
    355. void SortedLinkedList< Type >::removeAllItem()
    356. {
    357.     while( !isEmpty() )
    358.     {
    359.         removeItem( 1 );
    360.     }
    361. }
    362.  
    363.  
    364. /*
    365.     ----------------------
    366.     - Method description -
    367.     ----------------------
    368.     Public method #6 :
    369.         - This method will insert a node
    370.         base all its value since our list is
    371.         sorted linked list.
    372.         - Duplicate value is invalid.
    373.         - One exception will be thrown :
    374.             + DuplicateException( an item that is
    375.             already in the list
    376. */
    377. template< typename Type >
    378. void SortedLinkedList< Type >::insertAnItem( const Type& new_item )
    379.     throw( DuplicateException )
    380. {
    381.     // create a flag variable
    382.     bool duplicate_error;
    383.     // try to get a valid insert postion
    384.     int  insert_position = findInsertPosition( new_item, duplicate_error );
    385.     // if we the item is already in the list
    386.     // throw an exception
    387.     if( duplicate_error == true )
    388.     {
    389.         throw DuplicateException( "DuplicateException : new_item already exists !" );
    390.     }
    391.     // otherwise call insertItemByIndex and insert the
    392.     // new_item into the position we just found
    393.     else
    394.     {
    395.         insertItemByIndex( insert_position, new_item );
    396.     }
    397. }
    398.  
    399.  
    400. /*
    401.     ----------------------
    402.     - Method description -
    403.     ----------------------
    404.     Public method #7 :
    405.         - This method just simply return the current
    406.         size of our list.
    407. */
    408. template< typename Type >
    409. int SortedLinkedList< Type >::getSize() const
    410. {
    411.     return size;
    412. }
    413.  
    414.  
    415. /*
    416.     ----------------------
    417.     - Method description -
    418.     ----------------------
    419.     Public method #8 :
    420.         - This method will call find the appropriate
    421.         position for our data base on its value.
    422.         - If the data is already in the list, flag variable
    423.         duplicate will be set to false otherwise is true.
    424. */
    425. template< typename Type >
    426. int SortedLinkedList< Type >::findInsertPosition( const Type& new_item, bool& duplicate )
    427. {
    428.     // get the head pointer
    429.     ListNode< Type >* target      = getHeadPointer();
    430.     // start from the first item
    431.     int               position    = 1;
    432.  
    433.     // loop through until we find our "target"
    434.     while( ( target != NULL ) && ( ( target->item ) > new_item ) )
    435.     {
    436.         // update target
    437.         target = target->next;
    438.         // update position
    439.         position++;
    440.     }
    441.     // if we find a duplicate value
    442.     if( ( target != NULL ) && ( new_item == target->item ) )
    443.     {
    444.         duplicate = true;
    445.         // the position is invalid
    446.         position  = INVALID_POSITION;
    447.     }
    448.     else
    449.     {
    450.         duplicate = false;
    451.     }
    452.     // return target position
    453.     return position;
    454. }
    455.  
    456.  
    457. /*
    458.     ----------------------
    459.     - Method description -
    460.     ----------------------
    461.     Public method #9 :
    462.         - This method will get the value for our data at
    463.         a specific position.
    464.         - One exception will be thrown :
    465.             + ListIndexOutOfRangeException( access
    466.             the position is not valid.
    467. */
    468. template< typename Type >
    469. void SortedLinkedList< Type >::retrieveItem( int index, Type& assigned_item ) const
    470.     throw( ListIndexOutOfRangeException )
    471. {
    472.     // if the index is out of range
    473.     // throw an exception
    474.     if( index < 1  || index > getSize() )
    475.     {
    476.         throw
    477.             ListIndexOutOfRangeException
    478.             (
    479.                 "ListIndexOutOfRangeException : " \
    480.                 "retrieve index out of range ! "
    481.             );
    482.     }
    483.     // otherwise assign the value at that position
    484.     // for our assigned_item.
    485.     else
    486.     {
    487.         assigned_item = findItem( index )->item;
    488.     }
    489. }
    490.  
    491.  
    492. /*
    493.     ----------------------
    494.     - Method description -
    495.     ----------------------
    496.     Public method #10 :
    497.         - This method will change the data of a
    498.         specific position.
    499.         - One exception will be thrown :
    500.             + ListIndexOutOfRangeException( access
    501.             the position is not valid.
    502. */
    503. template< typename Type >
    504. void SortedLinkedList< Type >::changeItem( int index, Type& new_item )
    505.     throw( ListIndexOutOfRangeException )
    506. {
    507.     // if the index is out of range
    508.     // throw an exception
    509.     if( index < 1  || index > getSize() )
    510.     {
    511.         throw
    512.             ListIndexOutOfRangeException
    513.             (
    514.                 "ListIndexOutOfRangeException : " \
    515.                 "change index out of range ! "
    516.             );
    517.     }
    518.     // else if index = 1, save a function called findItem()
    519.     // the data we need is right at the front
    520.     else if( index == 1 )
    521.     {
    522.         head->item = new_item;
    523.     }
    524.     // otherwise called findItem to get to that postion
    525.     // and change its value
    526.     else
    527.     {
    528.         findItem( index )->item = new_item;
    529.     }
    530. }
    531.  
    532. /*
    533.     ----------------------
    534.     - Method description -
    535.     ----------------------
    536.     Public overloading operator #1 :
    537.         - This method will use the deep-copy
    538.         version since our data is allocated with
    539.         new operator.
    540. */
    541. template< typename Type >
    542. const SortedLinkedList< Type >& SortedLinkedList< Type >::operator =( const SortedLinkedList< Type >& rhs )
    543. {
    544.     // avoid self-assignment
    545.     if( this != &rhs )
    546.     {
    547.         // remove all item
    548.         removeAllItem();
    549.         // make a copy of right-hand-side object's nodes
    550.         cloneNode( rhs.head );
    551.         // update the size
    552.         size = rhs.size;
    553.     }
    554.     // enable cascading
    555.     return *this;
    556. }
    557.  
    558.  
    559. /*
    560.     ----------------------
    561.     - Method description -
    562.     ----------------------
    563.     Public overloading operator #2 :
    564.         - This method will compare the list of invoking
    565.         object with the list of right-hand-size object.
    566.         - If they're equal return true, otherwise return false.
    567. */
    568. template< typename Type >
    569. bool SortedLinkedList< Type >::operator ==( const SortedLinkedList< Type >& rhs ) const
    570. {
    571.     // create a condition flag
    572.     bool condition = true;
    573.     // if they have different size
    574.     // they're obvious not equal
    575.     if( size != rhs.size )
    576.     {
    577.         condition = false;
    578.     }
    579.     // two empty list is considered to be equal
    580.     else if( ( head == NULL ) && ( rhs.head == NULL ) )
    581.     {
    582.         condition = true;
    583.     }
    584.     else
    585.     {
    586.         // i point to the invoking object's head
    587.         ListNode< Type >* i   = head;
    588.         // j point to the right-hand-size object's head
    589.         ListNode< Type >* j   = rhs.head;
    590.         // "run" will runs from head until the
    591.         // end of list
    592.         int               run = 1;
    593.         while( run <= size )
    594.         {
    595.             // check every single item
    596.             // if there's a different term for
    597.             // the two, stop the loop
    598.             // it's already false
    599.             if( i->item != j->item )
    600.             {
    601.                 condition = false;
    602.                 break;
    603.             }
    604.             i = i->next;
    605.             j = j->next;
    606.             run++;
    607.         }
    608.     }
    609.     // return they're equal or not
    610.     return condition;
    611. }
    612.  
    613.  
    614. /*
    615.     ----------------------
    616.     - Method description -
    617.     ----------------------
    618.     Public overloading operator #3 :
    619.         - This method will compare the list of invoking
    620.         object with the list of right-hand-size object.
    621.         - If they're different return true, otherwise return false.
    622.         - Note that we call for the operator == which saves
    623.         a considerable amount of code.
    624. */
    625. template< typename Type >
    626. bool SortedLinkedList< Type >::operator !=( const SortedLinkedList< Type >& rhs ) const
    627. {
    628.     // call for operator == and negate the return value
    629.     return !( *this == rhs );
    630. }
    631.  
    632.  
    633. /*
    634.     ----------------------
    635.     - Method description -
    636.     ----------------------
    637.     Private method #1 :
    638.         - This method will copy all the nodes
    639.         of current node into invoking object list.
    640. */
    641. template< typename Type >
    642. void SortedLinkedList< Type >::cloneNode( const ListNode< Type >* const node )
    643. {
    644.     // if the copied node is NULL
    645.     // then head is NULL
    646.     if( node == NULL )
    647.     {
    648.         head = NULL;
    649.     }
    650.     // otherwise
    651.     else
    652.     {
    653.         // create a node with data of node
    654.         head                      = new ListNode< Type >( node->item );
    655.         // create a temporary pointer point to head
    656.         ListNode< Type >* new_ptr = head;
    657.  
    658.         // loop through the entire list and copy
    659.         for
    660.         (
    661.             ListNode< Type >* i  = node->next;
    662.                               i != NULL;
    663.                               i  = i->next
    664.         )
    665.         {
    666.             // create a node with data at i->item
    667.             new_ptr->next = new ListNode< Type >( i->item );
    668.             // link to the next
    669.             new_ptr       = new_ptr->next;
    670.         }
    671.         // return node for system
    672.         new_ptr->next = NULL;
    673.     }
    674. }
    675.  
    676.  
    677. /*
    678.     ----------------------
    679.     - Method description -
    680.     ----------------------
    681.     Private method #2 :
    682.         - This method will find and return a pointer
    683.         of the position "index".
    684.         - Note that there's no exception of out of range
    685.         here. NULL represents for the not_found pointer.
    686. */
    687. template< typename Type >
    688. ListNode< Type >* SortedLinkedList< Type >::findItem( int index ) const
    689. {
    690.     if( index < 1 || index > size )
    691.     {
    692.         return NULL;
    693.     }
    694.     else
    695.     {
    696.         ListNode< Type >* cur = head;
    697.         for( int i = 1; i < index; ++i )
    698.         {
    699.             cur = cur->next;
    700.         }
    701.         return cur;
    702.     }
    703. }
    704.  
    705.  
    706. /*
    707.     ----------------------
    708.     - Method description -
    709.     ----------------------
    710.     Private method #3 :
    711.         - This method will return the head pointer
    712.         of our list.
    713. */
    714. template< typename Type >
    715. ListNode< Type >* SortedLinkedList< Type >::getHeadPointer() const
    716. {
    717.     return head;
    718. }
    719.  
    720.  
    721. /*
    722.     ----------------------
    723.     - Method description -
    724.     ----------------------
    725.     Public friend method #1 :
    726.         - This method will call for printList( ostream& )
    727.         method to print out the entire list.
    728. */
    729. template< typename Type >
    730. ostream& operator <<( ostream& out, const SortedLinkedList< Type >& rhs )
    731. {
    732.     rhs.printList( out );
    733.     return out;
    734. }
    735.  
    736. int main()
    737. {
    738.     SortedLinkedList< int > l;
    739.  
    740.     l.insertAnItem( 1 );
    741.     l.insertAnItem( 2 );
    742.     l.insertAnItem( 3 );
    743.  
    744.     cout << l <<
    745.     return 0;
    746. }

  3. #3
    Ngày gia nhập
    11 2008
    Bài viết
    0

    rox lại đùa! rox viết bằng C# mừ! bài của rox cao siu quá! chịu hok nổi luôn. chỉ có căn bản lập trình mà con rớt tùm lum, nhìn code của rox chỉ còn nước chìmm thôi. vậy là hok ai giúp àh! buồn nhỉ?!

    mình không đùa! có ai giúp thì đỡ được phần nào, có bài cho tụi lớp nó nấu thành cháo đến bữa thi thì ung dung mắt nhắm, mắt mở mà code. Mình thì chả lo, tới bữa mang mấy bài c cũ ra code củng chẳng sao. tệ lắm củng qua được.

    đi học tự học là chính. chả ai giúp dc gì nhìu, buồn quá. thày cô bây giờ sướng ghê. Vào lớp nhấm nháp nước trà xem sih viên code, có lỗi củng chẳng fix ra hồn nữa.

  4. #4
    Ngày gia nhập
    04 2008
    Bài viết
    336

    Cậu ko phân biệt được code C# với C++ std ....
    đổi từ C -> C++ thì cậu đừng xài struct nữa, thử xài class + friend, biến mấy hàm bên ngoài thành phương thức của class.
    anh r2 viết template nên cậu nhìn thấy nó dài thôi, cố gắng phân tích từng phần ra thì sẽ hiểu.
    Kêu cả lớp xúm vào phân tích từng phần cho lẹ, với lại code thì thầy cô chỉ sửa được lỗi cú pháp thôi chứ lỗi logic mà gặp mấy bài dài thì ko phải do chính mình viết rất khó bắt lỗi.
    code ra gió bão

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

  1. Thuật toán C++ xuất 5 phần tử đầu tiên và cuối cùng trong linkedlist và binary tree
    Gửi bởi GMXChaser trong diễn đàn Thắc mắc CTDL & Giải thuật
    Trả lời: 5
    Bài viết cuối: 24-09-2012, 04:02 PM
  2. Sử dụng destructor hợp lý (trong custom linkedlist)
    Gửi bởi quano1 trong diễn đàn Thắc mắc lập trình Visual C++
    Trả lời: 5
    Bài viết cuối: 24-12-2010, 05:43 PM
  3. Cài đặt Queue bằng linkedlist
    Gửi bởi lcdoan 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: 10-12-2010, 06:07 AM
  4. Giúp em ý nghĩa đoạn code dùng operator() để thực thi LinkedList
    Gửi bởi chuong01 trong diễn đàn Nhập môn lập trình C/C++
    Trả lời: 1
    Bài viết cuối: 30-04-2010, 05:35 PM
  5. Trả lời: 3
    Bài viết cuối: 30-11-2008, 09:51 AM

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