Сортировка массива в с++

int tmp;
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N-1; j++)
        {
            if (mass[i] < 0 && mass[i] < mass[j]) {
                    tmp = mass[i];
                    mass[i] = mass[j];
                    mass[j] = tmp;

            }
            else
            {
                if (mass[i] > 0) {
                    if (mass[i] < mass[j])
                {
                    tmp = mass[i];
                    mass[i] = mass[j];
                    mass[j] = tmp;
                }
                }
            }
        }
    }
    for (int i = 0; i < N; i++)
        cout << mass[i] << endl;

Пример:

#include <iostream>
#include <string>
void sort(int *arr, size_t arr_len)
{
    for (auto i = 0U; i < arr_len; ++i)
    {
        for (auto j = i + 1; j < arr_len; ++j)
        {
            if (arr[i] > 0 && arr[j] > 0) continue;
            if (arr[i] < arr[j]) std::swap(arr[i], arr[j]);
        }
    }
}
void print_array(int *arr, size_t n) 
{
    for (auto i = 0U; i < n; ++i)
        std::cout << arr[i] << " ";
    std::cout << '\n';
}
int main() 
{
    int arr[] = { -2, -3, 10, -10, 4, -5, -1, 6, -2, -4, 7, 8, 2, -8 };
    const auto arr_len = sizeof(arr) / sizeof(*arr);
    print_array(arr, arr_len);
    sort(arr, arr_len);
    print_array(arr, arr_len);
    return 0;
}

Пример на wandbox.org

Могу предложить для данного случая сортировку методом выборки. То есть среди отрицательных элементов ищется максимальный элемент и ставится в позицию первого отрицательного элемента. Затем алгоритм продолжается, но уже для второго отрицательного элемента, то есть из оставшихся отрицательных элементов находится максимальный и ставится в позицию второго отрицательного элемента и т.д.

#include <iostream>
#include <utility>
void sort_negative_values( int a[], size_t n )
{
    for ( size_t i = 0, next_i; i < n; i = next_i )
    {
        next_i = n;
        while ( not ( a[i] < 0 ) ) i++;
        if ( i != n )
        {
            size_t max = i;
            for ( size_t j = i + 1; j < n; j++ )
            {
                if ( a[j] < 0 )
                {
                    if ( next_i == n ) next_i = j;
                    if (  a[max] < a[j] )
                    {
                        max = j;
                    }
                }                   
            }
            if ( max != i ) std::swap( a[max], a[i] );  
        }
    }
}
int main() 
{
    int a[] = { -9, 0, -7, 2, -5, 4, -3, 2, -1, 8 };
    const size_t N = sizeof( a ) / sizeof( *a );
    for ( int x : a ) std::cout << x << ' ';
    std::cout << '\n';
    sort_negative_values( a, N );
    for ( int x : a ) std::cout << x << ' ';
    std::cout << '\n';
    return 0;
}

Вывод программы на консоль:

-9 0 -7 2 -5 4 -3 2 -1 8 
-1 0 -3 2 -5 4 -7 2 -9 8 

Если вам не разрешается использовать стандартную функцию std::swap, то данное предложение

if ( max != i ) std::swap( a[max], a[i] );

вы можете заменить на следующее if-предложение

if ( max != i ) 
{
    int tmp = a[max];
    a[max] = a[i];
    a[i] = tmp;
}

https://ideone.com/987vUj

#include <iostream>
#include <algorithm>
using namespace std;
int main()
{
  int a[] = {-5, 0, 3, -7, 1, -6 };
  const int n = sizeof a / sizeof *a;
  sort(a, a+n, [](const int &x, const int &y) { return x<y ? y>=0 : x<0 && -x<-y; });
  for (int x : a) cout << x << ' ';
  return 0;
}

int n;
cin >> n;
int mass[N];
for (int i = 0; i < n; i++)
{
    cin >> mass[i];
}
int tmp;
for (int i = 0; i < n; i++) //сортировка пузырьком. У вас какой то странный алгоритм
{
    for (int j = 0; j < n - 1; j++)
    {
        if (needswap(mass[j], mass[j + 1]))//если нужно поменять местами меняем.
        {
            tmp = mass[j + 1];
            mass[j + 1] = mass[j];
            mass[j] = tmp;
        }
    }
}
for (int i = 0; i < n ;i++)
    cout << mass[i] << endl;

Ну а теперь сама функция needswap:

bool needswap(int a, int b)
{
    if (a < 0 && b<0)//ясно что делать если оба числа отрицательные
    {
        return a < b;
    }
    return b < a;
}