Получить все простые делители числа

1. Индекс простого числа=0:
2. получить следующее простое число,
    если его нет, то находим новое простое число и добавляем  в набор;
3. делим число на простое число
    если делится, то делим наше число и к п1,
    если не делится, то
        если остаток ==1 - подсчет окончен,
        в противном случае к п2

#include<iostream.h>

/**********************************************************
cancellation() Выясняет являеться ли divisor делителем для
number, если да, то находит кратность делителя и возвращает
зачение (number/(divisor^S))
**********************************************************************/

int cancellation(int divisor,int number);

/************************************************************************
Ведём перебор возможных делителей для number (он будет
лежать в промежутке до корня из number включительно, если
number - сложное, см.http://forum.codenet.ru/
showthread.php?t=40875&page=2 сообщение №18), возможное
значение передаем функции cancellation(); перебор возможных
делителей оптимизирован исключением чисел вида 2k, где
k=1,2,3,4,5,6,...; по предложению cheburator'а возможно
исключение чисел вида 3k, 5k  и т.п.
*********************************************************************/

int main()
{
 int n,number;
 cout<<"\nInput number..."<<endl;
 cin>>n;
 cout<<"\nSolve..."<<endl;

 number=n;
 number=cancellation(2,number);

 int k=3;
 while (k*k <= number)
 {
   psi=cancellation(k,psi);
   k+=2;
 }

  cout<<number;
  cout<<"\nDone..."<<endl;

  return (0);
}

int cancellation (int divisor,int number)
{
 if ((number%divisor)==0) cout<<divisor<<"\t";
 while((number%divisor)==0) number/=divisor;
 return (number);
}

#include <stdio.h>;
#include <math.h>;
#include <stdlib.h>;
#include <conio.h>;
int n,i,a,b;
void main()
{
clrscr();
puts("Введите n");
scanf("%i",&n);
printf("Простые делители числа %i:\n",n);
for (i=2;i<=(n/2);i++)
 {
  if ((n%i)==0)
   {
    b=0;
    for (a=2;a<=(i-1);a++)
     {
      if ((i%a)==0) b++;
     }
    if (b==0) printf("%i\n",i);
   }
 }
getch();
}

#include <stdio.h>;
#include <math.h>;
#include <stdlib.h>;
#include <conio.h>;
int n,i,a,b,c;
void main()
{
clrscr();
c=0;
puts("Vvedite n");
scanf("%i",&n);
printf("Prostue deliteli chisla %i:\n",n);
for (i=2;i<=n;i++)
 {
  if ((n%i)==0)
   {
    b=0;
    for (a=2;a<=(i-1);a++)
     {
      if ((i%a)==0) b++;
     }
    if (b==0)
     {
      printf("%i\n",i);
     }
   }
  else c++;
 }
if (c=0) printf("%i\n",n);
//printf("%i",c);
getch();
}

if (c=0) printf("%i\n",n);

#include <deque>
#include <iostream>
#include <math.h>

using namespace std;

// Алгоритм: ищем простые числа, не превосходящие корня из N. Начинаем с числа 2.
// Для каждого найденного простого проверяем делимость N на него.
// "Вычеркиваем" числа, кратные текущему простому p (вычеркивание начинаем с p^2 и идем до N).
// Ищем следующее невычеркнутое число - это будет следующее простое число.
// И т. д. в цикле, пока не превзошли корня из N.
// Часть из оставшиеся чисел после корня из N могут также быть простыми.
// Таким образом, нужно искать невычеркнутые числа после корня из N и для них также проверять делимость N.

// Ограничимся ста миллионами
#define MAX_VAL 100000000

