Массив: Найти первый максимум в этом массиве, а затем все числа до этого элемента упорядочить по возрастанию, а после — по убыванию.

#include <iostream>
#include <ctime>
#include <cstdlib>
using namespace std;
void Input(int* mas, int n)
{
    for(int i=0;i<n;i++)
        mas[i]=rand()%100;
}
void Show(int* mas, int n)
{
    for(int i=0;i<n;i++)
        cout<<mas[i]<<" ";
    cout<<endl;
}
int Max(int* mas, int n)
{
    int max=mas[0], pos=0;
    for(int i=0;i<n;i++)
        if(mas[i]>max) { max=mas[i]; pos=i; }
    return pos;
}
void Replace(int* mas, int n, int pos)
{
    for(int i=0;i<pos-1;i++)
    {
        for(int j=i+1;j<pos;j++)
        {
            if(mas[i]>mas[j])
            {
                int temp=mas[i];
                mas[i]=mas[j];
                mas[j]=temp;
            }
        }
    }
 
    for(int i=pos;i<n;i++)
    {
        for(int j=i+1;j<n;j++)
        {
            if(mas[i]<mas[j])
            {
                int temp=mas[i];
                mas[i]=mas[j];
                mas[j]=temp;
            }
        }
    }
}
int main()
{
    setlocale(0,"rus");
    int* mas;
    int n,pos;
    cout<<"Введите размер массива: ";cin>>n;
    mas=new int[n];
    srand((unsigned)time(NULL));
    Input(mas,n);
    Show(mas,n);
    pos=Max(mas,n);
    Replace(mas,n,pos);
    Show(mas,n);
    delete[] mas;
    system("pause");
    return 0;
}

#include<iostream>
using namespace std;
void vvodMas (double x[],int n);
int nomMax (double x[],int n);
void SortUbyv (double x[],int n,int k);
void SortVozr (double x[],int n,int k);
void print (double x[],int n);
int main ()
{
 const int n=9;
 double x[n];
 vvodMas (x,n);
 int k=nomMax(x,n);
 SortUbyv (x,n,k);
 SortVozr (x,n,k);
 print (x,n);
 return 0;
}
void vvodMas (double x[],int n)
{
 cout<<" Zadaite "<<n<<" chisel"<<endl;
 for (int i=0;i<n;i++)
 cin>>x[i];
}
void print (double x[],int n)
 {
 cout <<"massiv : ";
 for (int i=0;i<n;i++)
 cout<<x[i]<<" ";
 }
 
int nomMax (double x[],int n)
{
 int k=0;
 double max=x[0];
 for (int i=1;i<n; i++)
 if (x[i]>max)
 {
 max=x[i];
 k=i;
 }
 return k;
 
}
void SortUbyv (double x[],int n,int k)
{ int i;
 double a;
 int m=n;
 bool p;
 do {
 p=false;
 m--;
 for (i=0;i<k;i++)
 if (x[i]>x[i+1])
 {
 a=x[i];
 x[i]=x[i+1];
 x[i+1]=a;
 p=true;
 }
}while (p);
}
void SortVozr (double x[],int n,int k)
{
 int i;
 double a;
 int m=n;
 bool p;
 do {
 p=false;
 m--;
 for (i=k+1;i<n;i++)
 if (x[i+1]>x[i])
 {
 a=x[i];
 x[i]=x[i+1];
 x[i+1]=a;
 p=true;
 }
}while (p);
}

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
 
#define N 20
 
void swap(int& n1, int& n2);
 
void sort(int* pn, int start, int end, bool desc = false)
{
    for (int i = start; i <= end; i++)
    {
        int m = i;
        for (int q = i+1; q <= end; q++)
            m = (!desc) ? ((pn[q] > pn[m]) ? q : m) : 
                ((pn[q] < pn[m]) ? q : m);
 
        swap(pn[i],pn[m]);
    }
}
 
void swap(int& n1, int& n2)
 { int _tn = n1; n1 = n2; n2 = _tn; }
 
