Цикл в цикле (for()).

for ( i=0; i<N; i++ )
    {
        for (z=0;z<N;z++)
        {
         ... Выполняю своё действие.
        }   
    }

#include "stdafx.h"
#include "stdio.h"
#include "iostream"
 
using namespace std;
 
int _tmain()
{
    int i;      /* Переменная для циклов         */
    int z = 0;
    int az=-1;
    double max = 0; /* Максимальный элемент массива       */
    double min = 0; /* Минимальный элемент массива     */
    int N;          /* Количество элементов в массиве    */
    int M;          /* Количество "ящиков"              */
    double S[40];       /* Отсортированный массив          */
    double A[] =    /* Определяем массив                */
    {
        3,1,2
    };
 
    /* 1. Определяем колличество элементов в массиве. */
    N = sizeof(A) / sizeof(A[0]);
 
    /* 2. Определяем максимальный и минимальный элемент этого массива. */
    for ( i=0; i<N; i++ )
    {
    if ( A[i] > max )
    max = A[i];
    if ( A[i] < min )
    min = A[i];
    }
 
    /* 3. Определяем количество "ящиков"! */
    M = max / 2 + 1;
 
    /* 4. "Раскидываем" элементы по "ящикам" отсортированного массива. */
    for ( i=0; i<N; i++ )
    {
        for (z=0;z<N;z++)
        {
            int zs=z+2;
            if ( A[z]<zs && A[z]>z)
            {
            az=az+1;
            S[az]=A[z];
            cout << "If " << A[z] << " < " << zs << " and " << A[z] << " > " << z << endl;
            cout << "ITS: " << z << "     " << A[z] << " going into S" << az << endl;
            cout << z << endl << endl;
            A[z]=0;
            }
        }   
    }
 
    /* 4. Выводим на печать уже отсортированный массив. */
    for ( i=0; i<N; i++ )
    {
    cout << S[i] << " ";
    }
 
    cin.get();
    return 0;
}

double A[] = { 3, 1, 2 };
N = sizeof(A) / sizeof(A[0]);

double A[] =    /* Определяем массив                */
    {
        14.2594,        7.6226,         8.1113,         23.7865,
        20.1796,        27.3322,        10.2708,        30.1469,
        11.0851,        24.4584,        20.0111,        27.8091,
        1.4991,         31.7734,        0.0454,         5.3713,
        31.1648,        29.7484,        29.4232,        -2.8434,
        6.6163,         22.2269,        10.5985,        0.6183,
        19.8660,        -1.7290,        19.3626,        33.6190,
        20.4391,        15.6690,        8.3869,         19.8722,
        15.8876,        9.4932,         8.0816,         10.4655,
        0.3828,         6.9225,         26.5060,        15.4990
    };

for ( i=0; i<N; i++ )
        {
                for (z=0;z<N;z++)
                {
                 ... Выполняю своё действие.
                }       
        }

#include <iostream>
#include <vector>
using std::vector;
using std::cout;
using std::cin;
using std::endl;
int main(){
    double *a,max,min,h,t1;
    int n,i,m,j,tmp,l,tmp2;
    vector<double> *v;
    n=40; m=5;
    
    a=new double[n];
    v=new vector<double>[m];
    for(i=0;i<n;i++)
        a[i]=i+0.5;
 
    for(i=0;i<n;i++)
        cout<<a[i]<<endl;
    cout<<"------------------------------\n";
 
    min=max=a[0];
    for(i=1;i<n;i++){
        if(a[i]>max)
            max=a[i];
        if(a[i]<min)
            min=a[i];
    }
 
    h=(max-min)/m+1;
    for(i=0;i<n;i++)
        v[int((-a[i]+max)/h)].push_back(a[i]);
 
    for(i=0;i<m;i++)
        for(j=0,tmp=v[i].size();j<tmp;j++){
            for(l=j+1,tmp2=j;l<tmp;l++)
                if(v[i][l]>v[i][tmp2])
                    tmp2=l;
            t1=v[i][j];
            v[i][j]=v[i][tmp2];
            v[i][tmp2]=t1;
        }
    for(i=0,l=0;i<m;i++)
        for(j=0,tmp=v[i].size();j<tmp;j++,l++)
            a[l]=v[i][j];
 
    for(i=0;i<n;i++)
        cout<<a[i]<<endl;
 
    system("pause");
    return 0;
}

#include "stdio.h"
#include "iostream"
#include "math.h"
using namespace std;
 
int main()
{
        int     i;              /* Переменная для циклов                        */
        int z, az, temp;
        double max = 0; /* Максимальный элемент массива         */
        double min = 0; /* Минимальный элемент массива          */
        int N;                  /* Количество элементов в массиве       */
        int M=10;                /* Количество "ящиков"  */
        int H;                  /* Размер ящика                               */
        double S[40];           /* Отсортированный массив                       */
        int K[40];              /* Массив для хранения номеров ящиков        */
        double A[] =    /* Определяем массив                            */
        {
                14.2594,                7.6226,                 8.1113,                 23.7865,
                20.1796,                27.3322,                10.2708,                30.1469,
                11.0851,                24.4584,                20.0111,                27.8091,
                1.4991,                 31.7734,                0.0454,                 5.3713,
                31.1648,                29.7484,                29.4232,                -2.8434,
                6.6163,                 22.2269,                10.5985,                0.6183,
                19.8660,                -1.7290,                19.3626,                33.6190,
                20.4391,                15.6690,                8.3869,                 19.8722,
                15.8876,                9.4932,                 8.0816,                 10.4655,
                0.3828,                 6.9225,                 26.5060,                15.4990
        };
 
        /* 1. Определяем колличество элементов в массиве. */
        N = sizeof(A) / sizeof(A[0]);
 
        /* 2. Определяем максимальный и минимальный элемент этого массива. */
        max=min=A[0];
        for ( i=0; i<N; i++ )
        {
        if ( A[i] > max )
        max = A[i];
        if ( A[i] < min )
        min = A[i];
        }
 
        /* 3. Определяем размер "ящиков"! */
        H = (fabs(max-min)) /M;
 
        /* 4. "Раскидываем" элементы по "ящикам". */
        for ( i=0; i<N; i++ )
        {
            K[i]=(fabs(max-A[i]))/(H+1);
        }
        /* 5. Сортируем элементы в ящиках и заносим отсортируемые элементы в массив S[]. */
        S[0]=min;
        for ( i=0; i<N; i++ )
        {
            if(A[i]==min)
                K[i]=-1;       
        }
        for ( i=M-1, az=1; i>0, az<N-1; i--)
        {   
            min=max;
            int y=1;
            while(y==1)
            {
            y=0;
            min=max;
            for (z=0;z<N;z++)
            {
                if(K[z]==i && A[z]<min && A[z]>=S[az-1])
                {
                    min=A[z];
                    y=1;
                    S[az]=min;
                    temp=z;                 
                }
                if(z==N-1 && y==1)
                {
                    az++;
                    K[temp]=-1;             
                }
            }
            }
        }
        S[N-1]=max;
        /* 4. Выводим на печать уже отсортированный массив. */
        for ( i=0; i<N; i++ )
        {
        cout << S[i] << " ";
        } 
        cin.get();
        return 0;
}

        h=(max-min)/m+1;
        for(i=0;i<n;i++)
                v[int((-a[i]+max)/h)].push_back(a[i]);