Η σελίδα μας αναβαθμίστηκε, γι' αυτό τον λόγο τα μέλη μας θα πρέπει να ζητήσουν νέο κωδικό πρόσβασης από την υπηρεσία "Αποστολή κωδικού πρόσβασης".
Εάν το email με τον νέο κωδικό δεν έρθει στο inbox κοιτάξτε και στο spam folder. Ο server είναι φρέσκος και δεν έχει το reputation που του αξίζει.

Αλλαγή τρόπου ταξινόμησης

Συζητήσεις για την γλώσσα C και C++

Συντονιστές: Super-Moderators, WebDev Moderators

Απάντηση
santi mavropoulou
Δημοσιεύσεις: 5
Εγγραφή: 28 Μάιος 2008 07:21

Αλλαγή τρόπου ταξινόμησης

Δημοσίευση από santi mavropoulou » 28 Μάιος 2008 07:30

Γεια σας,με αυτόν τον κώδικα η λίστα ταξινομείται βάση διεύθυνσης

Κώδικας: Επιλογή όλων

/*===========================================================================*  
 *							  free_mem									 *  
 *===========================================================================*/ 
PUBLIC void free_mem(base, clicks)											  
phys_clicks base;			   /* base address of block to free */			 
phys_clicks clicks;			 /* number of clicks to free */				  
{																			   
/* Return a block of free memory to the hole list.  The parameters tell where   
 * the block starts in physical memory and how big it is.  The block is added   
 * to the hole list.  If it is continuous with an existing hole on either end,  
 * it is merged with the hole or holes.										 
 */																			 
																				
  register struct hole *hp, *new_ptr, *prev_ptr;								
																				
  if (clicks == 0) return;													  
  if ( (new_ptr = free_slots) == NIL_HOLE) panic("Hole table full", NO_NUM);	
  new_ptr->h_base = base;													   
  new_ptr->h_len = clicks;													  
  free_slots = new_ptr->h_next;												 
  hp = hole_head;															   
																				
  /* If this block's address is numerically less than the lowest hole currently 
   * available, or if no holes are currently available, put this hole on the	
   * front of the hole list.													
   */																		   
  if &#40;hp == NIL_HOLE || base <= hp->h_base&#41; 
  &#123;								   
		/* Block to be freed goes on front of the hole list. */				 
		new_ptr->h_next = hp;												   
		hole_head = new_ptr;													
		merge&#40;new_ptr&#41;;														 
		return;																 
  &#125;																			 
																				
  /* Block to be returned does not go on front of hole list. */				 
  while &#40;hp != NIL_HOLE && base > hp->h_base&#41; 
  &#123;								 
		prev_ptr = hp;														  
		hp = hp->h_next;														
  &#125;																			 
																				
  /* We found where it goes.  Insert block after 'prev_ptr'. */				 
  new_ptr->h_next = prev_ptr->h_next;										   
  prev_ptr->h_next = new_ptr;												   
  merge&#40;prev_ptr&#41;;			  /* sequence is 'prev_ptr', 'new_ptr', 'hp' */   
&#125;																			   

/*===========================================================================*  
 *							  merge										*  
 *===========================================================================*/ 
PRIVATE void merge&#40;hp&#41;														  
register struct hole *hp;	   /* ptr to hole to merge with its successors */  
&#123;																			   
 /* Check for continuous holes and merge any found.  Continuous holes can occur  
 * when a block of memory is freed, and it happens to abut another hole on	  
 * either or both ends.  The pointer 'hp' points to the first of a series of	
 * three holes that can potentially all be merged together.					 
 */																			 
																				
  register struct hole *next_ptr;											   
																				
  /* If 'hp' points to the last hole, no merging is possible.  If it does not,  
   * try to absorb its successor into it and free the successor's table entry.  
   */																		   
  if &#40; &#40;next_ptr = hp->h_next&#41; == NIL_HOLE&#41; return;							 
  if &#40;hp->h_base + hp->h_len == next_ptr->h_base&#41; 
  &#123;							 
		hp->h_len += next_ptr->h_len;   /* first one gets second one's mem */   
		del_slot&#40;hp, next_ptr&#41;;												 
  &#125; else 
  &#123;																	  
		hp = next_ptr;														  
  &#125;  
																		   
  /* If 'hp' now points to the last hole, return; otherwise, try to absorb its  
   * successor into it.														 
   */																		   
  if &#40; &#40;next_ptr = hp->h_next&#41; == NIL_HOLE&#41; return;							 
  if &#40;hp->h_base + hp->h_len == next_ptr->h_base&#41; 
  &#123;							 
		hp->h_len += next_ptr->h_len;										   
		del_slot&#40;hp, next_ptr&#41;;												 
  &#125;																			 
&#125;													  
Αυτό που προσπάθησα παρακάτω είναι να αλλάξω τον τρόπο ταξινόμησης ώστε η λίστα να ταξινομείται με βάση το μέγεθος.Είναι αρκετό;

Κώδικας: Επιλογή όλων

/*===========================================================================*  
 *							  free_mem									 *  
 *===========================================================================*/ 
PUBLIC void free_mem&#40;base, clicks&#41;											  
phys_clicks base;			   /* base address of block to free */			 
phys_clicks clicks;			 /* number of clicks to free */				  
&#123;																			   
/* Return a block of free memory to the hole list.  The parameters tell where   
 * the block starts in physical memory and how big it is.  The block is added   
 * to the hole list.  If it is continuous with an existing hole on either end,  
 * it is merged with the hole or holes.										 
 */																			 
																				
  register struct hole *hp, *new_ptr, *prev_ptr;								
																				
  if &#40;clicks == 0&#41; return;													  
  if &#40; &#40;new_ptr = free_slots&#41; == NIL_HOLE&#41; panic&#40;"Hole table full", NO_NUM&#41;;	
  new_ptr->h_base = base;													   
  new_ptr->h_len = clicks;													  
  free_slots = new_ptr->h_next;												 
  hp = hole_head;															   
																				
  /* If this block's address is numerically less than the lowest hole currently 
   * available, or if no holes are currently available, put this hole on the	
   * front of the hole list.													
   */																		   
  if &#40;hp == NIL_HOLE || clicks <= hp->h_len&#41; 
  &#123;								   
		/* Block to be freed goes on front of the hole list. */				 
		new_ptr->h_next = hp;												   
		hole_head = new_ptr;													
		merge&#40;new_ptr&#41;;														 
		return;																 
  &#125;																			 
																				
  /* Block to be returned does not go on front of hole list. */				 
  while &#40;hp != NIL_HOLE && clicks > hp->h_len&#41; 
  &#123;								 
		prev_ptr = hp;														  
		hp = hp->h_next;														
  &#125;																			 
																				
  /* We found where it goes.  Insert block after 'prev_ptr'. */				 
  new_ptr->h_next = prev_ptr->h_next;										   
  prev_ptr->h_next = new_ptr;												   
  merge&#40;prev_ptr&#41;;			  /* sequence is 'prev_ptr', 'new_ptr', 'hp' */   
&#125;																			   

/*===========================================================================*  
 *							  merge										*  
 *===========================================================================*/ 
PRIVATE void merge&#40;hp&#41;														  
register struct hole *hp;	   /* ptr to hole to merge with its successors */  
&#123;																			   
 /* Check for continuous holes and merge any found.  Continuous holes can occur  
 * when a block of memory is freed, and it happens to abut another hole on	  
 * either or both ends.  The pointer 'hp' points to the first of a series of	
 * three holes that can potentially all be merged together.					 
 */																			 
																				
  register struct hole *next_ptr;											   
																				
  /* If 'hp' points to the last hole, no merging is possible.  If it does not,  
   * try to absorb its successor into it and free the successor's table entry.  
   */																		   
  if &#40; &#40;next_ptr = hp->h_next&#41; == NIL_HOLE&#41; return;							 
  if &#40;hp->h_base + hp->h_len == next_ptr->h_len&#41; 
  &#123;							 
		hp->h_len += next_ptr->h_len;   /* first one gets second one's mem */   
		del_slot&#40;hp, next_ptr&#41;;												 
  &#125; 
  else 
  &#123;																	  
		hp = next_ptr;														  
  &#125;  
																		   
  /* If 'hp' now points to the last hole, return; otherwise, try to absorb its  
   * successor into it.														 
   */																		   
  if &#40; &#40;next_ptr = hp->h_next&#41; == NIL_HOLE&#41; return;							 
  if &#40;hp->h_base + hp->h_len == next_ptr->h_len&#41; 
  &#123;							 
		hp->h_len += next_ptr->h_len;										   
		del_slot&#40;hp, next_ptr&#41;;												 
  &#125;																			 
&#125;										 

NIKOS NAXOS
Δημοσιεύσεις: 2
Εγγραφή: 31 Μάιος 2008 16:22

Αλλαγή τρόπου ταξινόμησης

Δημοσίευση από NIKOS NAXOS » 31 Μάιος 2008 17:01

Γεια σου Σαντη

Πιστευω οτι η αλλαγη που εχεις κανει στην free_mem ειναι σωστη ομως στη merge δεν ειναι σωστη καθοσον στην merge οι νεοι κομβοι(ελευθερες μνημες) της λιστας που προκυπτουν απο τη συνγχωνευση παραμενουν στη σωστη θεση ταξινομημενοι με κλειδι το h_base και αρα ο ηδη υπαρχων κωδικας δεν ενδιαφερεται καθολου για την ταξινομηση τους οπως γινεται στη free_mem.Αρα εδω πρεπει να προσθεσοθμε κωδικα και οχι ναλλαξουμε.
Εγω νομιζω οτι πρεπει να γινει μια διδικασια sort(hp) στη νεα λιστα που εφτiαξε η merge με κλειδι το h_len την οποια να καλω μετα την del_slot μεσα στη merge.

Εσυ τι λες υπαρχει κατι πιο ευκολο

santi mavropoulou
Δημοσιεύσεις: 5
Εγγραφή: 28 Μάιος 2008 07:21

Αλλαγή τρόπου ταξινόμησης

Δημοσίευση από santi mavropoulou » 01 Ιουν 2008 08:58

Δεν είμαι καθόλου σίγουρη για την Merge,όντως,στην free_mem νομίζω πως έχω κάνει τις σωστές αλλαγές.Η μόνη αλλαγή που έκανα στην Merge είναι:

...................
if (hp->h_base + hp->h_len == next_ptr->h_len)
...................

NIKOS NAXOS ευχαριστώ,κάτι τέτοιο κάτω από την πρώτη del_slot εννοείς;

void swap (int v[], int i, int j)
{
int temp;
temp=v;
v=v[j];
v[j]=temp;
}

void qsort(int v[], int left, int right)
{
int i, last;
void swap(int v[], int i, int j);
if (left >= right)
return;
swap(v, left, (left+right)/2);
last=left;
for (i=left+1; i<=right; i++)
if (v < v[left])
swap(v, ++last, i);
swap(v, left, last);
qsort(v, left, last-1);
qsort(v, last+1, right);
}

main()
{

int v[];
qsort(v, 0, NR_HOLES (2*NR_PROCS));
}

NIKOS NAXOS
Δημοσιεύσεις: 2
Εγγραφή: 31 Μάιος 2008 16:22

Αλλαγή τρόπου ταξινόμησης

Δημοσίευση από NIKOS NAXOS » 01 Ιουν 2008 18:19

Γεια σου Σαντη
Βλεπω βασανιζεσαι κ εσυ .
Κοιταξε δεν θελω να σε παρασυρω απλως τη γνωμη μου σου λεω.
Η ταξινομηση λιστας δεν ειναι ευκολο πραγμα και ειδικα να την προσαρμοσης εδω.
Τι εξαμηνο εισαι
Εαν καταληξω καπου δωσε μου το mail σου στο info@naxos-villaflora.com να σου πω.
Παντως κι εγω ταλαιπωρουμε και δεν ξερω αν παει χαμενος ο κοπος.

santi mavropoulou
Δημοσιεύσεις: 5
Εγγραφή: 28 Μάιος 2008 07:21

Αλλαγή τρόπου ταξινόμησης

Δημοσίευση από santi mavropoulou » 01 Ιουν 2008 18:41

Γεια σου Νίκο,σου έχω στείλει το email μου,σου έστειλα και προσωπικό μήνυμα το πρωί,δεν ξέρω αν έκανες login να το δεις.Πάντως απ'ότι έψαξα μανιωδώς και κατάλαβα τελικά,έχεις πέσει διάνα σε αυτό που είπες,δηλαδή όντως ο έλεγχος για το διαδοχικό πλαίσιο πρέπει να γίνει εν συγκρίσει με την επόμενη διεύθυνση.Κι επίσης όντως χρειάζεται μια συνάρτηση ταξινόμησης κάτω από τις 2 del_slot,νομίζω,για να τοποθετήσει και τον συγχωνευμένο κόμβο-κόμβους στη θέση τους.Πάντως σίγουρα έχεις καταλήξει κάπου πολύ καλύτερα από μένα,δείχνεις τρομερά έμπειρος για να είπες αυτά με την πρώτη.Ή εγώ θέλω πολύ δουλειά ακόμα!Αν δεν έχεις πρόβλημα,στείλε μου κάτι,ευχαριστώ.

Άβαταρ μέλους
soteres2002
S. & H. Moderator
Δημοσιεύσεις: 1524
Εγγραφή: 05 Μαρ 2004 22:17

Αλλαγή τρόπου ταξινόμησης

Δημοσίευση από soteres2002 » 02 Ιουν 2008 05:54

Πάτρα ή Ιωάννινα;; :wink:

santi mavropoulou
Δημοσιεύσεις: 5
Εγγραφή: 28 Μάιος 2008 07:21

Αλλαγή τρόπου ταξινόμησης

Δημοσίευση από santi mavropoulou » 02 Ιουν 2008 13:40

Γεια σου soteres2002,αν εννοείς από που είναι αυτή η εργασία,από το Ηράκλειο.

Άβαταρ μέλους
soteres2002
S. & H. Moderator
Δημοσιεύσεις: 1524
Εγγραφή: 05 Μαρ 2004 22:17

Αλλαγή τρόπου ταξινόμησης

Δημοσίευση από soteres2002 » 03 Ιουν 2008 17:30

santi mavropoulou έγραψε:Γεια σου soteres2002,αν εννοείς από που είναι αυτή η εργασία,από το Ηράκλειο.
Ααα, μου φάνηκε σαν chunk από τον κώδικα του kernel του Minix και λέω κάποιος από το Πανεπιστήμιο Ιωαννίνων ή της Πατρας πόσταρε. Απλη περιέργεια... :lol: Τελικά, και στο Πανεπ. τσι Κρήτης κάνετε Μinix απ' ότι φαίνεται...

santi mavropoulou
Δημοσιεύσεις: 5
Εγγραφή: 28 Μάιος 2008 07:21

Αλλαγή τρόπου ταξινόμησης

Δημοσίευση από santi mavropoulou » 04 Ιουν 2008 23:45

Πολύ καλά σου φάνηκε,ακριβώς αυτό είναι!Μόνο που είναι από το Τει Ηρακλείου

Απάντηση

Επιστροφή στο “C, C++”

Μέλη σε σύνδεση

Μέλη σε αυτήν τη Δ. Συζήτηση: Δεν υπάρχουν εγγεγραμμένα μέλη και 0 επισκέπτες