数组遍历去重复

敢不敢在来一次 2013-08-21 04:55:04
两个数组比较相同的，最后想得到三个数组，一个是两个数组相同的数组成的，另外两个分别是原来两个数组去除相同后的！
原数组：
String[] array1 = {1,2,3,4}
String[] array2 = {3,4,5,6,7}
需要得到的数组：
int [] a1 = {3,4}
int [] a2 = {1,2}
int [] a3 = {5,6,7}

求哪位大侠算法比较好的，帮忙写一下！3Q3Q~~
...全文
419 12 打赏 收藏 转发到动态 举报
写回复
用AI写文章
12 条回复
切换为时间正序
请发表友善的回复…
发表回复
lishikai500 2013-08-22
  • 打赏
  • 举报
 回复 

public class CompareArray {

	public static void main(String[] args) {
		new CompareArray().inti();
	}
	private void inti() {
		
		int[] Aarray={1,2,3,4};
		int[] Barray={3,4,5,6,7};
		int[] ddd = andOperation(Aarray, Barray);// 交集
		int[] ad = XOROperation(Aarray, ddd);//差集
		int[] bd = XOROperation(Barray, ddd);
		
		printArray(ddd);
		printArray(ad);
		printArray(bd);
		
	}
	
	private int[] andOperation(int[] a, int[] b){
		int[] andArray = new int[Math.max(a.length, b.length)];
		a = sortArray(a);
		b = sortArray(b);
		int cursorA=0, cursorB=0, count=0;
		
		while(cursorA<a.length && cursorB<b.length){
			if(a[cursorA] == b[cursorB]){
				andArray[count] = a[cursorA];
				count++;cursorA++;cursorB++;
			}else if(a[cursorA] > b[cursorB])
				cursorB++;
			else 
				cursorA++;		
		}
		return trimArray(andArray);
	}
	private int[] XOROperation(int[] a, int[] b){
		int[] XORArray = new int[Math.max(a.length, b.length)];
		a = sortArray(a);
		b = sortArray(b);
		int cursorA=0, cursorB=0, count=0;
		
		while(a.length>cursorA && b.length>cursorB){
			if(a[cursorA] == b[cursorB]){			
					cursorB++;cursorA++;
			}else if(a[cursorA] > b[cursorB]){
				XORArray[count] = b[cursorB];
					cursorB++;count++;
			}
			else {
				XORArray[count] = a[cursorA];
					cursorA++;count++;
			}	
		}
		if(cursorA==a.length && cursorB == b.length){}
		else if(cursorA<a.length){
			for(int i = cursorA; i<a.length ;i++){
				XORArray[count] = a[i];
				count++;
			}
		}else{
			for(int i = cursorB; i<b.length ;i++){
				XORArray[count] = b[i];
				count++;
			}
		}
		
		return trimArray(XORArray);
	}
	
	private int[] sortArray(int[] datas){
		for(int i=1; i<datas.length; i++) {  
            for(int j=0; j<datas.length-i; j++) {  
                if(datas[j] > datas[j+1]) {  
                    int temp = datas[j];
                    datas[j] = datas[j+1];
                    datas[j+1] = temp; 
                }  
            }  
        }  
        return datas;  
	}
	private int[] trimArray(int[] array){
		int count = 0;
		for(int i : array){
			if(i == 0)
				count++;
		}
		int[] newArray = new int[array.length -count];
		count =0;
		for(int i : array){
			if(i!=0){
				newArray[count] = i;
				count++;
			}
		}
		return newArray;
	}
	private void printArray(int[] array){
		System.out.println();
		boolean notFirst = false;
		for(int i:array){
			if(i==0 && notFirst)
				return;
			System.out.print(i+" ");
			notFirst = true;
		}
	}
}
流星陨落 2013-08-21
  • 打赏
  • 举报
 回复
小傅哥 2013-08-21
  • 打赏
  • 举报
 回复
LZ 我写了个，不用API的，就是看着恶心点，都是自己的逻辑了。 

package com.csdn.fzw;

