一道数组匹配笔试题

[南气子水]

有两个等长数组A，B，所含元素相同，但顺序不同，只能取得A数组某值和B数组某值进行比较，比较结果大于、小于或等于，但是不能取得同一个数组A或B中的两个数进行比较，也不能取得某数组中的某个值。写一个算法实现正确的匹配（即A数组中某值与B数组中某值相等）。

#include <iostream>
#include <cmath>
using namespace std;
int** matching(int *a, int *b, int len);


int main()
{
	int a[10]={1,2,3,4,5,6,7,8,9,10};
	int b[10]={10,6,4,5,1,8,7,9,3,2};
	int i=0;
	int len=sizeof(a)/sizeof(int);
	int **result = matching(a,b,len);
	for(i;i<len;i++)
	{
		cout<<result[i][0]<<' '<<result[i][1]<<endl;
	}
	i=0;
	while(i<len)
	{
		delete [] result[i];
		result[i] =NULL;	
		i++;
	}
	delete [] result;
	result = NULL;
	return 0;
}
int** matching(int *a, int *b, int len)
{	
	int **result = new int* [len];	
	int k=0;
	for(int i=0;i<len;i++)
	{
		for(int j=0;j<len;j++)
		{
			if (a[i]==b[j])
			{
				result[k] = new int [2];
				result[k][0]=i;
				result[k][1]=j;
			}
			
		}
		k++;
	}
	return result;
}

上述代码存在有错吗？存在内存泄露问题吗？

[南气子水]

#pragma once //保证头文件被编译一次
//定义函数结果状态代码  
#define TRUE        1  
#define FALSE       0  
#define OK          1  
#define ERROR       0  
#define OVERFLOW    -1  
#define UNDERFLOW   -2  
 
//定义函数返回值类型  
typedef int  Status;  
//定义链式栈的数据元素的类型  
typedef int  ElemType;
   
//定义链式栈的存储结构  
struct LNode{
 ElemType data;  //数据域
 struct LNode *next;    //指针域
};

struct LStack{  
    struct LNode    *top;       //栈顶指针   
};

//声明链式栈的基本操作  
Status  InitStack(LStack &s);  
Status  DestroyStack(LStack &s);   
Status  StackEmpty(LStack s);  
Status  StackLength(LStack s);  
Status  Push(LStack &s,ElemType e);  
Status  Pop(LStack &s,ElemType &e);  
Status  GetTop(LStack s,ElemType &e);  
Status  StackTraverse(LStack s);
（二）该源文件实现了头文件声明的函数（linkStack.cpp）

#include"linkStack.h"
#include<iostream>
using namespace std;
Status  InitStack(LStack &s)
//操作结果：构造一个空栈S
{
   struct LNode *p;
   p=(LNode *)malloc(sizeof(LNode));
   if(!p){
        cout<<"严重错误：链式栈初始分配头节点失败，程序退出";  
        exit(ERROR); 
   }
   s.top=p;
   p->next=NULL;
   return OK; 
 } 
 
Status  DestroyStack(LStack &s)  
 //初始条件：栈s已存在  
 //操作结果：栈s被销毁  
{  
    struct LNode *p;
    p=s.top;
    while(p){
        s.top=p->next;
        free(p);
        p=s.top;
    }    
    return OK;  
} 
 
Status  StackEmpty(LStack s)
//初始条件：栈s已存在  
//操作结果：若栈s为空栈，则返回TRUE，否则FALSE 
{
   if(s.top->next==NULL) return TRUE;
   return FALSE;
 }
 
Status  StackLength(LStack s)
//初始条件：栈s已存在  
//操作结果：返回s的元素个数，即栈的长度
{
   int length=0;
   struct LNode *p;
   p=s.top;
   while(p->next){
   length++;
   p=p->next;
   }
   return length;
} 
 
Status Push(LStack &s,ElemType e)
//初始条件：栈s已存在  
//操作结果：插入元素e成为新的栈顶元素
{  
   struct LNode *p;
   p=(LNode *)malloc(sizeof(LNode));
   if(!p)exit(OVERFLOW);
   s.top->data=e;
   p->next=s.top;
   s.top=p;
   return OK;
}   
   
   
Status  Pop(LStack &s,ElemType &e)
 //初始条件：栈s已存在且非空  
 //操作结果：删除s的栈顶元素，并且用e返回其值 
{
    struct LNode *p;
    if(!(s.top->next))exit(UNDERFLOW);
    p=s.top;
    s.top=p->next;
    e=s.top->data;
    free(p);
    return OK; 
}

Status  GetTop(LStack s,ElemType &e)
 //初始条件：栈s已存在且非空  
//操作结果：用e返回s的栈顶元素 
{
     if(!(s.top->next))exit(ERROR);
     s.top=s.top->next;
     e=s.top->data;
     return OK;
} 
 
Status  StackTraverse(LStack s)
//从栈顶开始依次输出
{
     struct LNode *p;
     if(!(s.top->next))exit(ERROR);
     p=s.top;
     while(p->next){
     p=p->next;
     cout<<p->data<<endl;
     }
     return OK;
}
（三）该源文件为测试程序（demo.cpp）
#include"linkStack.h"
#include<iostream>
using namespace std;
int main(){
 int e;
 struct LStack s;
 InitStack(s);
 Push(s,4);
 GetTop(s,e);
 cout<<e<<endl;
 Push(s,5);
 Push(s,6);
 Push(s,7);
 Push(s,8);
 Push(s,9);
 GetTop(s,e);
 cout<<e<<endl;
 cout<<StackLength(s)<<endl;
 Pop(s,e);
 Pop(s,e);
 Pop(s,e);
 Pop(s,e);
 cout<<StackEmpty(s)<<endl;
 StackTraverse(s);
 
}

[ryfdizuo]

matching函数中result指针数组做个初始化，函数外面释放result[i]的时候判空一下，不为空则delete[]。