精华内容
下载资源
问答
  • 一组数字去重

    2017-11-14 16:04:50
    方法1: 把这数据装进hashset里面 set不能存储重复数据,可以达到去重效果 方法2: 用遍历这数据,新建个list来接收,用...这2种方法都是利用封装好的类的特性来做的,写个底层的去重方法,还不太熟悉,待研究

    方法1:

    把这组数据装进hashset里面

    set不能存储重复数据,可以达到去重效果

    方法2:

    用遍历这组数据,新建一个list来接收,用list.contains 来判断,重复的不要添加

     

    这2种方法都是利用封装好的类的特性来做的,写一个底层的去重方法,还不太熟悉,待研究


    2017-11-27补充

    方法3:

    public   static   void  removeDuplicate(List list)   { 
       for  int  i  =   0 ; i  <  list.size()  -   1 ; i ++ )   { 
        for  int  j  =  list.size()  -   1 ; j  >  i; j -- )   { 
          if  (list.get(j).equals(list.get(i)))   { 
            list.remove(j); 
          
        
      
      System.out.println(list); 
    这个方法,要点就是倒叙遍历,删除,不会对list产生影响


    方法4:
     public   static   void  removeDuplicate(List list)   { 
        HashSet h  =   new  HashSet(list); 
        list.clear(); 
        list.addAll(h); 
        System.out.println(list); 

    以上这2个是网上看到的

    方法5(自己想的):
    	public List<String> quchong(List<String> a ){
    		List<String> b = new ArrayList<String>();
    		Iterator<String> bit  = b.iterator();
    		for(int i=0 ;i<a.size();i++){
    			String ai = a.get(i);
    			Boolean has = false;
    			while(bit.hasNext()){
    				String bn = bit.next();
    				if(ai.equals(bn)){
    					has = true;
    					break;
    				}
    			}
    			if(!has){
    				b.add(ai);
    				bit  = b.iterator();
    			}
    		}
    		return b ;
    	}
    

    展开全文
  • HP--day06--输入一组数去重并排序 在控制台输入一组数,去除重复的数字并按照升序顺序排列。 从控制台读入数字,先通过scanner.next()读取字符串,然后再用 string.match("")方法通过正则表达式来验证是否是数字。...
    HP--day06--输入一组数去重并排序

    在控制台输入一组数,去除重复的数字并按照升序顺序排列。

    从控制台读入数字,先通过scanner.next()读取字符串,然后再用 string.match("")方法通过正则表达式来验证是否是数字。升序可以通过冒泡排序、选择排序、插入排序等等 但是利用jdk提供的 Arrays.sort(数组名),这种方法执行效率比较高,一个问题有多种解决方法的同时还要考虑执行效率的问题。最后是去重,去重可能要先排序然后比较相邻的数字,相同的写入到另一个数组中,或者移动本数组的元素覆盖相同的数组元素。如果数量量非常大通过移动数组的元素来去重执行效率显然是非常低的。通过利用HashSet可以实现去重的效果,比较相同的数据在HashSet中只能出现一次。但是如果先排序按照升序的顺序通过add()方法添加到HashSet集合中,打印出来的却不是按照升序的顺序,因为HashSet的存放时按照哈希算法排序的,所以应当先 去重再排序。或者将HashSet去重后的数据放到List中(List是有序可重复的,HashSet是无序不可重复的) 。

    然后通过iterator迭代输出HashSet中的数,再通过Arrays.sort()排序

    <pre name="code" class="java">import java.util.HashSet;
    import java.util.Iterator;
    import java.util.Scanner;
    import java.util.Set;
    import java.util.Arrays;
    
    public class QuChong {
    
    	Scanner scanner = new Scanner(System.in);
    	int[] a = new int[100];
    
    	public static void main(String[] args) {
    		QuChong qc = new QuChong();
    		qc.start();
    	}
    
    	public void start() {
    		int count = inputa();// 获取输入了多少个数字
    		Set hashSet = new HashSet<Integer>();
    		for (int i = 0; i < count; i++) {
    			hashSet.add(a[i]);
    		}
    
    		Iterator<Integer> it = hashSet.iterator();
    		int countSet = 0;
    		int[] d = new int[hashSet.size()];
    		while (it.hasNext()) {
    			d[countSet++] = it.next();
    
    		}
    
    		Arrays.sort(d);// 对d数组从小到大排序
    		for (int i : d) {
    			System.out.print(i + ",");
    
    		}
    
    	}
    
    	// 判断并读取数字
    	public int inputa() {
    		int i = 0;
    		while (true) {
    			System.out.println("请输入第" + (i + 1) + "个数字");
    			String s = scanner.next();
    			if (s.matches("^[0-9]*$")) {// 利用正则表达式判断是否为数字
    				a[i++] = Integer.parseInt(s);
    			} else if (s.equals("n")) {
    				break;
    			}
    		}
    		return i;
    	}
    
    }
    


    
    

    展开全文
  • 一组数据去重和排序的实现

    千次阅读 2016-10-09 15:45:54
    一组数据去重和排序

    题目转自http://www.nowcoder.com/practice/3245215fffb84b7b81285493eae92ff0?tpId=37&tqId=21226&rp=&ru=/ta/huawei&qru=/ta/huawei/question-ranking

    题目描述

    明明想在学校中请一些同学一起做一项问卷调查,为了实验的客观性,他先用计算机生成了N个1到1000之间的随机整数(N≤1000),对于其中重复的数字,只保留一个,把其余相同的数去掉,不同的数对应着不同的学生的学号。然后再把这些数从小到大排序,按照排好的顺序去找同学做调查。请你协助明明完成“去重”与“排序”的工作。

    Input Param
    n 输入随机数的个数
    inputArray n个随机整数组成的数组

    Return Value
    OutputArray 输出处理后的随机整数

    注:测试用例保证输入参数的正确性,答题者无需验证。测试用例不止一组。
    测试用例:
    11 // 表示N
    10
    20
    40
    32
    67
    40
    20
    89
    300
    400
    15
    共有两段代码一个是没有while(input.hasNext())循环的代码,一个是有while(input.hasNext())的代码段。
    示例代码段1:

    package basicjavaday06;
    import java.util.Scanner;
    public class RandomNumberRemoveRepeatSort {
        public static void main(String[] args) {
            Scanner input = new Scanner(System.in);
            System.out.println("输入N值:");
            //给定N,且N≤1000
            int N = input.nextInt();
            System.out.println("N = " + N);
            //设置接受随机数的数组randomArray
            int[] randomArray = new int[N];
            for(int i = 0; i < randomArray.length; i++){
                randomArray[i] = input.nextInt();
            }
            //输出测试
            System.out.println("=======原始数据=======");
            for(int i = 0; i < randomArray.length; i++){
                System.out.print(randomArray[i] + "\t");
            }
    
            //去重
            int [] removeRepeat = new int[N];
            int count1 = 0;
            for (int i = 0; i < randomArray.length; i++) {
                if (count1 == 0) {
                    removeRepeat[count1] = randomArray[i];
                    count1++;
                } else {
                    int flag = 0;// 标记,0表示没有重复,1表示重复
                    for (int j = 0; j < count1; j++) {
                        if (randomArray[i] == removeRepeat[j]) {
                            flag = 1;
                        }
                    }
                    if(flag == 0){
                        removeRepeat[count1] = randomArray[i];
                        count1++;
                    }
                }
            }
            //测试输出
            System.out.println("\n=========去重后的数据==========");
            for(int i = 0; i < count1; i++){
                System.out.print(removeRepeat[i] + "\t");
            }
    
            //从小到大排序
            //1. 冒泡法排序
            int temp; 
            for(int i = 0; i < count1; i++){
                for(int j = i+1; j < count1; j++){
                    if(removeRepeat[i] > removeRepeat[j]){
                        temp = removeRepeat[i];
                        removeRepeat[i] = removeRepeat[j];
                        removeRepeat[j] = temp;
                    }
                }
            }
            //测试输出
            System.out.println("\n=========从小到大排序后==========");
            for(int i = 0; i < count1; i++){
                System.out.print(removeRepeat[i] + "\t");
            }
    
            input.close();
        }
    }
    

    示例代码段2:

    package basicjavaday06;
    
    import java.util.Scanner;
    
    public class Main {
        public static void main(String[] args) {
            Scanner input = new Scanner(System.in);
            // System.out.println("输入N值:");
            // 给定N,且N≤1000
            while (input.hasNext()) {
                int N = input.nextInt();
                // System.out.println("N = " + N);
                // 设置接受随机数的数组randomArray
                int[] randomArray = new int[N];
                for (int i = 0; i < randomArray.length; i++) {
                    randomArray[i] = input.nextInt();
                }
                // 输出测试
                // System.out.println("=======原始数据=======");
                // for(int i = 0; i < randomArray.length; i++){
                // System.out.print(randomArray[i] + "\t");
                // }
    
                // 去重
                int[] removeRepeat = new int[N];
                int count1 = 0;
                for (int i = 0; i < randomArray.length; i++) {
                    if (count1 == 0) {
                        removeRepeat[count1] = randomArray[i];
                        count1++;
                    } else {
                        int flag = 0;// 标记,0表示没有重复,1表示重复
                        for (int j = 0; j < count1; j++) {
                            if (randomArray[i] == removeRepeat[j]) {
                                flag = 1;
                            }
                        }
                        if (flag == 0) {
                            removeRepeat[count1] = randomArray[i];
                            count1++;
                        }
                    }
                }
                // 测试输出
                // System.out.println("\n=========去重后的数据==========");
                // for(int i = 0; i < count1; i++){
                // System.out.print(removeRepeat[i] + "\t");
                // }
    
                // 从小到大排序
                // 1. 冒泡法排序
                int temp;
                for (int i = 0; i < count1; i++) {
                    for (int j = i + 1; j < count1; j++) {
                        if (removeRepeat[i] > removeRepeat[j]) {
                            temp = removeRepeat[i];
                            removeRepeat[i] = removeRepeat[j];
                            removeRepeat[j] = temp;
                        }
                    }
                }
                // 测试输出
                // System.out.println("\n=========从小到大排序后==========");
                for (int i = 0; i < count1; i++) {
                    System.out.println(removeRepeat[i]);
                }
            }
            input.close();
        }
    }
    展开全文
  • 整数数组去重

    千次阅读 2017-02-20 19:57:25
    关于整数数组去重的两种错误方法

    今天看到一道题,是关于整数数组的去重和排序。
    碰到去重也没有多想,就直接遍历数组然后判断,如果重复,则把后面的数字前移
    代码如下:

    for(i=0;i<N;i++)
        for(j=i+1;j<N;j++)
            if(a[i]==a[j])
            {
                for(k=j;k<N-1;k++)
                    a[k]=a[k+1];
                N--;
            }

    乍一看好像还很有道理很简洁有没有,但是如果我输入10个数:
    3 3 3 3 1 1 1 1 1 1 并经过排序后,
    结果却为: 1 1 3 3
    为什么呢?
    1、 i=0
    1) j =1时 数组变为 3 3 3 1 1 1 1 1 1
    2) j=2时 数组变为3 3 1 1 1 1 1
    3) j=3时 a[i]!=a[j]
    2、 i=1 a[i]!=a[j]
    发现问题了吗?对于这种情况,这种方法无法实现完全去重。

    另外,我在其他人写的代码中还发现了另一种错误方法:
    遍历数组,如果重复,则令:a[j]=a[N-1]; N–;

    for(i=0;i<N;i++)
        for(j=i+1;j<N;j++)
            if(a[i]==a[j])
            {
                a[j]=a[N-1];
                N--;
            }

    乍一看也很简单是不是?
    然而运行时也出现了问题:
    输入10个数:3 3 3 3 1 1 1 1 1 1 并排序后,
    结果为: 1 1 3
    为什么呢?
    对3成功去重后,数组为 3 1 1 1 1 1 1
    1、 i=1
    1) j =2时 数组变为 3 1 1 1 1 1
    2) j=3时 数组变为3 1 1 1 1
    3) j=4时 数组变为3 1 1 1
    2、 i=2
    3) j=3时 数组变为3 1 1
    可见,这种方法也无法实现完全去重。

    特此标记,以免再犯。

    展开全文
  • jQuery 组合并去重排序

    千次阅读 2018-06-29 19:50:20
    sort() 方法: 用于对数的元素进行排序   语法:arrayObject.sort(sortby)  例:  var c = b.sort( function (a, b) {   // 排序   return a - b;  }); 日期格式的数组排序:   var c = $.merge...
  • 整数数组去重、排序
  • 两个组合并去重(前端)

    千次阅读 2019-03-25 16:37:15
    以下方法是将两个数组合并为个新的数组,并去除所有重复的元素。示例: let arr1 = [1,2,3,3,4] let ...//定义个函数,传入两个数组,返回去重数组 function twoArraysToOne (arr1,arr2) { let arr3= []; ...
  • 1. js 组合并去重 //数组去重 function uniqueArr(arr1, arr2){ var arr3 = arr1.concat(arr2); var arr4 = []; for(var i=0,len=arr3.length; i<len; i++) { ...
  • java实现两个组合并去重

    千次阅读 2017-08-15 17:01:35
    import java.util.Arrays; import java.util.Scanner; import java.util.TreeSet;...//数组合并 去重 public class Test { public static void main(String[] args) { // TODO Auto-generated method stub
  • 个数组添加到另个数组中并去重,其中tableData是将要 添加到fatherTablelist的数组,这时建议用es6的reduce方法: inChildByValue: function(tableData){ if (this.fatherTablelist.leng...
  • 、数组去重 1.for循环嵌套,利用splice去重 function newArr(arr){ for(var i=0;i<arr.length;i++){ for(var j=i+1;j<arr.length;j++) if(arr[i]==arr[j]){ arr.splice(j,1); ...
  • js对象转数组 function toArray(){ var data = {a:1,b:2,c:3,d:4,e:1,f:4}; var arr=[]; for (let i in data){...js对数组去重 1. 遍历数组法 它是最简单的数组去重方法(indexOf方法) 实现思路:新建个数组,...
  • 需求:用三个不同参数请求三遍,返回的数据进行合并去重,如果重复的话只保留第条。 getDataAll = () => { this.props.beginLoadingData(); let requestArray = []; requestArray.push(this.get...
  • var test1 = [1,2,3,4,1,2,’mama’]; Array.prototype.unique1 = function() {var temp = []; // 个新的临时数组 //排序sort(); this.sort(function(a,b){ return b-a}); for(var i
  • JavaScript实现两个对象组合并去重

    千次阅读 2018-03-23 09:42:11
    javascript删除数组中重复的元素,并统计每个元素出现的次数 方法: var array = new Array ( 1 , 2 , 5 , 1 , 4 , 4 , 2 , 3 , 5 , 1 , 1 , 5 , 5 , 5 , 6 , 7 , 3 , 9 , 9 , 10 ) ; var arr = ...
  • createorder: function() { var _self = this; var data = []; for (var i = 0; i < _self.msglist.length; i++) { if (_self.msglist[i].medic_sum >... console.log(_self.msglist[i].medic_sum) ...
  • json组合并和去重

    千次阅读 2019-08-05 22:11:13
    将图的json转化为图二的形式,也就是在相同的id时,将key... //维数组去重 var arr = [] for(var i = 0 ; i< questionParams.length; i++){ arr.push(questionParams[i].id) } //将多选的...
  • lodash库数组和数对象去重

    千次阅读 2021-01-08 18:06:26
    lodash库数组和数对象去重 ###uniq(array) 创建去重后的array数组副本。使用了 SameValueZero 做等值比较。只有第次出现的元素才会被保留。 参数 array (Array): 要检查的数组。 返回 (Array): 返回新的...
  • 要讲到组合并与去重,这里就不得不提array_flip()函数,而这个函数也是数组键值的翻转函数。 For example:$arr=array('10','11','12'); $arr2=array('12','13','14'); $arr3=array('14','15','16');print_r(array_...
  • var zz = [1,2,3,5,5,7,8,6,6]; var se = []; d(se); function d(attr){ for(var i = 1;i<zz.length;i++){ if(se.indexOf(zz[i])<0){ se.push(zz[i]); ...
  • 如果有遇到个数组中存储多个对象,有部分对象的某个键值是相同的,需要过滤掉重复项的实现方案 const arr =[ { "count": 1095, "month": "三月", }, { "count": 1106, "month": "三月", }, { "count":...
  • 2、在1的基础之上,固定第二个位置,数组数组中该位置之后的元素与该位置元素交换 3、递归退出条件:当位置指针等于当前数组的长度,返回当前字符串排序 4、递归: (1)交换元素 (2)递归调用下位置 (3)...
  • js去重方法有很多,最常用也是最基本的如下: var array = [1, 1, '1', '1']; function uq(array) { var del = []; for (var i = 0, arrayLen = array.length; i ; i++) { for (var j = 0, delLen =
  • 前后端数据交互无可避免处理数组,数组去重也是个常用的方法,总结了两个方法: export default { /* 数组对象去重,例如 [ { id: 1, name: 'a' }, { id: 1, name: 'a' ...
  • 个数组的进行 去重

    千次阅读 2016-11-11 18:44:54
    int n = 11; int a[] = { 1, 1, 2, 3, 3, 4, 4, 5, 5, 5, 5 }; n = unique(a, a + n) - a;//使用STL自带去重函数,返回值为最后个元素的位置(地址) for (int i = 0; i cout }
  • c++对数vector去重

    2020-12-07 18:33:42
    设有个数组 cvector<int> submesh_idvec; 使用如下代码可以去掉其中的重复的元素: sort(submesh_idvec.begin(), submesh_idvec.end()); submesh_idvec.erase(unique(submesh_idvec.begin(), submesh_...
  • 集合对数元素去重

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 74,122
精华内容 29,648
关键字:

一组数去重