精华内容
下载资源
问答
  • 问题简介:给定一个有序的数组,删除数组中的重复元素,返回的是不重复元素的个数n,传入的数组nums的前n个值应变为不重复元素 举例: 1: 给定的数组 = [1,1,2], 返回长度n = 2,并且nums前两个值为[1,2] 2: 给...

    Remove Duplicates from Sorted Array

    问题简介:给定一个有序的数组,删除数组中的重复元素,返回的是不重复元素的个数n,传入的数组nums的前n个值应变为不重复元素
    举例:
    1:
    给定的数组 = [1,1,2],
    返回长度n = 2,并且nums前两个值为[1,2]

    2:
    给定数组 = [0,0,1,1,1,2,2,3,3,4],
    返回长度n = 5, 并且nums的前5个值为[0,1,2,3,4]

    解法一:
    笨重的解法。。。通过set元素不重复将nums值传入set,再对nums赋值

    class Solution {
        public int removeDuplicates(int[] nums) {
            Set set = new HashSet<>();
            int length = nums.length;
            for(int i=0;i<length;i++){
                set.add(nums[i]);
            }
            int size = set.size();
            Integer [] array = new Integer [size];
            set.toArray(array);
            Arrays.sort(array);
            for(int j=0;j<size;j++){
                nums[j] = array[j];
            }
            return size;
        }
    }
    

    解法二:
    定义两个变量,i,j,遍历数组,i用来表示不重复的数字索引,j为当前遍历到的索引,当nums[i] != nums[j] 即表示不重复,将记录不重复的值,i的索引加1

    class Solution {
        public int removeDuplicates(int[] nums) {
        if (nums.length == 0) return 0;
        int i = 0;
        for (int j = 1; j < nums.length; j++) {
            if (nums[j] != nums[i]) {
                i++;
                nums[i] = nums[j];
            }
        }
        return i + 1; 
        }
    }
    

    复杂度分析:
    时间复杂度 : O(n)遍历一遍
    空间复杂度:O(1) 定义的空间为定值

    Space complexity : O(1)O(1).
    小白刷题之路,请多指教— — 要么大器晚成,要么石沉大海

    展开全文
  • java中去除数组重复元素

    千次阅读 多人点赞 2019-03-21 09:48:27
    今天这篇文章总结记录下java中去除数组重复元素。 方法一: 创建一个集合,然后遍历数组逐一放入集合,并且在放入之前用contains方法判断集合 中是否已经存在这个元素,如果不存在,则放入,最后用toArray转成数组。...

    今天这篇文章总结记录下java中去除数组重复元素。

    方法一:
    创建一个集合,然后遍历数组逐一放入集合,并且在放入之前用contains方法判断集合
    中是否已经存在这个元素,如果不存在,则放入,最后用toArray转成数组。
    代码如下:

    public static Object[] arrayDeduplication(Object[] originArray) {
            List list = new ArrayList();
            for (int i = 0; i < originArray.length; i++) {
                if (!list.contains(originArray[i])) {
                    list.add(originArray[i]);
                }
            }
            Object[] resultArray = list.toArray();
            return resultArray;
        }
    

    方法二:
    利用set无序不重复的特性进行去重。
    代码如下:

    public static Object[] arrayDeduplication(Object[] originArray) {
            Set set = new HashSet();
            for (int i = 0; i < originArray.length; i++) {
                set.add(originArray[i]);
            }
            return set.toArray();
        }
    

    方法三:
    使用LinkedHashSet,有顺序、不重复。
    代码如下:

    public static Object[] arrayDeduplication(Object[] originArray) {
            LinkedHashSet linkedHashSet = new LinkedHashSet();
            for (int i = 0; i < originArray.length; i++) {
                linkedHashSet.add(originArray[i]);
            }
            return linkedHashSet.toArray();
        }
    

    方法四:
    自己写,两套for循环。
    代码如下:

    public static Object[] arrayDeduplication(Object[] originArray) {
            int temp = 0;  //用来记录去重后的数组长度和给临时数组作为下标索引
            Object[] tempArray = new Object[originArray.length];  //临时数组
            for (int i = 0; i < originArray.length; i++) {  //遍历原始数组
                boolean isTrue = true;
                for (int j = i + 1; j < originArray.length; j++) {  //将原数组的数据逐一比较
                    if (originArray[i] == originArray[j]) {  //如果发现有重复元素,改变标记状态并结束内层循环
                        isTrue = false;
                        break;
                    }
                }
                if (isTrue) {
                    tempArray[temp] = originArray[i];
                    temp++;
                }
            }
            Object[] resultArray = new Object[temp];
            System.arraycopy(tempArray, 0, resultArray, 0, temp);
            return resultArray;
        }
    
    展开全文
  • java:去除数组重复元素的四种方法

    万次阅读 多人点赞 2018-11-18 10:38:16
    需要一个存储去重后元素数组,然后两层循环,外层遍历原数组,内容逐个判断是否和之后的元素重复,然后再提出来存入新的数组。方法System.arraycopy(被复制的数组,起始下标,接收的新数组,起始下标,结束下标);...

    方法1:

    需要一个存储去重后元素的数组,然后两层循环,外层遍历原数组,内容逐个判断是否和之后的元素重复,然后再提出来存入新的数组。方法System.arraycopy(被复制的数组,起始下标,接收的新数组,起始下标,结束下标);可以直接复制数组,既然这样,我就没必要纠结新数组的长度了,直接声明一个跟原数组长度一样的临时数组,只要记录下去重后的元素个数,然后就可以确定去重后数组长度再去将临时数组拷贝到新数组就行了。 
    package testPro.test;
    
    
    public class testDistinctArr {
    
    	public static void main(String[] args) {
    		String[] arr = new String[7];
    		arr[0] = "a";
    		arr[1] = "a";
    		arr[2] = "b";
    		arr[3] = "c";
    		arr[4] = "d";
    		
    		System.out.println(arr.toString());
    		for (String s : arr) {
    			System.out.println(s);
    		}
    		System.out.println("===============");
    		Object[] s  = ifRepeat(arr);
    		for (Object o : s) {
    			System.out.println(o);
    		}
    		
    		
    	}
    
    	/**
         * 去掉数组中重复的元素
         *
         * @param arr
         * @return
         */
    	//方法一:需要传入一个Object数组,然后返回去重后的数组  
        public static Object[] ifRepeat(Object[] arr){  
            //用来记录去除重复之后的数组长度和给临时数组作为下标索引  
            int t = 0;  
            //临时数组  
            Object[] tempArr = new Object[arr.length];  
            //遍历原数组  
            for(int i = 0; i < arr.length; i++){  
                //声明一个标记,并每次重置  
                boolean isTrue = true;  
                //内层循环将原数组的元素逐个对比  
                for(int j=i+1;j<arr.length;j++){  
                    //如果发现有重复元素,改变标记状态并结束当次内层循环  
                    if(arr[i]==arr[j]){  
                        isTrue = false;  
                        break;  
                    }  
                }  
                //判断标记是否被改变,如果没被改变就是没有重复元素  
                if(isTrue){  
                    //没有元素就将原数组的元素赋给临时数组  
                    tempArr[t] = arr[i];  
                    //走到这里证明当前元素没有重复,那么记录自增  
                    t++;  
                }  
            }  
            //声明需要返回的数组,这个才是去重后的数组  
            Object[]  newArr = new Object[t];  
            //用arraycopy方法将刚才去重的数组拷贝到新数组并返回  
            System.arraycopy(tempArr,0,newArr,0,t);  
            return newArr;  
        }  
    }
    

    去重效果:

     

    方法2:

    只需要创建一个集合,然后遍历数组逐一放入集合,只要在放入之前用contains()方法判断一下集合中是否已经存在这个元素就行了,然后用toArray转成数组一切搞定。
     public static Object[]  ifRepeat2(Object[] arr){  
            //创建一个集合  
            List list = new ArrayList();  
            //遍历数组往集合里存元素  
            for(int i=0;i<arr.length;i++){  
                //如果集合里面没有相同的元素才往里存  
                if(!list.contains(arr[i])){  
                    list.add(arr[i]);  
                }  
            }  
              
            //toArray()方法会返回一个包含集合所有元素的Object类型数组  
            Object[] newArr = list.toArray();  
    		return newArr;  
      
        }  

    运行效果:

    方法3:

    利用Set集合无序不可重复的特性进行元素过滤。 
    
        public static Object[] ifRepeat3(Object[] arr){  
            //实例化一个set集合  
            Set set = new HashSet();  
            //遍历数组并存入集合,如果元素已存在则不会重复存入  
            for (int i = 0; i < arr.length; i++) {  
                set.add(arr[i]);  
            }  
            //返回Set集合的数组形式  
            return set.toArray();  
        } 

    运行效果:

     

    方法4:

    链表的哈希集合:有顺序,不重复。
     public static Set<Object>  ifRepeat4(Object[] arr){  
              
            Set<Object> haoma = new LinkedHashSet<Object>();  
            for (int i = 0; i < arr.length; i++) {  
                haoma.add(arr[i]);  
            }  
    		return haoma;  
              
              
        } 

    运行效果:

     

     

     

    展开全文
  • java去除数组重复元素的四种方法

    万次阅读 2017-11-30 09:49:26
    [java] view plain copy  print? package com.yzycool.test;...import java.util.ArrayList;...import java.util.HashSet;  import java.util.Iterator;  import java.util.LinkedHashSet;
    [java]  view plain  copy
     print ?
    1. package com.yzycool.test;  
    2.   
    3. import java.util.ArrayList;  
    4. import java.util.HashSet;  
    5. import java.util.Iterator;  
    6. import java.util.LinkedHashSet;  
    7. import java.util.List;  
    8. import java.util.Set;  
    9.   
    10. /*去除重复的数组: 
    11.  * 方法一:需要一个存储去重后元素的数组,然后两层循环,外层遍历原数组,内容逐个判断是否和之后的元素重复,然后再提出来存入新的数组。方法System.arraycopy(被复制的数组,起始下标,接收的新数组,起始下标,结束下标);可以直接复制数组,既然这样,我就没必要纠结新数组的长度了,直接声明一个跟原数组长度一样的临时数组,只要记录下去重后的元素个数,然后就可以确定去重后数组长度再去将临时数组拷贝到新数组就行了。 
    12.  * 方法二:只需要创建一个集合,然后遍历数组逐一放入集合,只要在放入之前用contains()方法判断一下集合中是否已经存在这个元素就行了,然后用toArray转成数组一切搞定。 
    13.  * 方法三:最简单的方法就是利用Set集合无序不可重复的特性进行元素过滤。 
    14.  * 方法四:链表的哈希集合:有顺序,不重复。 
    15.  */  
    16.   
    17.   
    18. public class ShijuanDa1 {  
    19.   
    20.     public static void main(String[] args) {  
    21.         // TODO Auto-generated method stub  
    22.         String[] strs ={"2007-1-01","2007-1-06",  
    23.                 "2007-1-01","2007-1-08","2007-1-08"};  
    24.           
    25.         printArr(strs);  
    26.           
    27.         System.out.println("------------");  
    28.           
    29.         Object[] newArr = ifRepeat(strs);  
    30.           
    31.         printArr(newArr);  
    32.           
    33.         System.out.println("------------");  
    34.           
    35.         ifRepeat2(strs);  
    36.           
    37.         System.out.println("------------");  
    38.           
    39.         Object[] newArr3 = ifRepeat3(strs);  
    40.           
    41.         printArr(newArr3);  
    42.           
    43.         System.out.println("------------");  
    44.           
    45.         ifRepeat4(strs);  
    46.   
    47.     }  
    48.       
    49.     public static void printArr(Object[] arr) {  
    50.         for (Object object : arr) {  
    51.             System.out.println(object);  
    52.         }  
    53.     }  
    54.       
    55.       
    56.     //方法一:需要传入一个Object数组,然后返回去重后的数组  
    57.     public static Object[] ifRepeat(Object[] arr){  
    58.         //用来记录去除重复之后的数组长度和给临时数组作为下标索引  
    59.         int t = 0;  
    60.         //临时数组  
    61.         Object[] tempArr = new Object[arr.length];  
    62.         //遍历原数组  
    63.         for(int i = 0; i < arr.length; i++){  
    64.             //声明一个标记,并每次重置  
    65.             boolean isTrue = true;  
    66.             //内层循环将原数组的元素逐个对比  
    67.             for(int j=i+1;j<arr.length;j++){  
    68.                 //如果发现有重复元素,改变标记状态并结束当次内层循环  
    69.                 if(arr[i]==arr[j]){  
    70.                     isTrue = false;  
    71.                     break;  
    72.                 }  
    73.             }  
    74.             //判断标记是否被改变,如果没被改变就是没有重复元素  
    75.             if(isTrue){  
    76.                 //没有元素就将原数组的元素赋给临时数组  
    77.                 tempArr[t] = arr[i];  
    78.                 //走到这里证明当前元素没有重复,那么记录自增  
    79.                 t++;  
    80.             }  
    81.         }  
    82.         //声明需要返回的数组,这个才是去重后的数组  
    83.         Object[]  newArr = new Object[t];  
    84.         //用arraycopy方法将刚才去重的数组拷贝到新数组并返回  
    85.         System.arraycopy(tempArr,0,newArr,0,t);  
    86.         return newArr;  
    87.     }  
    88.       
    89.     /* 
    90.      * 方法二:只需要创建一个集合,然后遍历数组逐一放入集合,只要在放入之前用contains()方法判断一下集合中是否已经存在这个元素就行了,然后用toArray转成数组一切搞定。 
    91.      */  
    92.     public static void ifRepeat2(Object[] arr){  
    93.         //创建一个集合  
    94.         List list = new ArrayList();  
    95.         //遍历数组往集合里存元素  
    96.         for(int i=0;i<arr.length;i++){  
    97.             //如果集合里面没有相同的元素才往里存  
    98.             if(!list.contains(arr[i])){  
    99.                 list.add(arr[i]);  
    100.             }  
    101.         }  
    102.           
    103.         //toArray()方法会返回一个包含集合所有元素的Object类型数组  
    104.         Object[] newArr = list.toArray();  
    105.         //遍历输出一下测试是否有效  
    106.         for(int i=0;i<newArr.length;i++){  
    107.             System.out.println(" "+newArr[i]);  
    108.         }  
    109.   
    110.     }  
    111.     /* 
    112.      * 方法三:最简单的方法就是利用Set集合无序不可重复的特性进行元素过滤。 
    113.      */  
    114.     public static Object[] ifRepeat3(Object[] arr){  
    115.         //实例化一个set集合  
    116.         Set set = new HashSet();  
    117.         //遍历数组并存入集合,如果元素已存在则不会重复存入  
    118.         for (int i = 0; i < arr.length; i++) {  
    119.             set.add(arr[i]);  
    120.         }  
    121.         //返回Set集合的数组形式  
    122.         return set.toArray();  
    123.     }  
    124.       
    125.     /* 
    126.      * 方法四:链表的哈希集合:有顺序,不重复。 
    127.      */  
    128.     public static void ifRepeat4(Object[] arr){  
    129.           
    130.         LinkedHashSet<Object> haoma = new LinkedHashSet<Object>();  
    131.         for (int i = 0; i < arr.length; i++) {  
    132.             haoma.add(arr[i]);  
    133.         }  
    134.           
    135.         // 创建迭代器  
    136.         Iterator<Object> iterator = haoma.iterator();  
    137.         int a = 0;  
    138.         // 迭代集合  
    139.         while (iterator.hasNext()) { // true  
    140.             Object c = iterator.next();  
    141.               
    142.             System.out.println(c);  
    143.         }  
    144.           
    145.           
    146.     }  
    147.       
    148.   
    149. }  
    展开全文
  • 经过一系列的思考与实践,总结出了以下三种不同情形“删除数组重复元素”的解决办法。 1、通过原始数组删除重复元素 方法一:不重新开辟内存(不创建list、set等),可以在原始数组中原地删除重复元素。 由于...
  • 另外注意obeject需要转化为int,且java数组并没有contains()方法。 方法二:运用Set集合 public static int[] quchong(int a[]){ Set set=new HashSet(); for(int i=0;i;i++){ set.add(a[i]); } Object...
  • 普通数组: import java.util.Arrays; public class mytest { public static void main(String[] args) { int [] num=new int[] {1,2,2,33,45,6,3,3,44,3,44,344,55,44,33,45,6,7,8,9,10}; int[] int...
  • // 1,3,5,6,8 } // HashSet(不保证元素的顺序,顺序有可能发生变化) HashSet hashSet = new HashSet(Arrays.asList(arr)); Iterator iterator1 = hashSet.iterator(); List arrList = new ArrayList(); while ...
  • HashSet删除重复元素

    千次阅读 2016-09-07 21:15:11
    应用场景:经常遇到网络请求回来的数据是一个list形式的列表,这个List的数据类型是自自己定义的数据类型,这里面包含了重复元素,而重复元素的判断重复的标准往往是自己定义数据类型的某个成员变量来区分,比如,...
  • Java操控数组删除数组中所有的重复元素,使其数组元素全部唯一,有以下几种方法: 1,使用set(最好想到),set本身就是不重复的集合; package Array_test; import java.util.HashSet; import java.util.Set;...
  •  问题:比如我有一个数组元素个数为0哈),希望添加进去元素不能重复。  拿到这样一个问题,我可能会快速的写下代码,这里数组用ArrayList. privatestaticvoidtestListSet(){ List&...
  • 要求删除重复元素,实际上就是将不重复的元素移到数组的左侧。 假如一个有序数组为 [1,1,1,2,2,3,4,5] 使用双指针法,分别为p和q 在循环遍历过程中,第一轮可以将数组表示为 p在1的位置上q在第二个2的位置上...
  • java 删除数组重复元素

    千次阅读 2012-11-07 19:38:37
    如果你要得到的数组可以无序的话将原数组里的元素放到HashSet中就行了,如果你想得到的数组还要之前的顺序的话,就只能一个个比了,从头开始遍历,看每个元素跟它前面的元素有没有重复有则删掉。 -----------------...
  • import java.util.HashSet;import java.util.Set; public class Test {  /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub String...
  • 由于HashSet可以自动过滤掉重复元素,所以我觉得用java自带的要比手写的效率好 加入由一个数组 a[]; Set s1=new HashSet(); System.out.print("原始数据:"); for(int i=0;i;i++) { System.out.print(a...
  • 按照每个数的个位划分,个位一共有0~9十种情况,我将个位相同的放在同一个链地址中,只需申请一个每个成员为结构体,共有10个成员的数组。这在数据较大时查找前面相同元素能提高很大效率的。 代码如下: #...
  • 当我第一次碰到这个题目的时候,我把它想得很复杂,甚至想到了用算法去删除重复的元素实现它,或者... //声明一个有重复元素数组 String [] str={"a","b","c","d","b","c"}; //使用Arrays.asList将字符串数组转成Li
  • import java.util.List; import java.util.ArrayList; import java.util.Set;...import java.util.HashSet; public class lzwCode { public static void main(String [] args) { te...
  • 数组扩容 以下实例演示了如何在数组初始化后对数组进行扩容: public class Main { public static void main(String[] args) { String[] names = new String[] { "A", "B", "C" }; String[] extend...
  • @Test public void test4() { ... //set.toArray(str) : 将set集合中的元素装到数组中, //注意:该数组和该集合的大小一定要相等!!! String[] sss = set.toArray(str); //return set.toArray(str); return sss; }
  • 给定一个排序数组,你需要在原地删除重复出现的元素,使得每个元素只出现一次,返回移除后数组的新长度。 不要使用额外的数组空间,你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。 示例1: 给...
  • 我们如何从数组中找到重复元素? 你能用 O(n) 复杂度来解决这个问题吗? 不论在日常工作中,或者在面试中,这都是经常遇到的问题; 其实有多种方法可以解决这个问题,在这里我们将讨论两种比较常见的...
  • 一个短数组a,一个长数组b,都为正整数,找出两个数组重复元素,要求不用其他数据结构,时间复杂度与空间复杂度尽量最优 1.最刚的办法: public static void main(String[] args) { int[] a = new int[10000]; ...
  • 存在重复元素 【easy】 给定一个整数数组,判断是否存在重复元素。 如果存在一值在数组中出现至少两次,函数返回 true 。如果数组中每个元素都不相同,则返回 false 。 示例 1: 输入: [1,2,3,1] 输出: true 示例 2...
  • Set<Integer> numSet = new HashSet(); numSet.addAll(numList); System.out.println(numSet); } 方案2: public static void main(String[] args) { String[] s = {"1","10","15","14","111","133",...
  • if(hashSet.find(unsortBuffer[i]) == hashSet.end()) { hashSet.insert(unsortBuffer[i]); } } cout<<"{1,9,3,1,7,3,5,15,12,3}, remove duplicates :"<<endl; for(hash_set<int>::...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 40,195
精华内容 16,078
关键字:

hashset删除数组重复元素