#include <stdio.h>
#include <conio.h>
#include <string.h>
#include <alloc.h>
typedef struct list {
char number[50];
struct list *next;
} LIST;

LIST *read_list(LIST *lst)
{
  LIST *p;
  FILE *f;
  f=fopen("rg.txt","r");
  if (!feof(f))
  {
    lst=(LIST *)malloc(sizeof(LIST));
    p=lst;
    while (1)
    {
      fscanf(f,"%s",p->number[50]);
      if (!feof(f))
      {
	p->next=(LIST *)malloc(sizeof(LIST));
	p=p->next;
      } else break;
    }
    p->next=NULL;
  }
  else printf("Файл пустой\n");
  fclose(f);
  return lst;
}

#include <stdio.h>
#include <conio.h>
#include <string.h>
#include <alloc.h>

typedef struct list {

  char number[50];
  struct list *next;

} LIST;

LIST *read_list() {
  char s[255];

  LIST *p, *lst, *final;
  FILE *f;
  f=fopen("rg.txt","r");

  lst = NULL;
  while(!feof(f)) {

    fscanf(f, "%s", s);
    p = (LIST*)malloc(sizeof(list));
    strcpy(p -> number, s);

    if(!lst) lst = p;
    else final -> next = p;

    final = p;

  }
  fclose(f);

  if(!lst) {
    printf("empty file\n");
    return NULL;
  }
  final -> next = NULL;

  return lst;
}

void sort(LIST **first) {

  LIST *L, *p;
  char s[255];

  for(L = *first; L -> next; L = L -> next)

    for(p = L -> next; p; p = p -> next) {

      if(strcmp(L -> number, p -> number) > 0) {
        strcpy(s, L -> number);
        strcpy(L -> number, p -> number);
        strcpy(p -> number, s);
      }
    }

}


int main() {
  struct list *p;
  p = read_list();
  sort(&p);
  for(; p; p = p -> next)
    printf("%s\n", p -> number);

  return 0;
}

Цитата(volvo @ 1.05.2007 21:48)

    strcpy(p -> number, s);

    

if(!lst) lst = p;
    else final -> next = p;

#include <stdio.h>
#include <conio.h>
#include <string.h>
#include <alloc.h>

typedef struct list {

  char number[50];
  struct list *next;

} LIST;

LIST *read_list() {
  char s[255];

  LIST *p, *lst, *final;
  FILE *f;
  f=fopen("rg.txt","r");

  lst = NULL;
  while(!feof(f)) {

    fscanf(f, "%s", s);
    p = (LIST*)malloc(sizeof(list));
    strcpy(p -> number, s);

    if(!lst) lst = p;
    else final -> next = p;

    final = p;

  }
  fclose(f);

  if(!lst) {
    printf("empty file\n");
    return NULL;
  }
  final -> next = NULL;

  return lst;
}

void sort(LIST **first) {

  LIST *L, *p;
  char s[255];

  for(L = *first; L -> next; L = L -> next)

    for(p = L -> next; p; p = p -> next) {

      if(strlen(L -> number) > strlen(p -> number)) { /* сортируем по длине */
        strcpy(s, L -> number);
        strcpy(L -> number, p -> number);
        strcpy(p -> number, s);
      }
    }

}


int main() {
  struct list *root, *p, *T;
  int n;

  /* читаем список из файла */
  root = read_list();

  /* сортируем его по возрастанию длин строк */
  sort(&root);
  /* и печатаем ... */
  for(p = root; p; p = p -> next)
    printf("%s\n", p -> number);

  /* теперь удаляем первые 5 элементов */
  n = 0;
  for(p = root; p && n < 5; n++) {

    p = (T = p) -> next;   /* запоминаем текущее P в переменной T, для того чтобы потом удалить */
    free(T);
  }
  /* и устанавливаем новое начало списка */
  root = p;

  /* еще раз проходим, и печатаем весь список, сразу удаляя все узлы, которые уже распечатаны */
  for(p = root; p; ) {
    printf("%s\n", p -> number);
    p = (T = p) -> next;
    free(T);
  }
  root = NULL;
  return 0;
}

for(L = *first; L -> next; L = L -> next)

    for(p = L -> next; p; p = p -> next)

sort(&root);

 for(p = root; p; p = p -> next)
    printf("%s\n", p -> number);

for(p = root; p && n < 5; n++) 

for(p = root; p; )