public class From_web {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		String[] arr1 = {"1","2","3","4"};//"3","4","5","6","3"
		String[] arr2 = {"3","4","5","6","7"};//"1","2","3"
		
		String[] arrMerger = mergerArray(arr1,arr2);
		
		String[] arrRr = removeRepeat(arrMerger, arrMerger);

		System.out.println("并集：");
		for(String str : arrRr){
			System.out.print(str + " ");
		}
		System.out.println();
		
		String[] intersect = changeToArray(sbIntersect);
		
		System.out.println("交集：");
		for(String str : intersect){
			System.out.print(str + " ");
		}
		System.out.println();
		
		
		String[] ds_1 = dSet(intersect,arr1);
		System.out.println("差集：");
		for(String str:ds_1){
			if(ds_1.length > 0){
				System.out.print(str+" ");
			}
		}
		System.out.println();
		
		String[] ds_2 = dSet(intersect,arr2);
		System.out.println("差集：");
		for(String str:ds_2){
			if(ds_1.length > 0){
				System.out.print(str+" ");
			}
		}
	}
	
	private static StringBuffer sbIntersect = new StringBuffer();
	
	/**
	 * 合并数组
	 * @param arrOne
	 * @param arrTwo
	 * @return
	 */
	public static String[] mergerArray(String[] arrOne,String[] arrTwo){
	
		String[] marray = new String[arrOne.length + arrTwo.length];
		//拷贝第一个数组
		for(int i = 0; i < arrOne.length; i ++){
			marray[i] = arrOne[i];
		}
		//拷贝第二个数组
		for(int i = arrOne.length,index = 0; i < arrOne.length + arrTwo.length; i++,index ++){
			marray[i] = arrTwo[index];
		}
		
		return marray;
	}
	
	/**
	 * 去重函数
	 * @param arrOne
	 * @param arrTwo
	 * @return
	 */
	public static String[] removeRepeat(String[] arrOne,String[] arrTwo){
		
		StringBuffer sbSave = new StringBuffer();
		
		//统计匹配次数
		int countNum = 0;
		String strBuffer = "";
		
		for(int i = 0; i < arrOne.length; i ++){
			
			for(int j = 0; j < arrTwo.length; j ++){
				if(arrOne[i] == arrTwo[j]){
					countNum ++;
				}
			}
			
			if(countNum > 1){
				strBuffer = arrOne[i];
				if(null != arrOne[i]){
					sbSave.append(arrOne[i]);
					
					//相交的另外保存
					intersect(arrOne[i]);
				}
				for(int ri = 0; ri < arrOne.length; ri ++){
					if(strBuffer == arrOne[ri]){
						arrOne[ri] = null;
					}
				}
			}else{
				if(null != arrOne[i]){
					sbSave.append(arrOne[i]);
				}
			}
			
			countNum = 0;
		}
		
		String[] arrNew = new String[sbSave.length()];
		
		//转成数组
		for(int i = 0; i < sbSave.length();i ++){
			arrNew[i] = String.valueOf(sbSave.charAt(i));
		}
		
		return arrNew;
		
	}
	
	
	public static String[] dSet(String[] arrOne,String[] arrTwo){
		
		StringBuffer sbSave = new StringBuffer();
		
		String strBuffer = "";
		
		if(arrOne.length >= arrTwo.length){
			for(int i = 0; i < arrTwo.length; i ++){
				for(int j = 0; j < arrOne.length; j ++){
					if(arrTwo[i].equals(arrOne[j])){
						
						strBuffer = arrTwo[i];
						
						for(int ri = 0; ri < arrOne.length; ri ++){
							if(strBuffer.equals(arrOne[ri])){
								arrOne[ri] = null;
							}
						}
					}
				}
			}
		}else{
			for(int i = 0; i < arrOne.length; i ++){
				for(int j = 0; j < arrTwo.length; j ++){
					if(arrOne[i].equals(arrTwo[j])){
						
						strBuffer = arrOne[i];
						
						for(int ri = 0; ri < arrTwo.length; ri ++){
							if(strBuffer.equals(arrTwo[ri])){
								arrTwo[ri] = null;
							}
						}
					}
				}
			}
		}
		
		for(int i = 0; i < arrTwo.length; i ++){
			if(arrTwo[i] != null){
				sbSave.append(arrTwo[i]);
			}
		}
		sbSave.trimToSize();
		
		String[] strArr = new String[sbSave.length()];
		for(int i = 0; i < sbSave.length(); i ++){
			strArr[i] = String.valueOf(sbSave.charAt(i));
		}
		
		return strArr;
		
	}
	
	/**
	 * 相交函数
	 * @param str
	 */
	public static void intersect(String str){
		sbIntersect.append(str);
	}
	
	/**
	 * 字符串转数组
	 * @param sbArray
	 * @return
	 */
	public static String[] changeToArray(StringBuffer sbArray){
		String[] arr = new String[sbArray.length()];
		
		for(int i = 0; i < sbArray.length(); i ++){
			arr[i] = String.valueOf(sbArray.charAt(i));
		}
		
		return arr;
	}

}
小傅哥 2013-08-21
  • 打赏
  • 举报
 回复
