求两无序不重复数组的交集

求两无序不重复数组的交集


//输入:a[]={5,7,8,9,1,2,3 }; b[]={2, 8,10,4,6,7};

//输出:{2,7,8}


[思路1]:

判断a数组元素值的元素是否在b中,是则输出之。

时间复杂度:O(n2)

void  cmpInterSection(int a[], int b[], int m, int n)
{
	for(int i = 0; i < m; i++)
	{
		for(int j = 0;j < n; j++)
		{
			if(a[i] == b[j])
			{
				cout << a[i] << "\t";
				break;
			}
		}//end for j
	}//end for i
	cout << endl;
}

[思路2]:

1)对两数组进行排序;

2)一次循环判断a和b中元素是否相等,相等则输出;不等则小的值++。

时间复杂度:O(nlogn)

//快排之分割
int divided(int nArr[], int nLeft, int nRight)
{
	int pivot = nArr[nLeft];
	
	while(nLeft < nRight) //×¢ÒâwhileÑ­»•
	{
		while(nLeft < nRight && nArr[nRight] >= pivot)  //×¢ÒâµÈºÅ
		{
			--nRight;
		}
		nArr[nLeft] = nArr[nRight];
		while(nLeft < nRight && nArr[nLeft] <= pivot)   //×¢ÒâµÈºÅ
		{
			++nLeft;
		}
		nArr[nRight] = nArr[nLeft];
	}
	
	nArr[nLeft] = pivot;
	return nLeft;
}


//快排之递归
void quickCurve(int nArr[], int nLeft, int nRight)
{
	int nPivotPos = 0;
	if(nLeft < nRight)
	{
		nPivotPos = divided(nArr,nLeft,nRight);
		quickCurve(nArr,nLeft,nPivotPos-1);
		quickCurve(nArr,nPivotPos+1,nRight);
	}
}
//快排
void quickSort(int nArr[], int nLen)
{
	quickCurve(nArr,0,nLen-1);
}
void interSectionOfArray(int a[], int b[], int m, int n)
{
	//快排
	quickSort(a,m);
	quickSort(b,n);


	//一次循环筛选出交集.
	if( m < n)
	{
		int j = 0;
		int i = 0;
		while(i < m)
		{
			if(a[i] == b[j])
			{
				cout << a[i] << "\t";
				i++;


				j++;
			}
			else if(a[i] > b[j])
			{
				j++;        //小值++
			}
			else
			{
				i++;        //小值++
			}
		}
		cout << endl;
	}//end  if
}

[思路3]:

hash表存储两数组到一个表中,统计次数累计为2的元素输出即可。

时间复杂度:O(n),典型的以空间换时间的方法。

ypedef struct HASHSET
{
	int key;  //值
	int nCnt; //计数
}hashSet;


	hashSet* pSetArray = new hashSet[m+n]; //空间换时间
	for(int i = 0; i <m+n; i++)
	{
		pSetArray[i].key = 0;
		pSetArray[i].nCnt = -1;
	}


//O(n)实现输出…
void hashInterSection(hashSet* pSetArray, int a[], int b[], int m, int n)
{
	for(int i = 0; i < m; i++)
	{
		pSetArray[a[i]].key = a[i];
		pSetArray[a[i]].nCnt++;
	}
	for(int j = 0; j < n; j++)
	{
		pSetArray[b[j]].key = b[j];
		pSetArray[b[j]].nCnt++;
	}


	for(int k = 0; k < m+n; k++)
	{
		if(pSetArray[k].nCnt == 1)
		{
			cout << pSetArray[k].key << "\t"; //两次累加-1+1+1=1.
		}
	}
	cout << endl;
}

       或者大家有什么更好的方法,欢迎讨论,谢谢!

       [思路三]网友keynumber指出了存在问题,见下面的评论。笔者的思路三的确非常空间复杂度太高,且不是严格意义上的哈希表,只能算类哈希(呵呵)。

       笔者进行了重写,如下:继续欢迎大家讨论。

      

//[修改后思路3]:构建哈希表插入操作的过程中,如果元素已经插入过,即其哈希地址有值,则该元素必为两数组的交集,打印输出即可。(前提数组中的元素不重复)

以下哈希表的构造是通过除留余数法实现的,处理冲突的方法是通过开放定址法实现的。

//初始设定表长10000.
const int g_nLength = 10000;
template <typename _Type>
class HashTable
{
public:
 HashTable(int Length)   //构建哈希表,表长Length
 {
          Element = new _Type[Length];
          for(int i=0;i<Length;i++)
          {
                    Element[i] = -1;
          }
          this->Length = Length;
          Count = 0;
 }