/*
  ВНЕШНИЙ цикл

  Поскольку first передается как указатель на указатель
  (причину я объяснял выше), то L присваиваем значению
  разыменованного first (т.е. изначально L = указателю на
  голову списка)

  Условие окончания внешнего цикла - (L->next) подразумевает НЕравенство
  этого значения нулю... То есть, как только значение L->next станет NULL, цикл завершится...

  После обработки одной итерации продвигаемся по списку, путем L = L -> next
*/
for(L = *first; L -> next; L = L -> next)

    /*
    ВНУТРЕННИЙ цикл
    изначально p = L -> next
    условие окончания: закончится цикл - когда p будет нулевым
    продвижение - понятно как осуществляется...
    */
    for(p = L -> next; p; p = p -> next)

 /*
   изначально p = root
   окончание - когда p = NULL
   продвижение - p = p -> next
 */
 for(p = root; p; p = p -> next)
    printf("%s\n", p -> number);

  for(p = root; p; ) {
    printf("%s\n", p -> number);
    p = (T = p) -> next; /* <--- вот эту строку ты разобрала, как она работает? */
    free(T);
  }

for(L = *first; L -> next; L = L -> next)

    for(p = L -> next; p; p = p -> next) {

      if(strlen(L -> number) > strlen(p -> number)) { /* сортируем по длине */
        strcpy(s, L -> number);
        strcpy(L -> number, p -> number);
        strcpy(p -> number, s);
      }
    }

void sort(LIST **first) {

  LIST *L, *p, *pp, *T, *prv_L, *prv_p;
  char s[255];

  start_over:
  ;

  for(L = *first; L -> next; L = L -> next)

    for(p = L -> next; p; p = p -> next) {

      if(strlen(L -> number) > strlen(p -> number)) {

        // Вот тут раньше было 3 строки... Смотри теперь.

        if(L == *first) {

          for(pp = *first; pp -> next != p; pp = pp -> next);
          pp -> next = *first;

          T = (*first) -> next;
          *first = p;

          L -> next = p -> next;
          p -> next = T;

        }
        else {
          LIST *prv_L, *prv_p;
          for(prv_L = *first; prv_L -> next != L; prv_L = prv_L -> next);
          for(prv_p = *first; prv_p -> next != p; prv_p = prv_p -> next);

          prv_L -> next = p;
          prv_p -> next = L;
          T = p -> next;
          p -> next = L -> next;
          L -> next = T;
        }

        goto start_over;
      }
    }

}

Цитата(volvo @ 15.05.2007 17:11)

Ты сама просила

#include <stdio.h>
#include <conio.h>
#include <string.h>
#include <alloc.h>

typedef struct list {

  char number[255];
  struct list *next;

} LIST;

LIST *read_list() {
  char s[255];

  LIST *p, *lst, *final;
  FILE *f;
  f=fopen("rgz.txt","r");

  lst = NULL;
  while(!feof(f)) {

    fgets(s,255, f);
    p = (LIST*)malloc(sizeof(LIST));
    strcpy(p -> number, s);

    if(!lst) lst = p;
    else final -> next = p;

    final = p;

  }
  fclose(f);

  if(!lst) {
    printf("empty file\n");
    return NULL;
  }
  final -> next = NULL;

  return lst;
}
void *sort(LIST *first)
{
  LIST *p1=first, *p2=p1->next, *prev,*temp1, *temp2;
  int flag=1;
  while (flag&&p2)
  {
    flag=0;
    prev=first;
    while (p2)
    {

      if (strlen(p1->number)>strlen(p2->number))
	{
	  flag=1;
	  temp1=p1;
	  temp2=p2->next;
	  p1=p2;
	  p2=temp1;
	  p1->next=p2;
	  p2->next=temp2;
	  if (temp1==first) first=p1; else prev->next=p1;
	}
      prev=p1;
      p1=p1->next;
      p2=p2->next;
    }
    p1=first; p2=p1->next;
  }
}

void *sort1(LIST *first)
{
  LIST *p1=first, *p2=p1->next, *prev,*temp1, *temp2;
  int flag=1;
  while (flag&&p2)
  {
    flag=0;
    prev=first;
    while (p2)
    {

      if (strlen(p1->number) < strlen(p2->number))
	{
	  flag=1;
	  temp1=p1;
	  temp2=p2->next;
	  p1=p2;
	  p2=temp1;
	  p1->next=p2;
	  p2->next=temp2;
	  if (temp1==first) first=p1; else prev->next=p1;
	}
      prev=p1;
      p1=p1->next;
      p2=p2->next;
    }
    p1=first; p2=p1->next;
  }
}







void main() {
  struct list *root, *p, *T;
  int n;
  FILE *f;
  f=fopen("RGZ2.txt","w");

  root = read_list();


   sort1(root);

  for(p = root; p; p = p -> next)
    fprintf(f,"%s\n", p -> number);
    fprintf(f,"\n---\n");
  sort(root);

  n = 0;
  for(p = root; p && n < 5; n++) {

    p = (T = p) -> next;
    free(T);
  }

  root = p;
  sort1(root);


  for(p = root; p; ) {
  fprintf(f,"%s\n", p -> number);
    p = (T = p) -> next;
    free(T);
  }
  root = NULL; fprintf(f,"\n--------\n");

}