精华内容
下载资源
问答
  • JavaScript 判断两个数组是否相等 或者 判断一个数组中是否有重复元素

    //判断两个数组是否相等:
    var aArray1 = ["1","I","2","N","3","S"],aArray2 = ["1","I","2","N","3","S"];
    if(aArray1.sort().toString() == aArray2.sort().toString()){
        alert("相等");
    }
    else{
       alert("不相等");
    }


    判断一个数组中是否有重复的元素:
    var aTitleList = ["1","I","2","N","3","S"],bRepeat = false;
    $.each(aTitleList.sort(), function (iIndex, sItem) {
       if (iIndex + 1 < aTitleList.length) {
          if (aTitleList[iIndex] == aTitleList[iIndex + 1]) {
             bRepeat = true;
            alert("有重复元素" + sItem);
             //return false;
          }
       }
    });
    if(bRepeat){
       alert("有重复元素!");
    }
    else{
       alert("没有重复元素!");
    }

    展开全文
  • function isRepeat(arr){ var hash = {}; for(var i in arr) { if(hash[arr[i]]) return true; hash[arr[i]] = true; } return false; }
    function isRepeat(arr){  
         var hash = {};  
         for(var i in arr) {
             if(hash[arr[i]])
                  return true; 
             hash[arr[i]] = true;  
         }  
         return false;  
    }  
    展开全文
  • 实现判断数组中是否包含有重复元素方法 这里用C#代码给出实例 方法一:可以新建一个hashtable利用hashtable的Contains方法进行查找 1 /// <summary> 2 /// Hashtable 方法 3 /// </summary>....

     如何判断一个数组中是否有重复的元素 

    实现判断数组中是否包含有重复的元素方法 这里用C#代码给出实例

    方法一:可以新建一个hashtable利用hashtable的Contains方法进行查找

     1         /// <summary>
     2         /// Hashtable 方法
     3         /// </summary>
     4         /// <param name="array"></param>
     5         /// <returns></returns>
     6         public static bool IsRepeat(int[] array)
     7         {
     8             Hashtable ht = new Hashtable();
     9             for (int i = 0; i < array.Length; i++)
    10             {
    11                 if (ht.Contains(array[i]))
    12                 {
    13                     return true;
    14                 }
    15                 else
    16                 {
    17                     ht.Add(array[i], array[i]);
    18                 }
    19             }
    20             return false;
    21         }

    方法二:使用for循环进行比较  需要注意的是j<=i    如果只是等于,实际上效率偏低,有重复计算可以自己摸索,有时间我画个图出来,^_^(这里感谢面试官的提醒)

     1         /// <summary>
     2         /// for循环
     3         /// </summary>
     4         /// <param name="yourValue"></param>
     5         /// <returns></returns>
     6         public static bool IsRepeat2(int[] array)
     7         {
     8             for (int i = 0; i < array.Length; i++)
     9             {
    10                 for (int j = 0; j < array.Length; j++)
    11                 {
    12                     if (j <= i)
    13                     {
    14                         continue;
    15                     } 
    16                     if (array[i] == array[j])
    17                     {
    18                         return true;
    19                     }
    20                 }
    21             }
    22             return false;
    23         }

    测试代码:

     1         static void Main(string[] args)
     2         {
     3             int[] array = new int[] { 1,2,3,4,3,6,7,8};
     4             int[] array2 = new int[] { 1, 2, 3, 4, 5, 6, 7, 8 };
     5             Console.WriteLine("---------------包含重复元素----------------");
     6             bool isrepeat = IsRepeat(array);
     7             bool isrepeat2 = IsRepeat2(array);
     8             Console.WriteLine(isrepeat);
     9             Console.WriteLine(isrepeat2);
    10 
    11             Console.WriteLine("---------------不包含重复元素----------------");
    12             bool isrepeat3 = IsRepeat(array2);
    13             bool isrepeat4 = IsRepeat2(array2);
    14             Console.WriteLine(isrepeat3);
    15             Console.WriteLine(isrepeat4);
    16             Console.Read();
    17         }

    运行结果:

    程序源代码工程下载

    各位好汉如果有更好的方法能够优化程序,减少计算的次数,麻烦给出,感激!

    转载于:https://www.cnblogs.com/JiYF/p/8799492.html

    展开全文
  • 判断一个数组是否有重复元素

    千次阅读 2018-06-25 20:29:52
    数组长度为n,数的范围{0,n-1};数组元素随机排放,可能重复值,怎样判断是否有重复元素?下面说明一下思路,这问题各种办法都可以解决,但是算法的复杂度和性能上却各不相同,最笨的办法就是逐个比较。 ...

    数组长度为n,数的范围{0,n-1};数组元素随机排放,可能有重复值,怎样判断是否有重复元素?下面说明一下思路,这个问题各种办法都可以解决,但是算法的复杂度和性能上却各不相同,最笨的办法就是逐个比较。
    下面介绍一下我的思路:
    (1)采用TreeSet对数组进行排序,排好序后计算TreeSet中元素个数,如果元素个数有变化(减少),证明重复元素没有加入,所以就可以判断元素有重复,因为TreeSetSet接口实现,底层是二叉树,保证了唯一性,重复元素不会加入到TreeSet中,但是这种会增加空间的开销。
    (2)使用快排可以解决,快排的时间复杂度为O(nlogn),当然也可以有其他复杂度更好的算法来解决。快排就是选中一个基准元素,小于基准元素的往前移动,大于基准元素的往后移动,形成两个子序列,对两个子递归序列做同样的快排操作,这里采用两头逼近的办法进行快排。直到在比较的过程中发现谋一个元素与基准元素相等就可以判定有重复元素。快排采用递归容易栈溢出,而且短的序列采用快排并不比一些简单的算法效率高,所以在子序列长度在某个设定的M值内时可以采用直接插入排序或者折半插入排序等一些简单的排序算法,同样在比较的过程中如果有相等元素则可以判定数组有重复元素。下面附上Java代码供大家参考:

    import java.util.Scanner;
    import org.junit.Test;
    public class Main8 {
        /**
         * 快排一趟划分过程
         * @param a 要排序的数组
         * @param low 子序列左边界下标
         * @param high 子序列右边界下标
         * @return 
         *      返回值不小于0,证明该趟排序没有重复元素,并且返回值就是基准元素要插入的位置,
         *如果返回值为-1,证明该趟排序有重复元素 
         */
        public static int partition(int []a,int low,int high){
            int key=a[low];
            while(low<high){
                while(low<high&&a[high]>=key){
                    if(a[high]==key){
                        return -1;//返回-1说明有重复元素
                    }
                    high--;
                }
                a[low]=a[high];
    
                while(low<high&&a[low]<=key){
                    if(a[low]==key){
                        return -1;//返回-1说明有重复元素
                    }
                    low++;
                }
                a[high]=a[low];
            }
            a[low]=key;
            return low;
        }
        /**
         * 快排算法
         * @param a 带排序数组
         * @param left 待排序列左边界下标
         * @param right 待排序列右边界下标
         * @param flag 如果快排结束后,flag中包含true,则说明有重复元素(这里选择StringBuffer作为标志,主要是为了以引用作为形参)
         */
        public static void quickSort(int [] a,int left,int right, StringBuffer flag){
            if(right-left==0){//如果子序列长度等于1,结束递归,说明已经排好序
                return ;
            }
            //基准元素下标
            int middleIndex=partition(a, left, right);
            if(middleIndex==-1){
                flag.append("true");
                return;
            }
            quickSort(a, left, middleIndex-1,flag);
            quickSort(a, middleIndex+1, right,flag);
        }
    
        /**
         * 判断数组a是否有重复元素
         * @param a 待判断数组
         * @return 返回true则有重复元素
         */
        public boolean isDoubleOrMore(int [] a){
            StringBuffer flag = new StringBuffer();
            int left=0;
            int right=a.length-1;
            quickSort(a, left, right, flag);
            if(flag.toString().contains("true")){
                return true;
            }
            return false;
        }
    
        @Test
        public void test(){
            Scanner sc=new Scanner(System.in);
            System.out.println("请输入数组长度");
            int n=sc.nextInt();
            System.out.println("请输入数组元素");
            int []a=new int[n];
            for (int i = 0; i < a.length; i++) {
                a[i]=sc.nextInt();
            }
            System.out.println(isDoubleOrMore(a));
    
        }
    }

    写在后面的话,由于快排这里采用的是递归,所以该算法在序列特别大的情况下可能会出现栈溢出,也就是递归过深造成的,我前几篇博客中有关于改进快排的算法,只需要在子序列长度规模在某个指定的范围内使用一些简单的排序算法就可以避免递归层级过深。

    展开全文
  • 判断数组中是否存在重复元素:   import org.apache.commons.lang.ArrayUtils; public boolean isDupInArray(Object[] array) { if (ArrayUtils.isEmpty(array) == true) { return false; ...
  • 判断数组中是否有重复元素,如果有重复元素输出Yes,否者输出No。 解题思路: 采用计数器原理。 例: 输入:1,3,2,5,6,4 输出:Yes #include <iostream> using namespace std; void print(bool b){ ...
  • 给定一个数组,判定该数组中是否有重复元素。 判定该数组中是否有重复元素总结出以下实现方案: using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace Demo...
  • 一个函数判断一个int类型的数组是否是有效的。  所谓有效是指:假设数组大小为n,那么这个int数组里的值为0~n-1之间的数,并且每个数只能出现一次,否则就是无效数组。  例如[5,3,1,4,2,0]是有效的,[5,3,5,1,2,0...
  • 转:... arr=[1,3,4,5,6,75,7,8]; %通过unique函数去除数组中相同的元素,然后比较俩个数组的长度 uniq=length(arr)-length(unique(arr)); %如果结果为0.则说明俩个数组中的没有相同的元素 % if...
  • Javascript判断一个数组中是否有重复值的三种方法: 判断重复方法一,转为字符串 进行比较: var ary = new Array("aaa","cc","dd","aaa"); var s = ary.join(",")+","; for(var i=0;i<ary.length;i++) { if(s....
  • 主要介绍了JS判断数组是否有重复元素的方法,结合实例形式分析了javascript针对数组重复元素判断相关的遍历、排序、递归等相关操作技巧,需要的朋友可以参考下
  • Javascript判断一个数组中是否有重复值的三种方法: 判断重复方法一,转为字符串 进行比较: var ary = new Array("aaa","cc","dd","aaa"); var s = ary.join(",")+","; for(var i=0;i;i++) { if(s.replace(ary[i]+...
  • 1、若数组中有重复元素,其排序后两个重复元素是相邻的。 故我们遍历数组判断arr[i]==arr[i+1]?, 2、删除时,定义一个双指针,i指向数组头部,、用j遍历数组,如果num[i]!=num[j],将num[j]放到nums[i]中 /** * ...
  • 217 判断数组中是否存在重复元素 Easy 例题2. 219 判断数组中是否存在重复元素II Easy 例题1. 217 判断数组中是否存在重复元素 Easy 例题2. 219 判断数组中是否存在重复元素II Easy 【题目】 【分析】 ...
  • 1.如果是数组转为List集合  List&lt;String&gt; lists = Arrays.asList( String[] );...新建一个set集合  Set&lt;String&gt; set = new HashSet&lt;String&gt;(); 2.循环往这个set集...
  • * 实现判断某字符串数组中是否有重复元素。 * 请自行拟定合适的方法名称, * 实现方法自行选择, * 可实现要求即可; * 例如:public boolean 方法名(String[] strArray){....} * */ public class Test24 { ...
  • 1.先将数组用sort进行排序,排序之后进行前后比较; let arry=['arr1','arr2','rt','tr','rt','11',11] let nary=arry.sort() console.log(nary) for(let i = 0; i < nary.length - 1; i++) { ...
  • 方法一: //将数组转换成字符串,遍历数组,移除一个元素後若还能找到该元素,那么这个元素就是重复的 ... alert("数组中有重复元素:" + ary[i]); break; } } 方法二: //对数组进行排序,查上一个和下一个是..
  • 给定一个长度为N的数组,其中每个元素的取值范围都是1~N,判断数组中是否有重复的数字 问题分析: 1.最简单暴力的方法是用双层嵌套对每两个数字进行比较,看是否相等但是时间复杂度太高,不予采用。 2.也可以先排...
  • java判断数组中是否存在重复元素 import java.util.HashSet; public class test2 { public static boolean cheakIsRepeat(int[] array) { HashSet<Integer> hashSet = new HashSet<Integer>(); for...
  • 点击此处返回总目录 【题目】 【方法】 使用Has...
  • 判断数组中是否存在重复元素;数组查重;
  • 我们很容易想到的就是遍历所有数字,然后比较是否有相同的,但这样很容易超时,可以先排序,然后比较数组前后的数字,如果相同,则出现重复元素。在这里采用C++的STL的set来完成,将数组中的数字赋值给set,set会...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 236,804
精华内容 94,721
关键字:

判断一个数组中是否有重复的元素