精华内容
下载资源
问答
  • 一个旧数组,一个空的新数组,然后去遍历旧的数组,如果存在重复的元素就保留一个元素并将其添加到新数组中,如果只是一个单独的数组元素,没有其他的重复项,也将其添加到新数组中。 注意: 新数组.indexOf...

    数组的去重

    数组去重原理:
    先有一个旧数组,一个空的新数组,然后去遍历旧的数组,如果存在重复的元素就保留一个元素并将其添加到新数组中,如果只是一个单独的数组元素,没有其他的重复项,也将其添加到新数组中。 注意: 新数组.indexOf(元素) === -1 就是来判断旧数组中的元素是否存在于新数组。
    具体代码如下:
    在这里插入图片描述
    *代码执行结果是:

    • [1, 2, 4, 85, 6, 84, 69]

    递归函数

    递归就是指: 在函数自身自己调用自己
    但是递归函数有一个很明显得问题就是: 如果没有返回条件,会造成死循环
    在这里插入图片描述

    翻转数组

    数组翻转:
           指的是将旧数组的最后一个元素反过来放到新数组的第一个位置上。
    使用递减的方式

    3 ——   0
    2 ——   1
    1 ——   2
    0 ——   3
    以上为旧数组的索引 与 新数组的索引 的对应关系
    

    具体代码如下:
    在这里插入图片描述

    冒泡排序

    冒泡排序采用双重for循环, 第一层的for循环用来指循环的趟数,而第二层的for循环用来指定每一趟交换数据的次数

    具体代码如下:
           升序:
    在这里插入图片描述
           降序:
    在这里插入图片描述
    采用方法的话比较简单,原理还是这个原理:
    具体代码如下:
    在这里插入图片描述
    但是这种有一个缺点,就是如果是个位数的话,还可以进行排序,但如果是两位数或者以上的话,就会排不过来,解决方法如下:
    在这里插入图片描述
    以上情况即为今天面试所接触到的手写代码题
    注:
         此为模拟面试

    展开全文
  • 这题开始一直不会,解题报告,都看不懂,后来还是自己想明白了……其实这个题目的难点就在于重复值不能重复算(假设没有重复值就是一道很水的树状数组题了,甚至都可以不用树状数组),所以这题突破点就是消除重复...

    这题开始一直不会,查解题报告,都看不懂,后来还是自己想明白了……其实这个题目的难点就在于重复值不能重复算(假设没有重复值就是一道很水的树状数组题了,甚至都可以不用树状数组),所以这题突破点就是消除重复值带来的影响。如何消除呢?其实也不难。我们先局部地看这个问题,数据不是一次性加入树状数组里,而是一个个地加。假设有两个查询(1, y1)和(x2, y2)其中y1<y2。假设[1, y1]之间没有重复的数,那么我们把这些数插入一个树状数组里就能解决问题(logn时间查出结果)。然后到了操作(x2,y2),因为y2比y1大,在y1到y2之间可能有些数在[1,y1]已经出现过了,那么我们如何处理呢?没错!删掉前面那个,保留当前这个!(这个不理解的慢慢想,想清楚别的就简单了)这样我们又解决了(x2,y2)的查询,并且树状数组里维护的依然没有重复的数,依此类推,就能解决问题。当然,这是需要离线做的,先把所有数和操作都存起来,把操作按y从小到大排序,按排好的顺序一个个地处理每个操作。

    /*
     * hdu3874/win.cpp
     * Created on: 2012-11-1
     * Author    : ben
     */
    #include <cstdio>
    #include <cstdlib>
    #include <cstring>
    #include <cmath>
    #include <ctime>
    #include <iostream>
    #include <algorithm>
    #include <queue>
    #include <set>
    #include <map>
    #include <stack>
    #include <string>
    #include <vector>
    #include <deque>
    #include <list>
    #include <functional>
    #include <numeric>
    #include <cctype>
    using namespace std;
    const int MAXN = 50100;
    const int MAXQ = 2000010;
    typedef long long typec;
    typedef struct Query{
        int pos, x, y;
        typec result;
    }Query;
    inline bool cmppos(const Query &q1, const Query &q2) {
        return q1.pos < q2.pos;
    }
    inline bool cmpy(const Query &q1, const Query &q2) {
        return q1.y < q2.y;
    }
    inline int lowbit(int x) {
        return x & (-x);
    }
    int N, Q;
    Query query[MAXQ];
    map<int, int> lastpos;
    typec data[MAXN];//存储数据,下标从1开始
    int inputdata[MAXN];
    //查询data[1...pos]的和
    typec sum(int pos) {
        typec ret = 0;
        for(int i = pos; i > 0; i -= lowbit(i)) {
            ret += data[i];
        }
        return ret;
    }
    //修改data[pos]的值,在原来基础上加value
    void modify(int pos, typec value) {
        for (int i = pos; i <= N; i += lowbit(i)) {
            data[i] += value;
        }
    }
    void insert(int pos, int value) {
        if(lastpos[value] != 0) {
            modify(lastpos[value], -value);
        }
        lastpos[value] = pos;
        modify(pos, value);
    }
    int main() {
    #ifndef ONLINE_JUDGE
        freopen("data.in", "r", stdin);
    #endif
        int T;
        scanf("%d", &T);
        while(T--) {
            lastpos.clear();
            scanf("%d", &N);
            for(int i = 1; i <= N; i++) {
                scanf("%d", &inputdata[i]);
            }
            scanf("%d", &Q);
            for(int i = 0; i < Q; i++) {
                scanf("%d%d", &query[i].x, &query[i].y);
                query[i].pos = i;
            }
            sort(query, query + Q, cmpy);
            fill(data, data + N + 1, 0);
            int I = 1;
            for(int i = 0; i < Q; i++) {
                while(I <= query[i].y && I <= N) {
                    insert(I, inputdata[I]);
                    I++;
                }
                query[i].result = sum(query[i].y) - sum(query[i].x - 1);
            }
            sort(query, query + Q, cmppos);
            for(int i = 0; i < Q; i++) {
                printf("%I64d\n", query[i].result);
            }
        }
        return 0;
    }

    转载于:https://www.cnblogs.com/moonbay/archive/2012/11/01/2750231.html

    展开全文
  • 04-集合---list、Set

    2019-09-09 16:46:06
    list:元素有序,可以重复,因为这个list索引。 set:元素无序,元素不可以重复没有索引。 ###ArrayList: 底层是数组结构。查询快,增删慢。(因为插入或者删除的时候,所改变元素以及后面的所有元素都要跟着...

    ###Conllection:

    list:元素有序,可以重复,因为这个list有索引。
    set:元素无序,元素不可以重复,没有索引。

    ###ArrayList:
    底层是数组结构。查询快,增删慢。(因为插入或者删除的时候,所改变元素以及后面的所有元素都要跟着一起动,改变自己原先的索引。元素少不明显,元素越多越明显)线程不同步。 ArrayList初始数组的长度是10,超过了10会new一个新的数组长度会50%延长 也就是变成15,并把之前元素拷贝到新的数组中,并把新元素添加到后面去。
    LinkedList:底层用的是链表。查询慢,增删快。(因为链表中每一个元素只记得自己前后面的元素,一个一个的查下去就很慢,但是增删的时候这个特点就变成了优势。)
    vector:底层是数组结构,线程同步。无论是正删改查都很慢,被ArryList替代了。它如果长度超过了会100%延长.

    List特有方法:凡是可以操作角标的都是list特有的方法

    #####增:
    //向集合当中添加元素,参数的类型和泛型一致
    add(index,element);
    addAll(index,collection);添加一堆元素。
    #####删:
    //从集合当中删除元素,参数是索引编号,返回值级是被删掉的元素。
    remove(int index);
    #####改:
    set(index,element);
    #####查:
    //从集合中获取元素,参数是索引编号,返回值就是对应位置的元素。
    get(int index);
    subList(form,to);
    listIterator();
    #####获取集合尺寸:

    集合名称.size();获取集合尺寸长度,返回值是集合中包含的元素个数。
    

    #####遍历list集合

    public static void main (String[] args){
        ArrayList <Strring> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        //遍历集合
        for(int i = 0; i < list.size () ; i ++ ){
           System.out.println(list.get(i));
      }
    }
    

    #####LinkedList特有方法:

    addFirst();
    addLast();
    
    //获取元素,但不删除元素,如果集合中没有元素,会提示NoSuchElementException
    getFirst();
    getLast();
    
    //获取元素:但是元素被删除,如果集合没有元素,会提示NoSuchElementException
    removeFirst();
    removeLast();
    
    在jdk1.6出现了替代方法
    offerFirst();
    offerLast();
    
    //获取元素,但是被删除元素,如果元素集合中没有。就返回null。
    peekFirst();
    peekLast();
    
    //获取元素,但是元素被删除,如果集合中没有元素。就返回null。
    pollFirst();
    pollLast();
    

    List集合特有的迭代器,ListIterator是Iterator的子接口
    在迭代时 不可以通过集合对象的方法操作集合中的元素,因为会发生并发修改异常,所以在迭代器时 只能用迭代器的方法操作元素,可是Iterator方法是有限的,只能对元素进行判断,去除,删除的操作,如果想要其他的操作,比如添加修改就需要使用其子接口,listIterator。该接口只能通过list集合的listIterator方法获取。

    public static void main (String[] args){
        ArrayList al = new ArrayList();
        //添加元素
      al.add("java1");
      al.add("java2");
      al.add("java3");
      al.add("java4");
      sout("原方法集合是"+al);
     //原方法集合是:[java1,java2,java3,java4]
    
    
      //在指定元素位置添加元素。
      al.add(1,"java10086");
      sout("指定以后"+al);
      //指定以后:[java1,java10086,java2,java3,java4]
    
      //删除指定的位置元素
      al.remove(2);
      sout("删除指定位置元素后:"+al);
     //删除指定位置元素后:[java1,java10086,java3,java4]
    
      //修改元素
      al.set(2,"java999");
      sout("修改指定元素后:"+al);
    //修改指定元素后:[java1,java10086,java999,java4]
    
    //通过角标查取元素。
    al.get(1);
    sout("获取第1号角标的元素是:"+al);
    //获取第1号角标的元素是:[java10086]
    
    
    //获取全部元素
    for(int x=0;x<al.size();x++){
        sout("al("+x+")="+al);
        }
    }
    //al(0)=java1
    //al(1)=java10086
    //al(2)=java999
    //al(3)=java4
    
    //通过indeexOf获取对象的位置
    sout("index="+al.indexof("java999"));
    //获取索引位置1到3(不包含3)的元素
    List sub = al.subList(1,3);
    sout("sub="+sub);
    //index=2
    //sub=[java10086,java999]
    
    

    ###set:元素无序,元素不可以重复,没有索引。
    HashSet:数据结构是哈希表,线程是非同步。保证元素唯一性的原理是判断元素的hashCode值是否相同。如果相同,还会继续判断元素的equals方法时候为true。
    TreeSet:可以对set集合中的元素进行排序。一般会默认ASC码进行排序。底层数据结构是二叉树。保证元素唯一性的一句 compareTo方法return0。

    TreeSet排序的第一种方式:让元素自身具备比较性,元素需要实现Comparable接口,覆盖compareTo方法,这种方式也成为元素的自然排序,或叫做默认排序。

    TreeSet的第二种排序方式:当元素自身不具备比较性时,或者具备的比较性不是所需要的,这时就需要让集合自身具备比较性。在集合初始化时就有了比较方式,

    展开全文
  • 36、数组有没有length()这个方法? String有没有length()这个方法? 24 37、下面这条语句一共创建了多少个对象:String s="a"+"b"+"c"+"d"; 24 38、try {}里有一个return语句,那么紧跟在这个try后的finally {}里的...
  • 1、ArrayList:底层使用的是动态数组实现的数据结构(特点是:查询快,增删慢),默认大小是10,使用的时候时会先判断对象的大小有没有等于或者大于默认(或者是自己定义)的对象大小,如果对象要是等于或者大于的话...

    List 和 set是 都是继承(extends) Collection 这个接口

    List主要常用分为(List元素是可以重复的)
    • 1、ArrayList:底层使用的是动态数组实现的数据结构(特点是:查询快,增删慢),默认大小是10,使用的时候时会先判断对象的大小有没有等于或者大于默认(或者是自己定义)的对象大小,如果对象要是等于或者大于的话,arrayList就会实行扩容,新建一个数组对象是原来定于或者默认的1.5倍(ArrayList默认1.5倍扩容,这里也不知道为什么是1.5倍可能觉得1.5倍比较好权衡把),然后再把原先的对象复制到新里面去。

    • 2、linkedList:底层使用的是双向链表的数据结构(特点是:增删快,查询慢)

    Set主要常用分为(Set元素是不可以重复的)

    • 1、HashSet:实现原理其实是HashMap,HashSet得key就是value
    • 2、TreeSet:实现原理其实是TreeMap
    Map(Key、Value的形式保存数据)
    • HashMap:(线程不安全的) 底层使用的是(jdk7的时候用的是数组+链表的形式(hashMap数组是主体,链表是为了解决哈希冲突而存在的)jdk8的时候多了个红黑树)默认大小是16,使用的时候时会判断对对象大小有没有到默认大小(或者是自己定义的大小)的0.75,要是超过了,就会进行扩容机制,扩容的大小是原先的2倍(为什么时2倍呢? 主要好像是幂的平方是最大程度是避免hash碰撞)

    • 往hashMap中put元素的时候,会根据key来计算hash值,根据hash值来获取对应的下标,如果要是这个这个下标的位置已经存放其他的元素,那就将这个位置的元素以链表的形式存储,新进来的放在链表头(先进后出),如果该下标没有其他元素,就之间存入到该位置。当链表长度大于阈值(默认为8)时,将链表转化为红黑树,以减少搜索时间。

    ----- hash碰撞:不一样的对象但是hash值是一样的,

    假设:hash表的大小为4(即有4个槽),现在要把一串数据存到表里:5,48,33,15 假设计算:hash(5)=2, 所以数据5应该放在hash表的第2个槽里;hash(48)=1,所以数据48应该放在hash表的第1个槽里; hash(33)=1,也就是说,数据33也应该放在hash表的第1个槽里——于是就造成了碰撞(也称为冲突,collision)。 主要得解决:开放定址(用链表或者红黑树存一起)、再哈希法(重新计算hash值)、链地址法(完后找空位)

    ------红黑树

    是一种特定类型的二叉树,是数据结构里面的一种结构

    展开全文
  •  ArrayList 和Vector都是使用数组方式存储数据,此数组元素数大于实际存储的数据以便增加和插入元素,它们都允许直接按序号索引元素,但是插入元素要涉及数组元素移动等内存操作,所以索引数据快而插入数据慢,...
  • java面试题(上)

    2018-12-14 10:15:00
    如果没有做过技术亮点的事,每天都在做增删改功能或重复性的工作,需要好好反思下,这样下去技术上没有多少增长。如果工作中就是做这个怎么办?可以考虑利用业余时间参与开源项目或自己做一些工具或框架。 2: ...
  • 如果没有做过技术亮点的事,每天都在做增删改功能或重复性的工作,需要好好反思下,这样下去技术上没有多少增长。如果工作中就是做这个怎么办?可以考虑利用业余时间参与开源项目或自己做一些工具或框架。  2:...
  • Java中文本文件的读取(按行读取)

    万次阅读 多人点赞 2018-04-29 18:14:44
    这样周而复始,并没有将知识积累下来,其实是把自己给坑了(对此深体会)。因此经过两天的学习,对文件读取这一方面了一定的了解,写下博客,总结一些东西,以备后续查询。文本文件读取的大致过程如下:构建文件...
  • 长整数的乘法运算

    2020-06-20 18:28:44
    所以如果需要计算100位的数字相乘, 因为编程本身是不支持存储这么大数字的, 所以就需要自己实现, 当然了, 各个编程语言都大数的工具包, 何必重复造轮子, 但我还是忍不住好奇他们是如何实现的, 虽然最终没有翻到...
  • 学习算法这东西,还是要考积累,没有量变是不可能质变的。还有的人选择看书,这是一个不错的选择。但是很多人选了过时的或者质量差的书,又或者不会去写书中给的练习题,导致效果很差。 基于这几个原因,我组织了...
  • 这样周而复始,并没有将知识积累下来,其实是把自己给坑了(对此深体会)。因此经过两天的学习,对文件读取这一方面了一定的了解,写下博客,总结一些东西,以备后续查询。文本文件读取的大致过程如下:构建文件...
  • 这样周而复始,并没有将知识积累下来,其实是把自己给坑了(对此深体会)。因此经过两天的学习,对文件读取这一方面了一定的了解,写下博客,总结一些东西,以备后续查询。文本文件读取的大致过程如下:构建文件...
  • javascript入门笔记

    2018-05-15 15:01:07
    特点 :将 a 和 b 转换为 二进制,按位比较,对应位置的数字,至少一位为1的话,那么该为的整体结果就为1,否则为 0 ex : 5 | 3 101 011 ======== 111 结果为 :7 适用场合:任何小数与0 做 按位或的操作...
  • 你必须知道的495个C语言问题

    千次下载 热门讨论 2015-05-08 11:09:25
    5.15 有没有什么简单点儿的办法理解所有这些与空指针有关的东西呢? 5.16 考虑到有关空指针的所有这些困惑,要求它们的内部表示都必须为0不是更简单吗? 5.17 说真的,真有机器用非零空指针吗,或者不同类型用...
  • 4.1.7 有没有有顺序的Map实现类,如果有,他们是怎么保证有序的。 4.1.8 抽象类和接口的区别,类可以继承多个类么,接口可以继承多个接口么,类可以实现多个接口么。 4.1.9 继承和聚合的区别在哪。 4.2.0 IO模型有...
  • 《你必须知道的495个C语言问题》

    热门讨论 2010-03-20 16:41:18
    5.15 有没有什么简单点儿的办法理解所有这些与空指针有关的东西呢? 60 5.16 考虑到有关空指针的所有这些困惑,要求它们的内部表示都必须为0不是更简单吗? 60 5.17 说真的,真有机器用非零空指针吗,或者不同...
  • 5.15 有没有什么简单点儿的办法理解所有这些与空指针有关的东西呢? 60 5.16 考虑到有关空指针的所有这些困惑,要求它们的内部表示都必须为0不是更简单吗? 60 5.17 说真的,真有机器用非零空指针吗,或者不同...
  • 实例074 利用指针过滤数组重复数据 实例075 使用Split函数分隔明日公司网址 第4章 程序常用算法 4.1 计算类算法 实例076 最大公约数和最小公倍数 实例077 杨辉三角 实例078 输出100以内的素数 实例079 ...
  • 实例074 利用指针过滤数组重复数据 实例075 使用Split函数分隔明日公司网址 第4章 程序常用算法 4.1 计算类算法 实例076 最大公约数和最小公倍数 实例077 杨辉三角 实例078 输出100以内的素数 实例079 ...
  • 12.9 有没有办法从一个或多个函数中跳出? 12.10 什么是信号(signal)?用信号能做什么? 12.11 为什么变量名不能以下划线开始? 12.12 为什么编译程序提供了两个版本的malloc()函数? 12.13 适用于整数和浮点数...
  • java面试宝典2012版.pdf

    2012-11-08 19:53:04
    36、数组有没有length()这个方法? String有没有length()这个方法? 37、下面这条语句一共创建了多少个对象:String s="a"+"b"+"c"+"d"; 38、try {}里有一个return语句,那么紧跟在这个try后的finally {}里的code会...
  • 最新Java面试宝典pdf版

    热门讨论 2011-08-31 11:29:22
    36、数组有没有length()这个方法? String有没有length()这个方法? 24 37、下面这条语句一共创建了多少个对象:String s="a"+"b"+"c"+"d"; 24 38、try {}里有一个return语句,那么紧跟在这个try后的finally {}里的...
  • 如果数组中检测到一个元素不满足,则整个表达式返回<code>false</code>,且剩余的元素不再检查。如果所有的元素都满足条件,则返回<code>true。 </li><li> <p>some(fn(currentValue,index,arr),...
  • Java面试宝典-经典

    2015-03-28 21:44:36
    36、数组有没有length()这个方法? String有没有length()这个方法? 24 37、下面这条语句一共创建了多少个对象:String s="a"+"b"+"c"+"d"; 24 38、try {}里有一个return语句,那么紧跟在这个try后的finally {}里的...
  • 避免没有必要的循环处理、重复处理; ●资源损耗(空间):设计尽量节约资源(内存、数组、链表等);不用的资源要及时释放; ●初始化: 变量、数组、内存块、链表节点(其next要置NULL)等都要初始化; ●健壮...
  • 避免没有必要的循环处理、重复处理; ●资源损耗(空间):设计尽量节约资源(内存、数组、链表等);不用的资源要及时释放; ●初始化: 变量、数组、内存块、链表节点(其next要置NULL)等都要初始化; ●健壮性...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 129
精华内容 51
关键字:

数组查自己有没有重复