手撕代码题

考题1：二分查找（递归与非递归）

//递归方法
int BinSearch(int Array[],int low,int high,int key/*要找的值*/)    
{    
    if (low<=high)    
    {    
        int mid = (low+high)/2;    
        if(key == Array[mid])    
            return mid;    
        else if(key<Array[mid])    
            return BinSearch(Array,low,mid-1,key);    
        else if(key>Array[mid])    
            return BinSearch(Array,mid+1,high,key);    
    }    
    else    
        return -1;    
} 

//非递归方法
int BinSearch(int Array[],int SizeOfArray,int key)    
    {    
        int low=0,high=SizeOfArray-1;    
        int mid;    
        while (low<=high)    
        {    
            mid = (low+high)/2;    
            if(key==Array[mid])    
                return mid;    
            if(key<Array[mid])    
                high=mid-1;    
            if(key>Array[mid])    
                low=mid+1;    
        }    
        return -1;    
}

  二分查找的变种：https://blog.csdn.net/qq_33951440/article/details/77484550

                               http://www.cnblogs.com/grandyang/p/6854825.html

                               http://www.voidcn.com/article/p-birourlz-bgt.html 

考题2：int atoi(const char *str ); 把字符串转换成整型数。

#include<iostream> 
using namespace std; 
int atoi_my(const char *str)
{
	int s=0;
	bool falg=false;
	
	while(*str==' ')
	{
		str++;
	}
 
	if(*str=='-'||*str=='+')
	{
		if(*str=='-')
		falg=true;
		str++;
	}
 
	while(*str>='0'&&*str<='9')
	{
		s=s*10+*str-'0';
		str++;
		if(s<0)
		{
			s=2147483647;
			break;
		}
	}
	return s*(falg?-1:1);
}

考题3：回文字符串的判断

int find(char *str, int n) {
     if(n<=1) 
        return 1;
     else if(str[0]==str[n-1])   
        return find(str+1, n-2);
     else     
        return 0;
}

 考题4：删除空格（不开辟额外空间）

#include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;
//原地往前推进，不使用额外的空间
int delspace(char *p)
{
    int i=0,j=0,count=0;
    while(p[j]!='\0')
    {
        if(p[j]!=' ')
        {
          p[i]=p[j];
          i++;
        }
        else
            count++;
        j++;

    }
    return count;
}
int main(int argc, char *argv[])
{
    char str[]="     Some spaces    before  the     first    word.    ";
    int n=delspace(str);
    int len=strlen(str);
    //需要删除末尾数字，即个数为多余的空格数
    for(int i=0;i<len-n;i++)
       cout<<str[i];
    return 0;
}

 考题4：多线程，一个线程打印偶数，一个线程打印奇数，交替输出0~N。

#include<stdlib.h>

pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t even =PTHREAD_COND_INITIALIZER;
pthread_cond_t uneven =PTHREAD_COND_INITIALIZER;

static int i=0; //全局静态变量

void* pthreadA(void *N)
{
  pthread_mutex_lock(&mutex);
  int n=*((int *)N);
  while(i<=n)
  {
    if(i%2==1)
    {
      printf("%d ",i);
      i++;
      pthread_cond_signal(&uneven);
    }
    else
      pthread_cond_wait(&even,&mutex);
  }
  pthread_mutex_unlock(&mutex);
}
void* pthreadB(void *N)
{
  pthread_mutex_lock(&mutex);
  int n=*((int *)N);
  while(i<=n)
  {
    if(i%2==0)
    {
      printf("%d ",i);
      i++;
      pthread_cond_signal(&even);
    }
    else
      pthread_cond_wait(&uneven,&mutex);
  }
   pthread_mutex_unlock(&mutex);
 }
 void printNumber(int N)
 {
       pthread_t A,B;
       pthread_create(&A,NULL,pthreadA,(void *)&N);
       pthread_create(&B,NULL,pthreadB,(void *)&N);
       pthread_join(A,NULL);
       pthread_join(B,NULL);
       return ;
 }

 int main()
 {
     int N=10;
     printNumber(N);
     return 0;
 }

  考题5：给定一个字符串，求出其最长的重复子串的长度

  参考链接：https://blog.csdn.net/renwotao2009/article/details/53039068

  考题6：全排列问题

   如下图：要对1、2、3、4进行排序，第一个位置上的元素有四种可能：1或2或3或4，假如已经确定了第一个元素为4，剩下的  第二个位置上可以是1、2、3，很显然这具有递归结构，如果原始要排列的数组顺序为1、2、3、4，现在只要分别交换1、2，1、3，1、4然后对剩下的3个元素进行递归的排列。

 

public  void Permutation(char chs[],int start )
    {
        if(start==chs.length-1)
        {
            Arrays.toString(chs);
            //如果已经到了数组的最后一个元素，前面的元素已经排好，输出。
        }
        for(int i=start;i<=chs.length-1;i++)
        {
        //把第一个元素分别与后面的元素进行交换，递归的调用其子数组进行排序
                Swap(chs,i,start);
                Permutation(chs,start+1);
                Swap(chs,i,start);
        //子数组排序返回后要将第一个元素交换回来。  
        //如果不交换回来会出错，比如说第一次1、2交换，第一个位置为2，子数组排序返回后如果不将1、2
        //交换回来第二次交换的时候就会将2、3交换，因此必须将1、2交换使1还是在第一个位置 
        }
    }
    public  void Swap(char chs[],int i,int j)
    {
        char temp;
        temp=chs[i];
        chs[i]=chs[j];
        chs[j]=temp;
    }

  参考链接：https://blog.csdn.net/u013309870/article/details/68941284

  考题7：打印字符串全部子序列

  例：“abc” 
  从位置0开始，有两种决策1、要；2、不要 
  向后走，每个位置同样两种决策，递归

  递归结束就是走到了字符串最后

void printAllSub(string str, int i, string res)
{
    if (i == str.length())
    {
        cout << res << endl;
        return;
    }
    printAllSub(str, i + 1, res);         //不要
    printAllSub(str, i + 1, res + str[i]);//要
}
int main()
{
    string a = "abcde";
    printAllSub(a, 0, "");
    system("pause");
}

 参考链接：https://blog.csdn.net/lindaxym/article/details/81449816