1)实现一个Memcpy函数
2STLvector的实现原理 (衍生: Map, Set等实现原理)
3)给定N张扑克牌和一个随机函数,设计一个洗牌算法
425匹马, 5个跑道,最少多少次能得出前3名?前5名?
5)进程和线程有什么区别?
6100亿个整数,内存足够,如何找到中位数?内存不够,如何找到中位数?
7Java垃圾回收机制

//1
  1 #include<stdio.h>
  2 #include<assert.h>
  3 void *Memcpy(void* dest,void* src,size_t size)
  4 {
  5     assert(dest&&src);
  6     void* ret=dest;
  7     char* str1=(char*)dest;
  8     char* str2=(char*)src;
  9     while(size--)
 10     {
 11         *str1++=*str2++;
 12     }
 13     return ret;
 14 
 15 }
 16 int main()
 17 {
 18     char arr1[12]="abcdef";
 19     char arr2[12]="helloworld";
 20     printf("arr1: %s   arr2: %s\n",arr1,arr2);
 21     Memcpy(arr1,arr2,sizeof(arr1));
 22     printf("arr1: %s   arr2: %s\n",arr1,arr2);
 23     Memcpy(arr1,arr2,sizeof(arr1));

2.

vector();
vector( size_type num, const TYPE &val );
vector( const vector &from );
vector( input_iterator start, input_iterator end );

 C++ Vectors可以使用以下任意一种参数方式构造:

  • 无参数 - 构造一个空的vector,

  • 数量(num)和值(val) - 构造一个初始放入num个值为val的元素的Vector

  • vector(from) - 构造一个与vector from 相同的vector

  • 迭代器(start)和迭代器(end) - 构造一个初始值为[start,end)区间元素的Vector(注:半开区间). 

void assign( input_iterator start, input_iterator end );
void assign( size_type num, const TYPE &val );

assign() 函数要么将区间[start, end)的元素赋到当前vector,或者赋num个值为val的元素到vector中.这个函数将会清除掉为vector赋值以前的内容.

  TYPE at( size_type loc );

at() 函数 返回当前Vector指定位置loc的元素的引用. at() 函数 比 [] 运算符更加安全, 因为它不会让你去访问到Vector内越界的元素.

iterator erase( iterator loc );  iterator erase( iterator start, iterator end );
erase函数要么删作指定位置loc的元素,要么删除区间[start, end)的所有元素.返回值是指向删除的最后一个元素的下一位置的迭代器.
//补全删除值为1的元素
for(vector<int>::iterator  it=arr.bgin();it!=arr.end();)
{
     if(*it==1)
          erase(it);
     it++;
}

3.

#include <iostream>  
#include <time.h>  
using namespace std;  
  
void swap(int &a, int &b){  
    int t = a;  
    a = b;  
    b = t;  
}  
  
void randomShuffle(int a[], int n){  
    for(int i = 0; i < n; ++i){  
        int j = rand() % (n - i) + i;  
        swap(a[i], a[j]);  
    }  
}  
  
int main(){  
    srand((unsigned)time(NULL));  
    int n = 9;  
    int a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};  
    randomShuffle(a, n);  
    for(int i = 0; i < n; ++i)  
        cout << a[i] << endl;  
    return 0;  
}


4.先分成5组A,B,C,D,E 跑5次 (后面A1代表A组第一名 B2代表B组第二名)
然后将5组的第一名跑一次 假设这一次的速度A1>B1>C1>D1>E1 这样第一名中跑的最慢的两匹 所在的组 将全部被淘汰(因为这一组的第一名都没有进前三甲)即D组 E组 10匹马全部被淘汰
A1肯定是最快的马 然后用跑第一的那组的二三名 跑第二的那组的一二名 和跑第三的那组的第一名 再跑一次(这是第7次比赛):即用A2 A3 B1 B2 C1再跑一次 (其中B1>C1)这次的前两名则是速度第二第三的马