 ~HashTable()
 {
     delete[] Element;
 }

 //求哈希地址
 virtual int Hash(_Type Data)
 {
     return Data % Length; //³ýÁôÓàÊý·¨Çó¹þÏ£µØÖ·.
 }

 //开放定址法再哈希
 virtual int ReHash(int Index,int Count)
 {
     return ((Index + Count) % Length); //
 }

 //查找元素,若已存在返回true,否则返回false。
 virtual bool SerachHash(_Type Data,int& Index)
 {
     Index = Hash(Data);
     int Count = 0;
 
     while(Element[Index] != -1 && Element[Index] != Data)
     {
         Index = ReHash(Index,++Count);
     }
 
     return (Data == Element[Index] ? true :false);
 }

 virtual int SerachHash(_Type Data)
 {
     int Index = 0;
     if(SerachHash(Data,Index)) 
     {
         return Index;

     }
     else 
     {
        return -1;
     }
 }

 // 插入元素
 bool InsertHash(_Type Data)
 {
     int Index = 0;
     if(Count < Length && !SerachHash(Data,Index))
     {
         Element[Index] = Data;
         Count++;
         return true;
     }   
      //在插入的过程中,如果元素已经存在,即为交集元素则打印之.
       if(SerachHash(Data,Index))
          {
              cout << Data << "\t"; 
          }
    return false;
 }

 //手动设置表长
 void SetLength(int Length)
 {
     delete[] Element;
     Element = new _Type[Length];
     for(int i=0;i<Length;i++)
    {
        Element[i] = -1;
    }
     this->Length = Length;
 }

 //移除元素.
 void Remove(_Type Data)
 {
     int Index = SerachHash(Data);
     if(Index != -1)
     {
         Element[Index] = -1;
         Count--;
     }
 }

 //清空整个哈希表
 void RemoveAll()
 {
     for(int i=0;i<Length;i++)
     {
         Element[i] = -1;
     }
     Count = 0;
 }

 void Print()
 {
     for(int i=0;i<Length;i++)
     {
         printf("%d\t",Element[i]);
     }
     printf("\n");
 }

protected:
 _Type* Element;           // Hash表
 int Length;               // Hash表长度
 int Count;                // Hash表当前长度

};

 //自定义子类.
template <typename _Type>
class HashSet : public HashTable<_Type>
{
public:
        HashSet(int nLen):HashTable<_Type>(nLen){}
         ~HashSet(){ }
         friend void hashInterSection(HashSet<_Type>* pHashSet, int a[], int b[], int m, int n);
private: 
};

//友元函数的实现
void hashInterSection(HashSet<int> *pHashSet, int a[], int b[], int m, int n)
{
         for(int i = 0; i < m; i++)
         {
             pHashSet->InsertHash(a[i]);
         }      

         for(int j = 0; j < n; j++)
         {
             pHashSet->InsertHash(b[j]);
         }
         cout << endl;

} 

void main()
{

//       HashSet<int> hashSet(20); 
         //测试用例1:两数组没有交集
//       int a[]={10,9,8,15,14,16,7,33 }; 
//       int b[]={1,3,5,11,13,17,19};
//       int nLena = sizeof(a)/sizeof(a[0]);
//       int nLenb = sizeof(b)/sizeof(b[0]);
//       hashInterSection(&hashSet,a,b,nLena,nLenb);         
//       //用例1测试结果:返回空。        

          //测试用例2:两数组相等,所含元素全部相同。
//       HashSet<int> hashSet2(20);  
//       int aa[]={10,9,8,15,14,16,7,33 }; 
//       int bb[]={10,9,8,15,14,16,7,33 };
//       int nLena = sizeof(aa)/sizeof(aa[0]);
//       int nLenb = sizeof(bb)/sizeof(bb[0]);
//       hashInterSection(&hashSet2,aa,bb,nLena,nLenb);
         //用例2测试结果:返回交集。

           //测试用例3:两数组部分相同。
          HashSet<int> hashSet3(20);  
          int aa[]={10,9,8,15,14,16,7,33 }; 
          int bb[]={10,9,8,15,144,166,73,333,55,29};
          int nLena = sizeof(aa)/sizeof(aa[0]);
          int nLenb = sizeof(bb)/sizeof(bb[0]);
          hashInterSection(&hashSet3,aa,bb,nLena,nLenb);
          //用例3测试结果:返回交集。
          system("pause");
}


发布了359 篇原创文章 · 获赞 2735 · 访问量 329万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 代码科技 设计师: Amelia_0503

分享到微信朋友圈

×

扫一扫,手机浏览