PDA

View Full Version : لیست پیوندی در ++c



ab o atash
دوشنبه 13 اسفند 1386, 22:30 عصر
سلام به همه دوستان
من یه لیست پیوندی با سه تابع insertوattachوdelet نوشتم ولی درست اجرا نمیشه
می خواستم یه کمکی کنید تا مشکلش رو پیدا کنم.

#include"stdafx.h"

class node
{
friendclass list;
private:
node *next;
char *name;
char *family;
int number;
public:
node()
{
next=0;
name="name";
family="family";
number=0;
}
node(char *n,char *f,int s)
{
next=0;
name=n;
family=f;
number=s;
}

};

class list
{
private:
node *first,*last;
public:
list()
{
first=last=0;
}
void attach(char*n,char*f,int s)
{
node *temp=new node(n,f,s);
node *cur=last;
if(first==0)
{
first=temp;
first->next=0;
last=first;
}
if(first=last)
{
last=temp;
first->next=temp;
}
cur->next=temp;
last=temp;
}
void insert(char *n,char *f,int s)
{
node *temp=new node(n,f,s);
node *prior=first;
node *cur=first->next;

if(first=0)
{
first=temp;
first->next=0;
first=last;
return;
}
if(first=last)
{
if(first->number<temp->number)
{
last=temp;
first->next=temp;
temp->next=0;
}
else

{
first=temp;
temp->next=last;
}
}
while((prior->number)<(temp->number) && cur!=0)
{
prior=cur;
cur=cur->next;
}
if(prior=first)
{
first=temp;
temp->next=prior;
}
if(cur=0 && prior->number < temp->number)
{
last=temp;
cur->next=temp;
temp->next=0;
}
first->next=temp;
temp->next=prior;
}
void delet(int id)
{
node *cur=first;
node *prior=0;
if(first=0)
return;
while(cur->number!=id && cur!=0)
{
prior=cur;
cur=cur->next;
}
if(cur=first)
first=first->next;
if(cur=last)
last=prior;
prior->next=cur->next;
}

ICEMAN
سه شنبه 14 اسفند 1386, 07:55 صبح
سلام ...
این یکی از تمرین هایی بود که من انجام دادم یه نگاهای به کدش بکن Comment هم داره
و فکر کنم مشکلت با همین حل میشه



1 // Fig. 21.3: Listnode.h
2 // Template ListNode class definition.
3 #ifndef LISTNODE_H
4 #define LISTNODE_H
5
6 // forward declaration of class List required to announce that class
7 // List exists so it can be used in the friend declaration at line 13
8 template< typename NODETYPE > class List;
9
10 template< typename NODETYPE>
11 class ListNode
12 {
13 friend class List< NODETYPE >; // make List a friend
14
15 public:
16 ListNode( const NODETYPE & ); // constructor
17 NODETYPE getData() const; // return data in node
18 private:
19 NODETYPE data; // data
20 ListNode< NODETYPE > *nextPtr; // next node in list
21 }; // end class ListNode
22
23 // constructor
24 template< typename NODETYPE>
25 ListNode< NODETYPE >::ListNode( const NODETYPE &info )
26 : data( info ), nextPtr( 0 )
27 {
28 // empty body
29 } // end ListNode constructor
30
31 // return copy of data in node
32 template< typename NODETYPE >
33 NODETYPE ListNode< NODETYPE >::getData() const
34 {
35 return data;
36 } // end function getData
37
38 #endif




1 // Fig. 21.4: List.h
2 // Template List class definition.
3 #ifndef LIST_H
4 #define LIST_H
5
6 #include <iostream>
7 using std::cout;
8
9 #include "listnode.h" // ListNode class definition
10
11 template< typename NODETYPE >
12 class List
13 {
14 public:
15 List(); // constructor
16 ~List(); // destructor
17 void insertAtFront( const NODETYPE & );
18 void insertAtBack( const NODETYPE & );
19 bool removeFromFront( NODETYPE & );
20 bool removeFromBack( NODETYPE & );
21 bool isEmpty() const;
22 void print() const;
23 private:
24 ListNode< NODETYPE > *firstPtr; // pointer to first node
25 ListNode< NODETYPE > *lastPtr; // pointer to last node
26
27 // utility function to allocate new node
28 ListNode< NODETYPE > *getNewNode( const NODETYPE & );
29 }; // end class List
30
31 // default constructor
32 template< typename NODETYPE >
33 List< NODETYPE >::List()
34 : firstPtr( 0 ), lastPtr( 0 )
35 {
36 // empty body
37 } // end List constructor
38
39 // destructor
40 template< typename NODETYPE >
41 List< NODETYPE >::~List()
42 {
43 if ( !isEmpty() ) // List is not empty
44 {
45 cout << "Destroying nodes ...\n";
46
47 ListNode< NODETYPE > *currentPtr = firstPtr;
48 ListNode< NODETYPE > *tempPtr;
49
50 while ( currentPtr != 0 ) // delete remaining nodes
51 {
52 tempPtr = currentPtr;
53 cout << tempPtr->data << '\n';
54 currentPtr = currentPtr->nextPtr;
55 delete tempPtr;
56 } // end while
57 } // end if
58
59 cout << "All nodes destroyed\n\n";
60 } // end List destructor
61
62 // insert node at front of list
63 template< typename NODETYPE >
64 void List< NODETYPE >::insertAtFront( const NODETYPE &value )
65 {
66 ListNode< NODETYPE > *newPtr = getNewNode( value ); // new node
67
68 if ( isEmpty() ) // List is empty
69 firstPtr = lastPtr = newPtr; // new list has only one node
70 else // List is not empty
71 {
72 newPtr->nextPtr = firstPtr; // point new node to previous 1st node
73 firstPtr = newPtr; // aim firstPtr at new node
74 } // end else
75 } // end function insertAtFront
76
77 // insert node at back of list
78 template< typename NODETYPE >
79 void List< NODETYPE >::insertAtBack( const NODETYPE &value )
80 {
81 ListNode< NODETYPE > *newPtr = getNewNode( value ); // new node
82
83 if ( isEmpty() ) // List is empty
84 firstPtr = lastPtr = newPtr; // new list has only one node
85 else // List is not empty
86 {
87 lastPtr->nextPtr = newPtr; // update previous last node
88 lastPtr = newPtr; // new last node
89 } // end else
90 } // end function insertAtBack
91
92 // delete node from front of list
93 template< typename NODETYPE >
94 bool List< NODETYPE >::removeFromFront( NODETYPE &value )
95 {
96 if ( isEmpty() ) // List is empty
97 return false; // delete unsuccessful
98 else
99 {
100 ListNode< NODETYPE > *tempPtr = firstPtr; // hold tempPtr to delete
101
102 if ( firstPtr == lastPtr )
103 firstPtr = lastPtr = 0; // no nodes remain after removal
104 else
105 firstPtr = firstPtr->nextPtr; // point to previous 2nd node
106
107 value = tempPtr->data; // return data being removed
108 delete tempPtr; // reclaim previous front node
109 return true; // delete successful
110 } // end else
111 } // end function removeFromFront
112
113 // delete node from back of list
114 template< typename NODETYPE >
115 bool List< NODETYPE >::removeFromBack( NODETYPE &value )
116 {
117 if ( isEmpty() ) // List is empty
118 return false; // delete unsuccessful
119 else
120 {
121 ListNode< NODETYPE > *tempPtr = lastPtr; // hold tempPtr to delete
122
123 if ( firstPtr == lastPtr ) // List has one element
124 firstPtr = lastPtr = 0; // no nodes remain after removal
125 else
126 {
127 ListNode< NODETYPE > *currentPtr = firstPtr;
128
129 // locate second-to-last element
130 while ( currentPtr->nextPtr != lastPtr )
131 currentPtr = currentPtr->nextPtr; // move to next node
132
133 lastPtr = currentPtr; // remove last node
134 currentPtr->nextPtr = 0; // this is now the last node
135 } // end else
136
137 value = tempPtr->data; // return value from old last node
138 delete tempPtr; // reclaim former last node
139 return true; // delete successful
140 } // end else
141 } // end function removeFromBack
142
143 // is List empty?
144 template< typename NODETYPE >
145 bool List< NODETYPE >::isEmpty() const
146 {
147 return firstPtr == 0;
148 } // end function isEmpty
149
150 // return pointer to newly allocated node
151 template< typename NODETYPE >
152 ListNode< NODETYPE > *List< NODETYPE >::getNewNode(
153 const NODETYPE &value )
154 {
155 return new ListNode< NODETYPE >( value );
156 } // end function getNewNode
157
158 // display contents of List
159 template< typename NODETYPE >
160 void List< NODETYPE >::print() const
161 {
162 if ( isEmpty() ) // List is empty
163 {
164 cout << "The list is empty\n\n";
165 return;
166 } // end if
167
168 ListNode< NODETYPE > *currentPtr = firstPtr;
169
170 cout << "The list is: ";
171
172 while ( currentPtr != 0 ) // get element data
173 {
174 cout << currentPtr->data << ' ';
175 currentPtr = currentPtr->nextPtr;
176 } // end while
177
178 cout << "\n\n";
179 } // end function print
180
181 #endif