5.线程的划分尺度小于进程,使得多线程程序的并发性。

另外,进程在执行过程中拥有独立的内存单元,而多个线程共享内存,从而极大地提高了程序的运行效率。线程的划分尺度小于进程,使得多线程程序的并发性。 
另外,进程在执行过程中拥有独立的内存单元,而多个线程共享内存,从而极大地提高了程序的运行效率。 
线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行,必须依存在应用程序中,由应用程序提供多个线程执行控制。 

从逻辑角度来看,多线程的意义在于一个应用程序中,有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用,来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。 

(Process)是最初定义在Unix等多用户、多任务操作系统环境下用于表示应用程序在内存环境中基本执行单元的概念。以Unix操作系统为例,进程是Unix操作系统环境中的基本成分、是系统资源分配的基本单位。Unix操作系统中完成的几乎所有用户管理和资源分配等工作都是通过操作系统对应用程序进程的控制来实现的。 

6.内存足够的情况: 可以使用类似quick sort的思想进行,均摊复杂度为O(n),算法思想如下: 
随机选取一个元素,将比它小的元素放在它左边,比它大的元素放在右边 
如果它恰好在中位数的位置,那么它就是中位数,可以直接返回 
如果小于它的数超过一半,那么中位数一定在左半边,递归到左边处理 
否则,中位数一定在右半边,根据左半边的元素个数计算出中位数是右半边的第几大,然后递归到右半边处理 
内存不足的情况: 
方法:分法 
思路:一个重要的线索是,这些数都是整数。整数就有范围了,32位系统中就是[-2^32, 2^32- 1], 有了范围我们就可以对这个范围进行二分,然后找有多少个数于Mid,多少数大于mid,然后递归,和基于quicksort思想的第k大方法类似 

方法二:分桶法 思路:化大为小,把所有数划分到各个小区间,把每个数映射到对应的区间里,对每个区间中数的个数进行计数,数一遍各个区间,看看中位数落在哪个区间,若够小,使用基于内存的算法,否则 继续划分

7.Java的垃圾回收机制是Java虚拟机提供的能力,用于在空闲时间以不定时的方式动态回收无任何引用的对象占据的内存空间。

需要注意的是:垃圾回收回收的是无任何引用的对象占据的内存空间而不是对象本身。
在C++中,对象所占的内存在程序结束运行之前一直被占用,在明确释放之前不能分配给其它对象;而在Java中,当没有对象引用指向原先分配给某个对象的内存时,该内存便成为垃圾。JVM的一个系统级线程会自动释放该内存块。垃圾回收意味着程序不再需要的对象是"无用信息",这些信息将被丢弃。当一个对象不再被引用的时候,内存回收它占领的空间,以便空间被后来的新对象使用。事实上,除了释放没用的对象,垃圾回收也可以清除内存记录碎片。由于创建对象和垃圾回收器释放丢弃对象所占的内存空间,内存会出现碎片。碎片是分配给对象的内存块之间的空闲内存洞。碎片整理将所占用的堆内存移到堆的一端,JVM将整理出的内存分配给新的对象。
  垃圾回收能自动释放内存空间,减轻编程的负担。这使Java 虚拟机具有一些优点。首先,它能使编程效率提高。在没有垃圾回收机制的时候,可能要花许多时间来解决一个难懂的存储器问题。在用Java语言编程的时候,靠垃圾回收机制可大大缩短时间。其次是它保护程序的完整性, 垃圾回收是Java语言安全性策略的一个重要部份。

  垃圾回收的一个潜在的缺点是它的开销影响程序性能。Java虚拟机必须追踪运行程序中有用的对象,而且最终释放没用的对象。这一个过程需要花费处理器的时间。其次垃圾回收算法的不完备性,早先采用的某些垃圾回收算法就不能保证100%收集到所有的废弃内存。当然随着垃圾回收算法的不断改进以及软硬件运行效率的不断提升,这些问题都可以迎刃而解。