void main (void)
{
    int max_val;
    cout << "Enter number: ";
    cin >> max_val;
    if (max_val > MAX_VAL || max_val < 2)
    {
        cout << "Wrong limits";
        return;
    };
    // Поиск простых ведем до корня из max_val
    int sqrt_max_val = (int)sqrt((double)max_val);
    // Признаки "вычеркнутости" чисел (элементы 0 и 1 не используются)
    deque<bool> flags (max_val+1, false);  // Массив признаков вычеркнутости чисел.
        // flags означает, вычеркнуто ли i или нет (true - вычеркнуто, false - нет).
        // Первоначально все числа не перечеркнуты
    int current_value = 2;    // Текущее простое число
    do
    {
        // Проверим делимость на текущее простое число
        if (max_val % current_value == 0)
            cout << current_value << endl;
        // Вычеркиваем все числа, кратные current_value, начиная с его квадрата
        for (int i = current_value * current_value; i <= max_val; i += current_value)
            flags = true;
        // Ищем следующее невычеркнутое число
        for (++current_value; current_value <= sqrt_max_val && flags[current_value]; ++current_value) ;
    } while (current_value <= sqrt_max_val);
    // Проверим все невычеркнутые числа больше корня из N
    for (current_value = sqrt_max_val+1; current_value <= max_val; ++current_value)
        if (!flags[current_value] && max_val % current_value == 0)
            cout << current_value << endl;
};

#include <deque>
#include <iostream>
#include <math.h>
#include <windows.h>

using namespace std;

// Алгоритм.
// 1 Этап. Ищем простые числа, не превосходящие корня из N. Начинаем с числа 2.
// Для каждого найденного простого проверяем делимость N на него.
// "Вычеркиваем" числа, кратные текущему простому p (вычеркивание начинаем с p^2 и идем до N).
// Ищем следующее невычеркнутое число - это будет следующее простое число.
// И т. д. в цикле, пока не превзошли корня из N.
// 2 Этап. Часть из оставшиеся чисел после корня из N могут также быть простыми.
// Таким образом, нужно искать невычеркнутые числа после корня из N и для них также проверять делимость N.
//
// При нахождении очередного делителя на обоих этапах можно "уменьшить" N,
// т. е. N = N / p (если p - кратный делитель N, делим до тех пор, пока делится),
// чтобы уменьшить количество простых чисел для дальнейшего рассмотрения.

// Ограничимся ста миллионами
#define MAX_VAL 100000000

void main (void)
{
    int max_val;
    cout << "Enter number: ";
    cin >> max_val;
    if (max_val > MAX_VAL || max_val < 2)
    {
        cout << "Wrong limits";
        return;
    };
    // Поиск простых ведем до корня из max_val
    int sqrt_max_val = (int)sqrt((double)max_val);
    // Признаки "вычеркнутости" чисел (элементы 0 и 1 не используются)
    deque<bool> flags (max_val+1, false);  // Массив признаков вычеркнутости чисел.
    // flags означает, вычеркнуто ли i или нет (true - вычеркнуто, false - нет).
    // Первоначально все числа не перечеркнуты
    int current_value = 2;  // Текущее простое число
    do
    {
        // Проверим делимость на текущее простое число
        if (max_val % current_value == 0)
        {
            cout << current_value << endl;
            do
                max_val /= current_value;
            while (max_val % current_value == 0);
            sqrt_max_val = (int)sqrt((double)max_val);
        }
        // Вычеркиваем все числа, кратные current_value, начиная с его квадрата
        for (int i = current_value * current_value; i <= max_val; i += current_value)
            flags = true;
        // Ищем следующее невычеркнутое число
        for (++current_value; current_value <= sqrt_max_val && flags[current_value]; ++current_value) ;
    } while (current_value <= sqrt_max_val);
    // Проверим все невычеркнутые числа больше корня из N
    for (current_value = sqrt_max_val+1; current_value <= max_val; ++current_value)
        if (!flags[current_value] && max_val % current_value == 0)
        {
            cout << current_value << endl;
            do
                max_val /= current_value;
            while (max_val % current_value == 0);
            sqrt_max_val = (int)sqrt((double)max_val);
        };
};