VISUAL C++ 2010 EXPRESS После установки она сразу в рабочем состоянии, но следует активировать её, зарегестрировавшись в системе Live ID
Другие бесплатные среды(IDE) для программирования на С/С++
Код[+]
#include<stdio.h>
#include<stdlib.h>
void printArray(double* arr, const unsigned len)
{//Вывод массива. Отличный пример самого простого перебора элементов массива.
for(int i = 0; i != len; ++i)
{
printf("%lf\n",arr[i]);
}
}
double* maximum(double* arr, const unsigned len)
{//Поиск максимума.
double* ret = arr;//Пусть, для начала максимальным элементом будет нулевой
for(int i = 1; i != len; ++i)//Далее перебрать остальные элементы
{//Если текущий элемент больше возвращаемого, назначить возвращаемый текущим, иначе ничего не делать
ret = arr[i] > *ret ? arr + i : ret;
}
return ret;
}
void swap (double* a, double* b)
{//Поменять местами два элемента.
double cnt = *a;//Значение из области памяти a записать временную переменную cnt
*a = *b;//Переписать значение по адресу b в память по адресу a
*b = cnt;//Записать значение из временной переменной в память по адресу b.
}
/*
1. Найти максимум
2. Поменять его с первым
3. повторить 1 и 2 для элементов кроме максимального
*/
void sort(double* arr, const unsigned len)
{
int i = 0;
while ( len - i > 1 )//Пока в неотсортированной части осталось больше одного элемента
{
double* max = maximum(arr + i,len - i);//Получаем указатель на максимальный элемент
swap(arr + i, max);//Меняем его с первым
++i;//Двигаемся дальше
}
}
void main()
{
const unsigned sizeOfArray = 5;
double* arrayOfNumbers = new double[sizeOfArray];//Выделить память под массив
for(int i = 0; i != sizeOfArray; ++i)
{
arrayOfNumbers[i] = (double) rand() / ( 1 + rand() ) * ( ( rand() % 2 ) ? -1 : 1 );
}
printArray(arrayOfNumbers, sizeOfArray);
sort(arrayOfNumbers, sizeOfArray);
printf("Otsortirovani massiv:\n");
printArray(arrayOfNumbers, sizeOfArray);
delete[] arrayOfNumbers;//Освобождаем память.
}
Скачать видео
Код[+]
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
void printArray(double* arr, const unsigned len)
{//Вывод массива. Отличный пример самого простого перебора элементов массива.
for(int i = 0; i != len; ++i)
{
printf("%lf\n",arr[i]);
}
}
double* maximum(double* arr, const unsigned len)
{//Поиск максимума.
double* ret = arr;//Пусть, для начала максимальным элементом будет нулевой
for(int i = 1; i != len; ++i)//Далее перебрать остальные элементы
{//Если текущий элемент больше возвращаемого, назначить возвращаемый текущим, иначе ничего не делать
ret = arr[i] > *ret ? arr + i : ret;
}
return ret;
}
void swap (double* a, double* b)
{//Поменять местами два элемента.
double cnt = *a;//Значение из области памяти a записать временную переменную cnt
*a = *b;//Переписать значение по адресу b в память по адресу a
*b = cnt;//Записать значение из временной переменной в память по адресу b.
}
/*
1. Найти максимум
2. Поменять его с первым
3. повторить 1 и 2 для элементов кроме максимального
*/
void sort(double* arr, unsigned len)
{
swap(arr, maximum(arr,len));//Поменять текущий элемент с максимальным
if(--len)//Уменьшить длинну на 1, и если она не стала нулевой
sort(++arr, len);//Выполнить то же, для массива без первого элемента
}
void main()
{
srand( time(0) );//Инициализация генератора случайных чисел
const unsigned sizeOfArray = 5;
double* arrayOfNumbers = new double[sizeOfArray];//Выделить память под массив
for(int i = 0; i != sizeOfArray; ++i)
{
arrayOfNumbers[i] = (double) rand() / ( 1 + rand() ) * ( ( rand() % 2 ) ? -1 : 1 );
}
printArray(arrayOfNumbers, sizeOfArray);
sort(arrayOfNumbers, sizeOfArray);
printf("Otsortirovani massiv:\n");
printArray(arrayOfNumbers, sizeOfArray);
delete[] arrayOfNumbers;//Освобождаем память.
}Задачка[+]
/*
Дан массив чисел и число s. Нужно определить, можно ли использовав все числа из массива ровно один раз получить число s.
например:
массив: { 2, 7,-32, 11, 0, -2 }, s = -46 => 2-7-32-11+0+2 = -46
массив: { -4, 77,-14, 12, 43, 98 }, s = 20 => -4+77+14-12+43-98 = 20;
массив: { 3, 56, 21 }, s = 56 => No solution;
*/ Скачать видео
Код[+]
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
struct Array
{//Структура объединяющая переменные, необходимые для работы с массивом
double* pointer;//Указатель на нулевой элемент
unsigned size;//Колличество элементов
};
void printArray(Array arr)
{
for(int i = 0; i != arr.size; ++i)
{
printf("%lf\n",arr.pointer[i]);
}
}
double* maximum(Array arr)
{
double* ret = arr.pointer;
for(int i = 1; i != arr.size; ++i)
{
ret = arr.pointer[i] > *ret ? arr.pointer + i : ret;
}
return ret;
}
void swap (double* a, double* b)
{
double cnt = *a;
*a = *b;
*b = cnt;
}
/*
1. Найти максимум
2. Поменять его с первым
3. повторить 1 и 2 для элементов кроме максимального
*/
void sort(Array arr)
{
swap(arr.pointer, maximum(arr));
++arr.pointer;
if(--arr.size)
sort(arr);
}
void main()
{
srand( time(0) );
Array arrayOfNumbers;
arrayOfNumbers.size = 5;
arrayOfNumbers.pointer = new double[arrayOfNumbers.size];
for(int i = 0; i != arrayOfNumbers.size; ++i)
{
arrayOfNumbers.pointer[i] = (double) rand() / ( 1 + rand() ) * ( ( rand() % 2 ) ? -1 : 1 );
}
printArray(arrayOfNumbers);
sort(arrayOfNumbers);
printf("Otsortirovani massiv:\n");
printArray(arrayOfNumbers);
delete[] arrayOfNumbers.pointer;
} Скачать видео
Код[+]
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
class Array
{
double* pointer;
unsigned size;
double* maximum ()
{//Поиск максимума ничего не получает - он работает с данными экземпляра, для которого вызван.
double* ret = pointer;
for(int i = 1; i != size; ++i)
{
ret = pointer[i] > *ret ? pointer + i : ret;
}
return ret;
}
void swap (double* a, double* b)
{//Старая добрая свапалка
double cnt = *a;
*a = *b;
*b = cnt;
}
void sort(Array arr)
{//Сортировочка. Не работает с элементами класса, всё что она меняет - копии этих элементов
swap(arr.pointer, arr.maximum());
++arr.pointer;
if(--arr.size)
sort(arr);
arr.pointer = 0;/*Переставив указатель на ноль, отключим очистку памяти при вызове деструктора
для копии класса*/
}
public:
void printArray()
{//Функция вывода массива
for(int i = 0; i != size; ++i)
{
printf("%lf\n", pointer[i]);
}
}
void random()
{
for(int i = 0; i != size; ++i)
{
pointer[i] = (double) rand() / ( 1 + rand() ) * ( ( rand() % 2 ) ? -1 : 1 );
}
}
void sort()
{//Вызывает приватную функцию sort, передавая в качестве аргумента (копируя таким образом) объект для которого вызвана sort()
sort(*this);
}
Array(unsigned Size):
size(Size),
pointer(new double [Size])
{//Создаёт объект. Заполняет его случайными числами
random();
}
Array()://Конструктор по умолчанию. Предусмотрительно реализован, но не используется.
size(0),
pointer(0)
{ }
~Array()
{//Деструктор. Освобождает память выделенную под массив.
delete[] pointer;
}
};
void main()
{
srand( time(0) );
Array arrayOfNumbers(8);//Создаём массив с восьмью случайными элементами.
arrayOfNumbers.printArray();
arrayOfNumbers.sort();
printf("Otsortirovani massiv:\n");
arrayOfNumbers.printArray();
} Скачать видео
Код[+]
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<iostream>
class Array
{
double* pointer;
unsigned size;
double* maximum ()
{//Поиск максимума ничего не получает - он работает с данными экземпляра, для которого вызван.
double* ret = pointer;
for(int i = 1; i != size; ++i)
{
ret = pointer[i] > *ret ? pointer + i : ret;
}
return ret;
}
void swap (double* a, double* b)
{//Старая добрая свапалка
double cnt = *a;
*a = *b;
*b = cnt;
}
void sort(Array arr)
{//Сортировочка. Не работает с элементами класса, всё что она меняет - копии этих элементов
swap(arr.pointer, arr.maximum());
++arr.pointer;
if(--arr.size)
sort(arr);
arr.pointer = 0;/*Переставив указатель на ноль, отключим очистку памяти при вызове деструктора
для копии класса*/
}
public:
void printArray()
{
for(double* it = pointer, * end = it + size; it != end; ++it)
{
std::cout << *it << std::endl;
}
}
void random()
{//Функция вывода массива
for(int i = 0; i != size; ++i)
{
pointer[i] = (double) rand() / ( 1 + rand() ) * ( ( rand() % 2 ) ? -1 : 1 );
}
}
void sort()
{//Вызывает приватную функцию sort, передавая в качестве аргумента (копируя таким образом) объект для которого вызвана sort()
sort(*this);
}
Array(unsigned Size):
size(Size),
pointer(new double [Size])
{//Создаёт объект. Заполняет его случайными числами
random();
}
Array()://Конструктор по умолчанию. Предусмотрительно реализован, но не используется.
size(0),
pointer(0)
{ }
~Array()
{//Деструктор. Освобождает память выделенную под массив.
delete[] pointer;
}
double& operator[](unsigned n)
{//Перегрузка оператора []
return pointer[n];
}
/*Объявление прототипа дружественной перегрузки оператора.
Необходимо для обеспечения доступа к приватным членам класса
из тела функции.*/
friend std::ostream& operator << (std::ostream& out, const Array& arr);
};
std::ostream& operator << (std::ostream& out, const Array& arr)
{//Перегрузка оператора << для потока вывода и класса Array
for(double* it = arr.pointer, * end = it + arr.size; it != end; ++it)
{//Передать потоку все элементы массива.
out << *it << std::endl;
}
return out;
/*
Обращу вниманеие, что такая перегрузка определяет формат вывода в любой поток, не только
поток вывода в консоль (cout).
*/
}
void main()
{
srand( time(0) );
Array arrayOfNumbers(8);//Создаём массив с восьмью случайными элементами.
arrayOfNumbers[5] = 56.7;//Присвоение значения 5-му элементу массива
arrayOfNumbers.printArray();//Старый формат вывода тоже работает
arrayOfNumbers.sort();
std::cout << "Otsortirovani massiv:\n" << arrayOfNumbers << "Spasibo";
//Вывод отсортированного массива с использованием определённого нами оператора <<.
} Скачать видео
Код[+]
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<iostream>
#include<cmath>
/*
Мы намерены использовать этот класс для хранения в контейнере Array, и применить к нему алгоритм сортировки.
Для этого мы должны определить то, как выполнять копирование данных нашего класса, как сравнивать между собой
элементы такого класса и как выводить данные класса в поток.
*/
class Vector
{
double x, y;
public:
Vector(void) { }
Vector(const Vector& op)
{
*this = op;
}
Vector(double X, double Y) : x(X), y(Y) { }
~Vector(void) { }
/*Стоит ли здесь использовать inline?*/
inline void operator = (const Vector& op)
{
x = op.x;
y = op.y;
}
inline const bool operator > (const Vector& op) { return sqrt( x * x + y * y ) > sqrt( op.x * op.x + op.y * op.y); }
friend std::ostream& operator << (std::ostream&, const Vector&);
};
std::ostream& operator << (std::ostream& ou, const Vector& op)
{
ou << '[' << op.x << ',' << op.y << ']';
return ou;
}
//Шаблонный класс, принимающий в качестве параметра тип (T) хранимых в нём данных
template < typename T >
class Array
{
T* pointer;//Все переменные, бывшие double, стали T. Больше НИЧЕГО в классе не поменялось.
unsigned size;
T* maximum ()
{
T* ret = pointer;
for(int i = 1; i != size; ++i)
{
ret = pointer[i] > *ret ? pointer + i : ret;
}
return ret;
}
void swap (T* a, T* b)
{
T cnt = *a;
*a = *b;
*b = cnt;
}
void sort(Array arr)
{
swap(arr.pointer, arr.maximum());
++arr.pointer;
if(--arr.size)
sort(arr);
arr.pointer = 0;
}
public:
void printArray()
{
for(T* it = pointer, * end = it + size; it != end; ++it)
{
std::cout << *it << std::endl;
}
}
void sort()
{
sort(*this);
}
Array(unsigned Size):
size(Size),
pointer(new T [Size])
{
}
Array():
size(0),
pointer(0)
{ }
~Array()
{
delete[] pointer;
}
T& operator[](unsigned n)
{
return pointer[n];
}
inline unsigned sizeOfArray() { return size; }
};
//При объявлении внешней функции необходимо так же указывать соответствующий тип данных принятых в векторе.
void random(Array<Vector>& arr)
{
for(int i = 0; i != arr.sizeOfArray(); ++i)
{
arr[i] = Vector(rand(),rand());
}
}
void main()
{
srand( time(0) );
//Теперь нужно указывать, для какого типа мы создаём экземпляр класса.
Array<Vector> arrayOfNumbers(8);
random(arrayOfNumbers);
arrayOfNumbers.printArray();
arrayOfNumbers.sort();
std::cout << "Otsortirovani massiv:\n";
arrayOfNumbers.printArray();
} Скачать проект Скачать видео
Код[+]
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <vector>
#include <cmath>
class Vector
{
double x, y;
public:
Vector(void) { }
Vector(const Vector& op)
{
*this = op;
}
Vector(double X, double Y) : x(X), y(Y) { }
Vector(double num) : x( static_cast<int> (num) ), y( ( num - x ) * 10 ) { }
~Vector(void) { }
inline void operator = (const Vector& op)
{
x = op.x;
y = op.y;
}
inline const bool operator > (const Vector& op) { return sqrt( x * x + y * y ) > sqrt( op.x * op.x + op.y * op.y); }
inline const bool operator < (const Vector& op) { return sqrt( x * x + y * y ) < sqrt( op.x * op.x + op.y * op.y); }
friend std::ostream& operator << (std::ostream&, const Vector&);
};
std::ostream& operator << (std::ostream& ou, const Vector& op)
{
ou << '[' << op.x << ',' << op.y << ']';
return ou;
}
//При объявлении внешней функции необходимо так же указывать соответствующий тип данных принятых в векторе.
template <typename T> void random(std::vector<T>& arr, unsigned size)
{
arr.resize(0);
arr.reserve(size);
for (unsigned i = 0; i != size; ++i)
{
arr.push_back( rand() / 32767. * 20 - 10 );
}
}
template <typename T> std::ostream& operator << (std::ostream& out, const std::vector<T>& arr)
{
for (std::vector<T>::const_iterator it = arr.begin(), end = arr.end(); it != end; ++it)
{
out << *it << std::endl;
}
return out;
}
template <typename T> void sort (T* a, long long N)
{
long long i = 0;
long long j = N;
const T p = a[ N >> 1 ];
T temp;
do
{
while ( a[i] < p )
{
++i;
}
while ( a[j] > p )
{
--j;
}
if ( i <= j )
{
temp = a[i];
a[i] = a[j];
a[j] = temp;
++i;
--j;
}
}
while ( i <= j );
if ( j > 0 )
{
sort( a, j );
}
if ( N > i )
{
sort( a + i, N - i);
}
}
template <typename T> inline void sort (std::vector<T>& v)
{
sort( &v[0], v.size() - 1);
}
void main()
{
srand( static_cast<unsigned int>( time(0) ) );
//Теперь нужно указывать, для какого типа мы создаём экземпляр класса.
std::vector<Vector> arrayOfNumbers;
random(arrayOfNumbers, 23);
std::cout << arrayOfNumbers;
sort(arrayOfNumbers);
std::cout << "Otsortirovani massiv:\n" << arrayOfNumbers;
} Скачать проект Скачать видео 
Сортировка Хоара