C# 里面有专门的函数实现 列举其中一个差集 C# 的这个方法是System.Linq下的 

double[] numbers1 = { 2.0, 2.1, 2.2, 2.3, 2.4, 2.5 };
double[] numbers2 = { 2.2 };

IEnumerable<double> onlyInFirstSet = numbers1.Except(numbers2);

foreach (double number in onlyInFirstSet)
    Console.WriteLine(number);

/*
 This code produces the following output:

 2
 2.1
 2.3
 2.4
 2.5
*/
java 里面需要自己实现 当然java里面java8已经有lambad了，另外java里面要用Linq需要另外引包 java 里的Linq http://www.infoq.com/cn/news/2007/09/quaere-linq java 里的lambadhttp://www.oschina.net/question/12_59047 java 里面的 【retainAll() 可得到交集， 做 removeAll() 可得到减集】这个二楼的很正确 自己实现的思路有1（这种方法还很多至列举一个）： 1、并集，两层for循环，第一个里面取值在第二个里面比较出现次数一次以上的取第一个值放到新数组里，否则取第二个里面的值放到新数组里 2、交集，两层for循环，第一个里面取的值在第二层里面出现次数大于一次的，这样的存到新数组里 3、差集，两层for循环，第一个里面取的值在第二层里面出现次数小于一次的，这样的存到新数组里 自己实现的思路有2： 都转成集合，之后用jdk提供的方法 1、retainAll boolean retainAll(Collection<?> c)仅保留 set 中那些包含在指定 collection 中的元素（可选操作）。换句话说，移除此 set 中所有未包含在指定 collection 中的元素。如果指定的 collection 也是一个 set，则此操作会实际修改此 set，这样其值是两个 set 的一个交集。 2、removeAll boolean removeAll(Collection<?> c)移除 set 中那些包含在指定 collection 中的元素（可选操作）。如果指定的 collection 也是一个 set，则此操作会实际修改此 set，这样其值是两个 set 的一个不对称差集。 3、set集合是一种无需不可重复的集合，你只要把两个数组里面的数都转成集合放进去，那么现在的这个set集合就是一个并集 能力有限，疏漏之处望见谅！
敢不敢在来一次 2013-08-21
  • 打赏
  • 举报
 回复
引用 3 楼 kemucc 的回复:
引用 2 楼 ldh911 的回复:
先把这两个数组转为 java.util.Set， 然后做 retainAll() 可得到交集， 做 removeAll() 可得到减集
顶这个，很省事
转换过去 又得转回来，才不省事呢！
敢不敢在来一次 2013-08-21
  • 打赏
  • 举报
 回复
引用 2 楼 ldh911 的回复:
先把这两个数组转为 java.util.Set， 然后做 retainAll() 可得到交集， 做 removeAll() 可得到减集
大侠，能不能用for 写一个吖！3Q3Q~~~
敢不敢在来一次 2013-08-21
  • 打赏
  • 举报
 回复
