为什么总是Memory Limit Exceeded...要怎么改?

[zourong0412]

如题，我用了很多种排序方法，最慢的冒泡还有选择排序等等，可为什么还是内存超出限制啊...
我将原题还有我的代码发上了呵呵，各位大仙，谢谢了~
原题：
Judge Info
Memory Limit: 1124KB
Case Time Limit: 10000MS
Time Limit: 10000MS
Judger: Number Only Judger
Description
Sorting is one of the most important algorithm in computer sciences. Please learn it well.

Input
The first line of input contains , the number of test cases. There is only line for each test case. The first number of each test case will indicates how many integer numbers are there for sort from smaller to larger. All numbers are in the range of .

Output
Output one line for every test case. The result of those integer numbers after sorting.

Sample Input
3
3 3 2 1
2 3 2
3 5 4 3
Sample Output
1 2 3
2 3
3 4 5

[zourong0412]

代码如下：
#include <iostream>
using namespace std;


void swap( int*a, int*b )//通过地址交换两个数据
{
int t = *a;
*a = *b;
*b = t;
}

void sort( int* a, int n )//快速排序函数
{
if( n<=2 ){//不超过两个数据就处理完毕
if( n==2 && a[1] < a[0] ) swap(a, a+1);
return;
}
swap( a, a+(n>>1) );//把中间的那个数据交换到最前面
int pivot=*a;//以现在最前面的数据作为分界值
int* l=a+1;//左边第二个数据
int* r=a+n-1;//右边最后一个数据
while( l<r )//把数据分组
{
//小于分界值的留在左边，遇到不小于的停止
while( l<r && *l<pivot ) l++;
//不小于分界值的留在右边，遇到小于的停止
while( r>a && *r>=pivot ) r--;
//交换这两个数据
if( l<r ) swap( l, r );
}
//把分界值交换回中间位置
if( *a > *r ) swap( a, r );
//对左右两组分别递归排序
sort( a, r-a );
sort( r+1, n-1-(r-a) );
}

int a[260000]={0};

int main()
{
int w,i;
cin>>w;
while(w--)
{
int n;
cin>>n;
for(i=0;i<n;i++)
cin>>a[i];
sort(a,n);
for(i=0;i<n;i++)
cout<<a[i]<<" ";
cout<<endl;
}
return 0;
}

[npuhuxl]

int a[260000]={0};会不会是这个太大了。
可以改小点试试，要不然就动态分配

[zourong0412]

[Quote=引用 2 楼 npuhuxl 的回复:]
int a[260000]={0};会不会是这个太大了。
可以改小点试试，要不然就动态分配
[/Quote]

改小了就会编译错误...因为它规定的大小一定要是260000，动态分配的话，也是一样的..

[zourong0412]

[Quote=引用 3 楼 scauscnu 的回复:]
静态变量
[/Quote]

能详细一点么？
是在全局变量前面加？

[logiciel]

以下修改把sort中3个局部变量移到外面,可减少递归调用时的内存使用.LZ可试一下是否可行:

int level = 0;
int pivot;
int* l;
int* r;
void sort( int* a, int n )//快速排序函数
{
  if( n<=2 ){//不超过两个数据就处理完毕
  if( n==2 && a[1] < a[0] ) swap(a, a+1);
  return;
  }
  swap( a, a+(n>>1) );//把中间的那个数据交换到最前面
  pivot=*a;//以现在最前面的数据作为分界值
  l=a+1;//左边第二个数据
  r=a+n-1;//右边最后一个数据
  while( l<r )//把数据分组
  {
  //小于分界值的留在左边，遇到不小于的停止
  while( l<r && *l<pivot ) l++;
  //不小于分界值的留在右边，遇到小于的停止
  while( r>a && *r>=pivot ) r--;
  //交换这两个数据
  if( l<r ) swap( l, r );
  }
  //把分界值交换回中间位置
  if( *a > *r ) swap( a, r );
  //对左右两组分别递归排序
  sort( a, r-a );
  sort( r+1, n-1-(r-a) );
}

[logiciel]

递归调用sort的层次太深时,将占用大量内存.用C写的还是递归调用sort吗?

[luciferisnotsatan]

冒泡是原地排序，空间复杂度是 1 呀
超标的话，是不是你代码超了？

光int a[260000]={0}就1015KB了

[zourong0412]

[Quote=引用 7 楼 logiciel 的回复:]
递归调用sort的层次太深时,将占用大量内存.用C写的还是递归调用sort吗?
[/Quote]

是。。。而且测试的排名居然很前...看来快排的算法真是好啊~

[zourong0412]

[Quote=引用 8 楼 luciferisnotsatan 的回复:]
冒泡是原地排序，空间复杂度是 1 呀
超标的话，是不是你代码超了？

光int a[260000]={0}就1015KB了
[/Quote]

不是，int a[260000]={0}是他要求定义的，不定义这个的话，会出现runtime error.所以说，冒泡空间是小，可是时间大啊。是O(n*n),而快排或者希尔排序只用O(n*lgn)...明显快排要好些...

[zourong0412]

找到改的方法了....用C写就不会出现这个问题了...虽然不知道为什么....并不关全局变量或者是静态变量的事....