youngyoungla

#include#includeint search(int a[],int i,int len){ int start,end,mid; start=0; end=len-1; if((ia[end])) { return -1; } while(start<=end) { mid=(start+end)/2; if(a[mid]<i) { start

#include#includeint Isone(int ret)  { int pos=1; while((ret&0x01)==0) { ret=ret>>1; pos++; } return pos;}bool test(int value,int pos){ return (value>>(pos-1))&0x01;}void find(int* a,int n,int* num1,

思路：入队：只将栈s1作为入队。出队：将栈s2作为出队，如果栈s1不为空，s2为空，出队时将s1的元素倒入s2中，再pop();否则s2不为空，出队时直接在栈s2中pop();#include#include#includeusing namespace std;templateclass Queue{public: Queue() :_size(0) {} void ap

第一种：思路：遍历一个字符串，遇到空格向后移动三个char空间，插入%20，直到遍历结束。时间复杂度O(n^2)空间复杂度O(1)#include#include#includeusing namespace std;void memmove(void* src,void* des,size_t size){ char* d=(char*)des; char* s=(char*)sr

第一种：思路：二维数组是从左到右递增，从上到下递增，row为行数，col为列数，a[row-1][col-1]为最大数，如果剔除这一行，这一列，则最大数为a[row-2][col-2],如果要查找的num大于a[row-2][col-2]并且大于a[row-1][col-1]，则在该row-1行和col-1列查找，照这样遍历。这样太麻烦，效率太低，应当舍弃。#include#include#i

#includeusing namespace std;class String{public: String(const char* str) :_str(new char[strlen(str)+1]) { strcpy(_str,str); } /*String(const String& s) :_str(NULL) { String tmp(s._str

第一种：开辟一个一样大小的数组，遍历原数组的数据，把原数组奇数依次存放在新数组的前面，偶数存放在后面。时间复杂度：O(n^2);空间复杂度：O(n)缺陷：效率太差#include#includevoid Adjust(int* src,int* des,int n){ int index=0; for(int j=0;j<n;j++) { if(src[j]%2) {

第一种：这个实现起来简单，计算机里数据存储都是以二进制形式存储的，简单的num%2,num/2就能实现。不过这个有一个缺陷：就是针对负数不能实现。#include#include//int count_one_bits(int num)//{// int count=0;// while(num)// {// if(num%2==1)// {// count++;//

数值的整数次方注意：0的0次方是没有意义的；0的负数负数次方也是无意义的；注意base与0值的比较；exponent为负数时，先转化成正数再求倒数。（1）这种方法比较直观。while()循环。#include#include#define m 0.000001 double DoublePower(double base,int exponent){ int flags=0; doub

第一种：递归函数  1 #include  2 #include  3 #include  4   5 int Fabonacci(int n)  6 {  7     if(n=0)  8     {  9         return n; 10     } 11     return Fabonacci(n-1)+Fabonacci(n-2); 12 } 13 int

思路：基本方法：从头遍历一遍，时间复杂度为O(n),效率比较低，这里采用二分查找，找出中间元素与头，尾比较，如果中间元素比头元素大，说明这部分有序，最小值在后半部分，中间元素为头：如果中间元素比尾元素大，说明最小值在前部分。  设定两个指针start和end分别指向数组的首尾元素，然后当start指向前半段最后一个元素，end指向后半段第一个元素，这是程序就找到了数组中的最小元素，就是end指向的

输入数字n,按顺序打印出从1最大的n位十进制数。（1）直接通过n定位到最大的数大一的数，然后打印出来。缺陷：有可能数值超出计算机存储数据基本类型的范围，所以就得采用第二种方法。  1 #include  2 #include  3 #include  4 void MAX_NUM(int n)  5 {  6     int num=0;  7     int i=1;  8    