引用 1 楼 cbxjj 的回复:
为什么不自己试着写写呢 这个很简单呢 别人写给你 你只是被动接受 下次还是不会 自己试着写下 再遇到也会写
自己写了一个，感觉太繁琐了，想听听大侠们有没有好的散法，学习学习！
kemucc 2013-08-21
  • 打赏
  • 举报
 回复
引用 2 楼 ldh911 的回复:
先把这两个数组转为 java.util.Set， 然后做 retainAll() 可得到交集， 做 removeAll() 可得到减集
顶这个，很省事
MiceRice 2013-08-21
  • 打赏
  • 举报
 回复
先把这两个数组转为 java.util.Set， 然后做 retainAll() 可得到交集， 做 removeAll() 可得到减集
剑神一笑 2013-08-21
  • 打赏
  • 举报
 回复
为什么不自己试着写写呢 这个很简单呢 别人写给你 你只是被动接受 下次还是不会 自己试着写下 再遇到也会写
JS几种数组遍历方式总结
JS数组遍历的几种方式JS数组遍历，基本就是for,forin,foreach,forof,map等等一些方法，以下介绍几种本文分析用到的数组遍历方式以及进行性能分析对比第一种:普通for循环代码如下:for(j = 0; j &lt; arr.length; j++) { } 简要说明: 最简单的一种，也是使用频率最高的一种，虽然性能不弱，但仍有优化空间第二种:优化版for循环代码如下...
C语言 数组遍历 - C语言零基础入门教程
目录 一.数组遍历原理 二.数组遍历实战 1.遍历数组查询数组中的元素 2.遍历数组修改数组中的元素 三.猜你喜欢 零基础 C/C++ 学习路线推荐 : C/C++ 学习目录 >> C 语言基础入门 一.数组遍历原理 在 C / C++ 数组定义和初始化中详细的介绍了关于数组五种初始化方法，这些初始化方式其实在开发中还是蛮实用的； 对于数组元素的访问和修改是通过数组下标的方式来解决的，数组遍历的原理也是一样，通过 while 循环或者 for 循环直接遍历数组下标从而达到访问或者修
JS数组遍历的几种方法
for     最简单的一种循环遍历方法，也是使用频率最高的一种，可优化 var arr = [1, 2, 3, 4, 5, 6] for(var i = 0; i < arr.length; i++) { console.log(arr[i]) } // 1 2 3 4 5 6     优化：使用临时变量，将长度缓存起来，避免重复获取数组长度，当数组较大时优化效果才会比较明显 var...
Python数组遍历-从基础到高级的全面指南
在深入探讨Python中的具体实现之前,让我们先明确一下什么是数组遍历。数组遍历是指按照某种顺序访问数组中的每个元素的过程。这个看似简单的操作实际上是许多复杂算法和数据处理任务的基础。无论是搜索、排序、还是数据分析,几乎所有的数组操作都离不开遍历。想象一下,数组就像一排整齐的书架,而遍历则是你按照某种规则(比如从左到右)查看每本书的过程。查找特定元素修改数组内容计算统计数据(如总和、平均值等)将数组转换为其他数据结构执行更复杂的数据处理任务。
JS数组遍历的几种方式以及性能讲解
JS数组遍历的几种方式以及性能讲解 JS数组遍历，基本就是for,forin,foreach,forof,map等等一些方法，以下介绍几种本文分析用到的数组遍历方式以及进行性能分析对比 第一种:普通for循环 for(j = 0; j < arr.length; j++) { } 简要说明: 最简单的一种，也是使用频率最高的一种，虽然性能不弱，但仍有优化空间 第二种:优化版...
非技术区

23,407

社区成员

70,513

社区内容

发帖
与我相关
我的任务
社区描述
Java 非技术区
社区管理员
  • 非技术区社区
加入社区
  • 近7日
  • 近30日
  • 至今

加载中

查看更多榜单
社区公告
暂无公告

试试用AI创作助手写篇文章吧

+ 用AI写文章