精华内容
下载资源
问答
  • 2015-08-29 22:13:26
    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;
    	}
    
    }
    


     
    

    更多相关内容
  • 一组数字去重

    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 ;
    	}
    

    展开全文
  • 行代码给数组去重

    2022-02-28 18:36:03
    遍历数中的每个值,存放到新数组中,然后用 **indexOf()**方法判断新数组中是否有重复的值,有则丢弃,没有则存入新数组,这样得到的新数组就是去重后的数组。 let arr= [1,2,3,4,1,3,5,6]; var arr2=[]; for...

    […new Set(arr)]

    常用数组去重方法:

    遍历数组中的每一个值,存放到新数组中,然后用 **indexOf()**方法判断新数组中是否有重复的值,有则丢弃,没有则存入新数组,这样得到的新数组就是去重后的数组。

    let arr= [1,2,3,4,1,3,5,6];
    var arr2=[];
    for(i=0;i<arr.length;i++){
      // 先判断这个值是否存在
      if(arr2.indexOf(arr[i])<0){
        // 存入值
        arr2.push(arr[i]);
      }
    }
    

    下面教你一行代码给数组去重:

    利用es6中的 Set() 方法,返回数组利用es6中的结构赋值;

    //			[...new Set(arr)]   这一行代码便可以实现;参考下面案例
    
    let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 5, 3, 1, 2, 6, 7, ];
    console.log([...new Set(arr)]);
    
    //看不懂可以看下面
    let newArr=new Set(arr);
    console.log(newArr);
    
    展开全文
  • 数组去重组合并去重

    千次阅读 2021-09-08 14:47:56
    数组去重组合并去重 数组去重 (1)indexOf()方法 let arr = [4, 1, 3, 2, 4, 1, 2] arr = removeRepeat(arr) console.log(arr) // [ 1, 2, 3, 4 ] function removeRepeat(val){ let newArr = [] val....

    📝 个人简介

    ⭐ 个人主页:我是段段🙋‍
    🍊 博客领域:编程基础、前端💻
    🍅 写作风格:干货!干货!都是干货!
    🍑 精选专栏:数组
    🛸 支持段段:点赞👍、收藏⭐、留言💬

    数组去重与数组合并去重

    数组去重

    (1)indexOf()方法

    let arr = [4, 1, 3, 2, 4, 1, 2]  
    arr = removeRepeat(arr)
    console.log(arr) // [ 1, 2, 3, 4 ]
    
    function removeRepeat(val){
        let newArr = []
        val.forEach( item => {
            if(newArr.indexOf(item) == -1){
                newArr.push(item)
            }
        })
        return newArr.sort()
    }
    

    使用indexOf()方法,判断当前值是否在新数组中存在,如若不存在,即返回值为-1,就将其push到新数组中

    (2)splice()方法

    let arr = [4, 1, 3, 2, 4, 1, 2]  
    arr = removeRepeat(arr)
    console.log(arr) // [ 1, 2, 3, 4 ]
    
    function removeRepeat(val){
        for(var i = 0; i < val.length - 1; i++){
            for (var j = i + 1; j < val.length; j++) {
                if(val[i] == val[j]){
                    val.splice(j, 1)
                    j--
                }
            }
        }
        return val.sort()
    }
    

    使用splice()方法去重需要使用两层for循环,使用数组中的第一个值依次与后面的每一个值进行判断,看其是否相等,如若相等,则使用splice()方法从后面相等值的下标开始删除1项,然后让j进行自减,因为减去一个值后,原数组的长度发生了变化,即后面的值已经填充了刚才删除值得位置,所以需要再次进行判断

    (3)数组下标判断法

    let arr = [4, 1, 3, 2, 4, 1, 2] 
    arr = removeRepeat(arr)
    console.log(arr) // [ 1, 2, 3, 4 ]
    
    function removeRepeat(val){
        let newArr = []
        for (var i = 0; i < val.length; i++) {
           if(val.indexOf(val[i]) == i){
               newArr.push(val[i])
           }
        }
        return newArr.sort()
    }
    

    indexOf()方法的定义:可返回某个指定的字符串值在字符串中首次出现的位置,正是使用了这一特性,判断值首次出现时的i和使用indexOf()方法查找的是否一直,若二者相等,则表示该值是首次出现

    (4)排序相邻去除

    let arr = [4, 1, 3, 2, 4, 1, 2] 
    arr = removeRepeat(arr)
    console.log(arr) // [ 1, 2, 3, 4 ]
    
    function removeRepeat(val){
        val = val.sort((a, b) => a - b)
        let newArr = [val[0]]
        for (var i = 1; i < val.length; i++) {
            if(val[i] !== newArr[newArr.length - 1]){
                newArr.push(val[i])
            }
        }
        return newArr
    }
    

    注意:使用此方法必须先对数组进行排序(升序降序均可),将排序后的第一个值放入新数组,然后从第二个值开始判断,其是否与新数组中的最后一个相等,如若不等,即可向新数组中push

    (5)ES6中Set()去重

    let arr = [4, 1, 3, 2, 4, 1, 2] 
    arr = removeRepeat(arr)
    console.log(arr) // [ 1, 2, 3, 4 ]
    
    // 可以使用ES6的扩展运算符
    function removeRepeat(val){
        return [ ...new Set(val) ].sort()
    }
    
    // 可以使用Array.form()
    function removeRepeat(val){
        return Array.from(new Set(val)).sort()
    }
    

    ES6中新增了Set容器,它类似于数组,但是成员的值都是唯一的,没有重复的值,Set()本身是一个构造函数,所以需要使用new关键字

    (6)利用对象的属性去重

    let arr = [4, 1, 3, 2, 4, 1, 2] 
    arr = removeRepeat(arr)
    console.log(arr) // [ 1, 2, 3, 4 ]
    
    function removeRepeat(val){
        let newArr = []
        let obj = {}
        val.forEach(item => {
            if(!obj[item]){
                newArr.push(item)
                obj[item] = 1
            }
        })
        return newArr.sort()
    }
    

    因为对象中的键名是不能重复的,所以将不重复的值在对象中进行标识。首先判断每一个值是否作为键名存放在对象中,如若没有,则向新数组中push该值,并且在对象中将以该值作为键名的键值赋值为1

    数组合并去重

    // 方法一
    let m = [3, 1, 2], 
        n = [3 ,4 ,5, 2],
        result = []
        result = removeRepeat(m, n)
    console.log(result) // [ 1, 2, 3, 4, 5 ]
    
    function removeRepeat(){
        let arr = [].concat.apply([], arguments)
        return Array.from(new Set(arr)).sort()
    }
    
    // 方法二
    let m = [3, 1, 2], 
        n = [3 ,4 ,5, 2],
        result = []
        result = removeRepeat(m, n)
    console.log(result) // [ 1, 2, 3, 4, 5 ]
    
    function removeRepeat(m, n){
        let arr = m.concat(n)
        return [ ...new Set(arr) ].sort()
    }
    

    方法一首先使用apply()方法接收类数组,然后再使用concat()方法进行合并,最后使用Set()方法进行去重

    方法二首先将两个数组使用concat()进行合并,然后使用Set()方法进行去重

    这次的分享就到这里了,后续了解了新的知识再来补充~~

    展开全文
  • java两个组合并去重

    2021-01-29 03:30:28
    Leetcode数组类题目总结(Java版本)_计算机软件及应用_IT/计算机_专业资料。Leetcode151 题目详解 1 第章线性表 此类...将所有的放入集合中(已经去重) 。 取,前后探索,记录连续的个数更新 max......Java数组...
  • 两个组合并去重

    2022-02-17 10:46:47
    String[] str1 = {"08:00", "09:00", "10:00", "18:00", "21:00"}; String[] str2 = {"12:00", "09:00", "10:00", "11:00"}; //jdk8 stream ....distinct() //去重 .sorted() //排序 .peek(Sy
  • 主要介绍了js操作两个json数组合并、去重,以及删除某项元素,需要的朋友可以参考下
  • 两个组合并去重(前端)

    千次阅读 2019-03-25 16:37:15
    以下方法是将两个数组合并为个新的数组,并去除所有重复的元素。示例: let arr1 = [1,2,3,3,4] let ...//定义个函数,传入两个数组,返回去重数组 function twoArraysToOne (arr1,arr2) { let arr3= []; ...
  • 组合并去重Array.from

    2021-05-07 09:19:36
    对多个组合并去重技巧PHP中两个数组合并可以使用+或者array_merge,但之间还是有区别的,而且这些区别如果了解不清楚项目中会要命的! 主要区别是两个或者多个数组中如果出现相同键名,键名分为字符串或者数字,需要...
  • 方法: 双层循环,外层循环元素,内层循环时比较值 如果有相同的值则跳过,不相同则push进数组 Array.prototype.distinct = function(){ var arr = this, result = [], i, j, len = arr.length; for(i = 0; i ...
  • jQuery 组合并去重排序

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

    千次阅读 2021-03-12 13:49:04
    int deleteRepitition(int *arr,int len) {//由于C语言无法直接修改数组长度,我们返回去重后的数组长度 int k = 0; for (int i = 0; i < len;i++) { if (*(arr+i)-*(arr+i+1)) { *(arr + k
  • 组合并的两种方法 1、concat--合并数组,并且不去重 var arr1 = ["ab","bc","de","fg"]; var arr2 = ["ml","kg","ww","bc","am"]; var arr3 = arr1.concat(arr2); console.log(arr3) 2、自定义数组合并并...
  • c++实现数组的去重

    千次阅读 2020-12-21 13:19:35
    #include<..."请输入6个(其中包含带重复的):" ; for(i=0;i<6;i++) { cin>>a[i]; flag[i]=1; } cout<<"去掉重复的数字后:" ; for(i=0;i<5;i++) { for(j=i+1
  • java组合并去重

    千次阅读 2019-09-20 15:26:29
    Set<Long> hashSet = new HashSet<>(); hashSet.addAll(Arrays.asList(uids1)); hashSet.addAll(Arrays.asList(uids1));
  • 3.去重与排序(Java)

    2021-11-14 15:27:04
    【问题描述】明明想在学校中请一些同学一起做项问卷调查,为了实验的客观性,他先用计算机生成了N个1到1000之间的随机整数(N≤1000),对于其中重复的数字,只保留个,把其余相同的去掉,不同的对应着不同...
  • mysql统计结果去重

    2020-12-02 16:07:08
    个tableA表,表中数据如下: id name age 1 tony 18 2 jacky 19 3 jojo 18 SELECT COUNT(age) FROM tableA 以上这条语句能查出table表中有多少条数据。查询结果是3 而COUNT这个关键词与 DISTINCT同使用时,...
  • 随机数去重
  • 下面小编就为大家分享篇Python numpy 点数组去重的实例,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 整数数组去重

    千次阅读 2017-02-20 19:57:25
    关于整数数组去重的两种错误方法
  • 利用set去重,再转化为数 set是个集合,其中的元素不能重复。 HashSet&lt;Integer&gt; hs=new HashSet&lt;Integer&gt;(); for(int i = 0;i&lt;n;i++){ Integer t = scan.nextInt(); ...
  • 需求:用三个不同参数请求三遍,返回的数据进行合并去重,如果重复的话只保留第条。getDataAll = () => {this.props.beginLoadingData();let requestArray = [];requestArray.push(this.getData("one"));//传入...
  • 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
  • a_list=[输入串空格间隔的数字],编写程序删除列表中重复的数字(保留第个),然后将其转化为字符串。(删除重复元素、列表转字符串) 输入样例: 4 8 7 8 6 8 3 输出样例: 48763 代码展示: a_list...
  • Java 数组去重

    千次阅读 2019-05-29 14:07:00
    第二种方法---利用hashSet去重 hashSet是个没有重复元素的集合,由hashMap实现的,无序,并且允许null,但只允许个null值。 下面贴上代码,亲测可用。 public boolean checkIsRepeat(String[] arrs){ ...
  • 主要介绍了Java中List集合对象去重及按属性去重的8种方法,本文给大家介绍的非常详细,对大家的学习或工作具有地的参考借鉴价值,需要的朋友可以参考下
  • 数组去重和冒泡排序

    2017-05-08 14:58:54
    最简单数组去重法 最简单的去重方法,实现思路:新建一新数组,遍历传入数组,值不在新数组就加入该新数组中; function unique1(array){ var n = []; //个新的临时数组 //遍历当前数组 ...
  • 双数组去重

    千次阅读 2022-01-05 10:46:33
    最后从新更换方法,顺利完成. 旧代码: let len = arr.length;...// 去重 for(let i=0;i<len;i++){ for(j=0;j<newArr.length;j++){ if(newArr[j].orgId === arr[i].orgId){ break; ...
  • 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) } //将多选的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 95,240
精华内容 38,096
关键字:

一组数去重