一、概念多态性可以简单的概括为“1个接口，多种方法”，在程序运行的过程中才决定调用的机制程序实现上是这样，通过父类指针调用子类的函数，可以让父类指针有多种形态。二、形式静态多态（函数重载）模板函数 在编译时就可以确定对象使用的形式动态多态（虚函数，函数重写）其具体引用的对象在运行时才能确定三、函数重载实现的多态函数重载：函数名相同，参数不同#include

#include#include#include#include#includetypedef int DataType;typedef struct Seqlist{ DataType* _array; size_t _size; size_t capacity;}Seqlist;void Initlist(Seqlist *s){ assert(s); s->ca

第一种：（类似冒泡排序）#include#include#includeint main(){ char a[5][30]={"aaa","bbb","ccc","adb","degf"}; int i=0; int j=0; char b[30]; for(i=0;i<4;i++) { for(j=0;j<4-i;j++) { if(strcmp(a[j],a

第一种方法：#include#includeint main(){ int a,b; scanf("%d%d",&a,&b); printf("%d",(a&b)+((a^b)>>1)); system("pause"); return 0;}第二种方法：#include#includeint main(){ int a,b; scanf("%d%d",&a,&b

第一种：#include#includeint main(){ int m,n,u; int count=0; scanf("%d%d",&m,&n); u=m^n; while(u) {  count++;  u=u&(u-1); } printf("%d",count); system("pause"); return 0;}第二种：#include#i

这一种是我自己想出来的方法，发现对二进制还是不太熟悉。#include#includeunsigned int  reverse_bit(unsigned int value){ unsigned sum=0; int i=0; for(i=0;i<32;i++) {  sum+=((value>>i)&1)<<(31-i); } return sum;}int main

The easier way:#include#includeint main(){int a,b;scanf("%d%d",&a,&b);a=a+b;b=a-b;a=a-b;printf("a=%d\nb=%d\n",a,b);system("pause");return 0;}The solution is easy to deal with,otherwise

#include#includeint fun(int n,int k){ if(k--) { return n*fun(n,k); } else { return 1; }}int main(){ int n,k; scanf("%d%d",&n,&k); printf("%d",fun(n,k)); system("pause"); return 

#include#includeint str(char *string){ int n=0; while(*string) {  n++;  string++; } return n; }void reverse(char *string){ int len=str(string); if(*string) {  char temp=*string;  *st

#include#include#includeint average(int val,...){ va_list(arg); va_start(arg,val); int i=0,sum; sum=0; for(i=0;i<val;i++) { sum+=va_arg(arg,int); } va_end(arg); return(sum/val);}int

字符串长度：#include#include#includeint my_strlen(const char *s){assert(s);int n=0;while(*s){n++;s++;}return n;}int main(){char s[]="abcedf";printf("%d",my_strlen(s));system("pause");ret

#include#includeint reverse(int num){ int old=num; int new1=0; while(num) {  new1=new1*10+num%10;  num=num/10; } if(old==new1) {  return 1; } else  return 0;}int main(){ int num=0;

#include#include#includeint ishw(char*p){ char *start=p; char *end=p+strlen(p)-1; while(start<end) {  if(*start==*end)  {   start++;   end--;  }  else   return 0; } return 1;}int ma

#include#includetypedef unsigned int uint;void* my_memmove(void* p,const void* q,uint len){ void*ret=p; char* p1=(char*)p; char* q2=(char*)q; if((p1>q2)&&(p1<q2+len)) {  while(len--)  {   

#include#includetypedef unsigned int uint;void* my_memmove(void* p,const void* q,uint len){ void*ret=p; char* p1=(char*)p; char* q2=(char*)q; if((p1>q2)&&(p1<q2+len)) {  while(len--)  {   

单例模式的要点有三个；一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。从具体实现角度来说，就是以下三点：一是单例模式的类只提供私有的构造函数，二是类定义中含有一个该类的静态私有对象，三是该类提供了一个静态的公有的函数用于创建或获取它本身的静态私有对象。(1)这种方法只适用单线程。#include#includeusing namespace