Массивы - обработка. С++ .

[Беата]

Вообщем я сделала лабораторную, там было такое условие - упорядочить массив А по возрастанию, а затем расположить так: минимальный, элемент, затем максимальный и так далее.
А теперь надо изменить условие:

чтобы было максимальный, минимальный, максимальный, минимальный

подскажите, как это сделать?



а вот и сам код:

#include "stdafx.h"
#include <iostream> 
#include <cmath> 
using namespace std; 
#define N22 10 


#include "time.h" 
using namespace std; 
void Neumann(int N, int A[]); 
int Prohod(int A[], int B[], int N); 
void Join(int A[], int B[], int *left, int *right, 
int *kl, int *kr, int Step); 

void Join(int A[], int B[], int *left, int *right, 
int *kl, int *kr, int Step){ 
// Выполняется слияние отрезков массива ключей A: 
// левого, начиная с *left и правого, начиная с *right 
// ( по ходу дела *left, *right изменяются) 
// результат слияния помещается в массив B, начиная с 
// *kl или *kr изменяется с шагом Step. Step=1, 
// если результат слияния помещается в b слева направо и 
// Step=-1, если справа налево 
bool l=true,r=true; // признаки того, что участок 
// упорядоченности (left,right) еще не кончился 
int v; 

while(l || r){ 
// найдем v - меньший ключ в сливаемых орезках 
if(l && (!r || A[*left] <= A[*right])){ 
v=A[(*left)++]; 
l=(*left<*right && A[*left] >= A[*left-1]); 
} else { 
v=A[(*right)--]; 
r=(*right>*left && A[*right] >= A[*right+1]); 
} 
if(Step==1){ 
B[(*kl)++]=v; 
} else { 
B[(*kr)--]=v; 
} 
} 
} 

int Prohod(int A[], int B[], int N){ 
// функция выполняет перекачку из области A в область B 
// и возвращает число отрезков упорядоченности в области B 
int left,right,kl,kr; 
int Count,step; 

left=0; right=N-1; kl=0; kr=N-1; step=1;Count=0; 

while(left<right){ 
Join(A,B,&left,&right,&kl,&kr,step); 
if(right==left){ 
B[kl]=A[left]; 
Count++; 
} 
Count++; 
step=-step; 
} 
return Count; 
} 

void Neumann(int N, int A[]){ 
int *B; 
bool flag=false; // если flag=false, то выполняем 
// перекачку из A в B 
int *from,*to; 
B=new int[N]; 
do { 
if(flag){ 
from=B; 
to=A; 
} else { 
from=A; 
to=B; 
} 
flag=!flag; 
} while(Prohod(from,to,N) > 1); 
if(flag){ 
memcpy(A,B,N*sizeof(int)); 
} 
for (int i=0;i<10;i++){ 
cout <<A[i]<<" "; 
} 
delete [] B; 
} 
/*void main(){ 
int *a; 
a=new int[1000]; 
for (int i=0;i<10;i++){ 
a[i]=rand() % 100; 
cout <<a[i]<<" "; 
} 
*/ 