int main()
{
    int* A = new int[N];
    for (int x = 0; x < N; x++)
    {
        A[x] = rand() % 9 + 1;
        printf("%d ",A[x]);
    }
 
    int max = 0;
    for (int i = 0; i < N; i++)
        max = (A[i] > A[max]) ? i : max;
 
    printf("\nmax = %d A[max] = %d\n\n",max,A[max]);
 
    int pos = 0; 
    while (A[pos] != A[max]) pos++;
 
    sort(A, 0, pos-1, true);
    sort(A, pos+1, N-1, false);
 
    for (int q = 0; q < N; q++)
        printf("%d ",A[q]);
    printf("\n");
 
    _getch();
 
    return 0;
}

#include <iostream>
 
#include <boost/mpl/vector.hpp>
#include <boost/mpl/max_element.hpp>
#include <boost/mpl/for_each.hpp>
#include <boost/mpl/sort.hpp>
#include <boost/mpl/less.hpp>
#include <boost/mpl/greater.hpp>
#include <boost/mpl/copy.hpp>
#include <boost/mpl/back_inserter.hpp>
 
namespace mpl = boost::mpl;
 
struct PrintSeq {
   template <typename T>
   void operator()(T val) {
      std::cout << val << " ";
   }
};
 
template <typename Seq>
struct MaxElement {
   typedef typename
      mpl::max_element <
         Seq
      >::type type;
};
 
template <typename Seq, typename First, typename Last>
struct GenerateSeq {
   typedef typename
      GenerateSeq <
         typename mpl::push_back <
            Seq,
            mpl::int_<
               mpl::deref <First>::type::value
            >
         >::type,
         typename mpl::next <First>::type,
         Last
      >::type type;
};
 
template <typename Seq, typename Last>
struct GenerateSeq <Seq, Last, Last> {
   typedef Seq type;
};
 
template <typename Seq>
struct ChangeSeq {
   typedef typename
      GenerateSeq <
         mpl::vector <>,
         typename mpl::begin <Seq>::type,
         typename mpl::next <
            typename mpl::max_element <
               Seq
            >::type
         >::type
      >::type v_start;
      
   typedef typename
      GenerateSeq <
         mpl::vector <>,
         typename mpl::next <
            typename mpl::max_element <
               Seq
            >::type
         >::type,
         typename mpl::end <Seq>::type
      >::type v_end;
};
 
template <typename Seq, typename Cmp = mpl::greater <mpl::_1, mpl::_2>>
struct SortSeq {
   typedef typename
      mpl::sort <
         Seq,
         Cmp
      >::type sort_seq;
};
 
template <typename SeqFirst, typename SeqSecond>
struct Concatenate {
   typedef typename
      mpl::copy <
         SeqSecond,
         mpl::back_inserter <
            SeqFirst
         >
      >::type v_concat;
};
 
int main() {
   typedef mpl::vector <
      mpl::int_ <-2>,
      mpl::int_ <10>,
      mpl::int_ <5>,
      mpl::int_ <13>,
      mpl::int_ <-1>,
      mpl::int_ <13>,
      mpl::int_ <2>,
      mpl::int_ <5>,
      mpl::int_ <1>,
      mpl::int_ <11>
   > v_numbers;
   
   mpl::for_each <
      Concatenate <
         SortSeq <
            ChangeSeq <
               v_numbers
            >::v_start,
            mpl::less <mpl::_1, mpl::_2>
         >::sort_seq,
         SortSeq <
            ChangeSeq <
               v_numbers
            >::v_end,
            mpl::greater <mpl::_1, mpl::_2>
         >::sort_seq
      >::v_concat
   >(PrintSeq());    
}

#include <iostream>
#include <algorithm>
#include <vector>
 
int main()
{
    std::vector <int> vec = {8, 22, 11, 7, 8, 3, 25, 14, 3, 9, 11, 19, 1};
    std::sort(vec.begin(), std::max_element(vec.begin(), vec.end()), std::less <int> ());
    std::sort(std::max_element(vec.begin(), vec.end()), vec.end(), std::greater <int> ());
    for(auto &i: vec)
        std::cout<<i<<" ";
    return 0;
}