int main() { 
int A[N22], Aclone[N22]; 
double N1 = N22; 
double min1[N22 - int(N22/2)]; 
double max1[int(N22/2)]; 
for (int i = 0; i < N22; i++) { 
cout << "Enter the A[" << i+1 << "] element: "; 
cin >> A[i]; 
} 
double temp; 
/* for (int i = 1; i < N22; i++){ 
for (int j = 0; j < N22-i; j++) { 
if (A[j] > A[j+1]){ 
temp = A[j]; 
A[j] = A[j+1]; 
A[j+1] = temp; 
} 
} 
}*/ 
Neumann(N1, A); 
cout << endl << endl; 
for (int i = 0; i < N22; i++) { 
cout << A[i] <<" "; 
} 
cout << endl; 
if (N22 % 2 == 0) { 
for (int i = 0; i < N22/2; i++) { 
min1[i] = A[i]; 
max1[(N22/2) - 1 - i] = A[i + N22/2]; 
} 
for (int i = 0; i < N22/2; i++) { 
A[2*i] = min1[i]; 
A[2*i + 1] = max1[i]; 
} 
} 
else { 
for (int i = 0; i < (N22-1)/2; i++) { 
min1[i] = A[i]; 
max1[(N22-1)/2 - 1 - i] = A[i + (N22-1)/2 + 1]; 
} 
min1[int(ceil(N1/2)) - 1] = A[int(ceil(N1/2)) - 1]; 
for (int i = 0; i < (N22-1)/2; i++) { 
A[2*i] = min1[i]; 
A[2*i + 1] = max1[i]; 
} 
A[N22-1] = min1[int(ceil(N1/2)) - 1]; 
} 
for (int i = 0; i < N22; i++) { 
cout << A[i] <<" "; 
} 
cout << endl; 

for (int i = 0; i < N22; i++) { 
Aclone[i] = A[i]; 
} 
int min, minnum; 
int B[N22], K[N22]; 
bool Flag[N22]; 
for (int i = 0; i < N22; i++) { 
cout << "enter the K[" << i << "]: "; 
cin >> K[i]; 
Flag[i] = true; 
if (K[i] == 0) Flag[i] = false; 
} 
cout << endl; 
B[0] = 0; 
for (int i = 1; i < N22; i++) { 
if (Flag[B[i-1]] == true) { 
B[i] = K[B[i-1]]; 
Flag[B[i-1]] = false; 
} 
else { 
int j = 0; 
while (Flag[j] == false) { 
j++; 
} 
min = K[j]; 
minnum = j; 
for (int k = 0; k < N22; k++) { 
if ((K[k] < min) && (Flag[k] == true)) { 
min = K[k]; 
minnum = k; 
} 
} 
B[i] = min; 
Flag[minnum] = false; 
} 
} 
for (int i = 0; i < N22; i++) { 
cout << B[i] << " "; 
} 
cout << endl; 
for (int i = 0; i < N22; i++) { 
A[i] = Aclone[B[i]]; 
} 
for (int i = 0; i < N22; i++) { 
cout << A[i] <<" "; 
} 
cout << endl; 
double x, Px = 1; 
double k1, eps; 
int v = 1; 
cout << "enter the X: "; 
cin >> x; 
for (int i = 0; i < N22; i++) { 
k1 = pow(x, i % v); 
cout << "k1 = " << k1 << endl; 
eps = 1; 
if (sqrt((double)i) == ceil(sqrt((double)i))) { 
cout << "i= " << i << endl; 
eps = 0; 
} 
Px *= k1 + eps*A[i]; 
} 
cout << endl; 
cout << "P(x) = " << Px; 
cout << endl; 
return 0; 
}

[Беата]

помогите! кто-нить поможет? Срочно нужна помощь!

[Беата]

очень очень прошу. там просто надо поменять

[RUSt88]

у тебя этот код рабочий?
сама делала?

[Беата]

Сообщение от RUSt88

у тебя этот код рабочий?
сама делала?

код полностью рабочий, делала не сама к сожалению.. с помощью

[iehf]

а чего не использовать какой-нибудь бабл, это будет первая часть задания.
а потом в одном цикле разбить полученный массив по второй части условия?

или может я чего не допонял...

[RUSt88]

упорядочить массив А по возрастанию, а затем расположить так: минимальный, элемент, затем максимальный и так далее.

ну очень простенькое задание, а твой приложенный код - ну эт прям монстр
там максимум 3 процедуры будет - заполнение массива, сортировка и расположение в определенном порядке и ВСЁ

у тебя там чего понаписано, смотреть даже не хочется

А теперь надо изменить условие:
чтобы было максимальный, минимальный, максимальный, минимальный

вот это вообще легко делается - изменением флага на противоположный по сравнению с первым вариантом

[Беата]

Сообщение от iehf

а чего не использовать какой-нибудь бабл, это будет первая часть задания.
а потом в одном цикле разбить полученный массив по второй части условия?

или может я чего не допонял...

просто задача на самом деле из трёх пунктов. мне надо поменять только первый. но я выложила весь готовый код (полной задачи)