二分查找的代碼.
int bfind(int* a,int len,int val)
{
int m = len/2;
int l = 0;
int r = len;
while(l!=m && r!= m)
{
if(a[m] > val)
{
r = m;
m = (m+l)/2;
}
else if(a[m] < val)
{
l = m;
m = (m+r)/2;
}
else
return m;
}
return -1; //沒有找到
}
寫出在母串中查找子串出現(xiàn)次數(shù)的代碼.
int count1(char* str,char* s)
{
assert(str!=NULL&&s!=NULL);
char* s1;
char* s2;
int count = 0;
s1=str;
while(*s1!='\0')
{
s2 = s;
while(*s2 == *s1&&(*s2!='\0')&&(*s1!='0'))
{
s2++;
s1++;
}
if(*s2 == '\0')
{ count++;
--s1;
}
s1++;
}
return count;
}
查找第一個(gè)匹配子串位置,如果返回的是s1長度len1表示沒有找到
size_t find(char* s1,char* s2)
{
assert(s1!=NULL&&s2!=NULL);
size_t i=0,j;
size_t len1 = strlen(s1);
size_t len2 = strlen(s2);
if(len1-len2<0) return len1;
for(;i<len1;i++){
size_t m = i;
for(j=0;j<len2;j++)
{
if(s1[m]!=s2[j])
break;
m++;
}
if(j==len2)
break;
}
return i+1;
}
寫出快速排序或者某種排序算法代碼
快速排序:
int partition(int array[],int start,int end)
{
int pivot=start;
while(start<end)
{
while(array[start]<array[pivot])start++;
while(array[end]>array[pivot])end--;
swap(&array[start],&array[end]);
}
swap(&array[start],&array[pivot]);
return start;
}
int partition(int *array,int l,int r)
{
int v=array[l];
while(l<r)
{
while(array[l]<v)l++;
while(array[r]>v)r--;
if(l==r)break;
swap(&array[l],&array[r]);
}
return l;
}
void qsort(int* a,int l,int r)
{
int i = partition(a,l,r);
if(i>l)qsort(a,l,i);
if(r>i)qsort(a,i+1,r);
}
冒泡排序:
void bubbleSort(int *a,int n)
{
for(int i=0;i<n-1;i++)
for(int j=1;j<n-i;j++)
if(a[j]<a[j-1])swap(&a[j-1],&a[j]);
}
插入排序：
直接插入排序(Insertion Sort)的基本思想是：每次將一個(gè)待排序的記錄，按其關(guān)鍵字大小插入到前面已經(jīng)排好序的子序列中的適當(dāng)位置，直到全部記錄插入完成為止。
設(shè)數(shù)組為a[0…n-1]。
1. 初始時(shí)，a[0]自成1個(gè)有序區(qū)，無序區(qū)為a[1..n-1]。令i=1
2. 將a[i]并入當(dāng)前的有序區(qū)a[0…i-1]中形成a[0…i]的有序區(qū)間。
3. i++并重復(fù)第二步直到i==n-1。排序完成。
void insertSort(int *a,int len)
{
assert(a!=NULL&&len>0);
int i,j;
for(i=1;i<len;i++)
{
for(j=i-1;j>=0&&a[j]>a[j+1];j--)
swap(&a[j],&a[j+1]);
}
}
出現(xiàn)次數(shù)相當(dāng)頻繁
實(shí)現(xiàn)strcmp函數(shù)
int strcmp11(char* l,char* r)
{
assert(l!=0&&r!=0);
while(*l == *r &&*l != '\0') l++,r++;
if(*l > *r)
return 1;
else if(*l == *r)
return 0;
return -1;
}
實(shí)現(xiàn)字符串翻轉(zhuǎn)
void reserve(char* str)
{
assert(str != NULL);
char * p1 = str;
char * p2 = str-1;
while(*++p2); //一般要求不能使用strlen
p2 -= 1;
while(p1<p2) {
swap(*p1++,*p2--);
}
}
將一個(gè)單鏈表逆序
void reverseList(Node **head)
{
if(head!=NULL&&(*head)==NULL&&(*head)->next==NULL)
return ;
Node *temp=*head;
Node *q,*p=NULL;
while(temp!=NULL)
{
q=temp->next;
temp->next=p;
p=temp;
temp=q;
}
*head=p;
}
循環(huán)鏈表的節(jié)點(diǎn)對換和刪除。
//雙向循環(huán)
list_node* earse(list_node* node)
{
// if(node == rear) return node->next; //對于頭節(jié)點(diǎn)可判斷也可不判斷。最好加上
list_node* next = node->next;
next->prev = node->prev;
node->prev->next = next;
delete node;
retrun next;
}
//單項(xiàng)循環(huán)
list_node* earse(list_node* node)
{
// if(node == rear) return node->next; //對于頭節(jié)點(diǎn)可判斷也可不判斷。最好加上
list_node* p = rear;
while(p->next != node) p=p->next;
p->next = node->next;
delete node;
retrun p->next;
}
對于單鏈表刪除node.如果node 肯定在鏈表里，if(node->next!=NULL)node->data=node->next->data;node->next=node->next->next;
delete node->next;
將一個(gè)數(shù)字字符串轉(zhuǎn)換為數(shù)字."1234" -->1234
int atoii(char* s)
{
assert(s!=NULL);
int num = 0;
int temp;
while(*s>'0' && *s<'9')
{
num *= 10;
num += *s-'0';
s++;
}
//應(yīng)考慮溢出
return num;
}
出現(xiàn)次數(shù)相當(dāng)頻繁
.實(shí)現(xiàn)任意長度的整數(shù)相加或者相乘功能。
void bigadd(char* num,char* str,int len)
{//int 數(shù)組更簡單
for(int i=len;i>0;i--)
{
num[i] += str[i]-'0';
int j = i;
while(num[j]>'9')
{
num[j--] -= 10;
num[j] += 1;
}
}
}
.寫函數(shù)完成內(nèi)存的拷貝
void* memcpy( void *dst, const void *src, unsigned int len )
{
register char *d;
register char *s;
if (len == 0)
return dst;
if ( dst > src ) //考慮覆蓋情況
{
d = (char *)dst + len - 1;
s = (char *)src + len - 1;
while ( len >= 4 ) //循環(huán)展開，提高執(zhí)行效率
{
*d-- = *s--;
*d-- = *s--;
*d-- = *s--;
*d-- = *s--;
len -= 4;
}
while ( len-- )
{
*d-- = *s--;
}
}
else if ( dst < src )
{
d = (char *)dst;
s = (char *)src;
while ( len >= 4 )
{
*d++ = *s++;
*d++ = *s++;
*d++ = *s++;
*d++ = *s++;
len -= 4;
}
while ( len-- )
{
*d++ = *s++;
}
}
return dst;
}
出現(xiàn)次數(shù)相當(dāng)頻繁
編寫類String的構(gòu)造函數(shù)、析構(gòu)函數(shù)和賦值函數(shù)，已知類String的原型為：
class String
{
public:
String(const char *str = NULL); // 普通構(gòu)造函數(shù)
String(const String &other); // 拷貝構(gòu)造函數(shù)
~ String(void); // 析構(gòu)函數(shù)
String & operate =(const String &other); // 賦值函數(shù)
private:
char *m_data; // 用于保存字符串
};
解答：
//普通構(gòu)造函數(shù)
String::String(const char *str)
{
if(str==NULL)
{
m_data = new char[1]; // 得分點(diǎn)：對空字符串自動(dòng)申請存放結(jié)束標(biāo)志'\0'的空
//加分點(diǎn)：對m_data加NULL 判斷
*m_data = '\0';
}
else
{
int length = strlen(str);
m_data = new char[length+1]; // 若能加 NULL 判斷則更好
strcpy(m_data, str);
}
}
// String的析構(gòu)函數(shù)
String::~String(void)
{
delete [] m_data; // 或delete m_data;
}
//拷貝構(gòu)造函數(shù)
String::String(const String &other) // 得分點(diǎn)：輸入?yún)?shù)為const型
{
int length = strlen(other.m_data);
m_data = new char[length+1]; //加分點(diǎn)：對m_data加NULL 判斷
strcpy(m_data, other.m_data);
}
//賦值函數(shù)
String & String::operate =(const String &other) // 得分點(diǎn)：輸入?yún)?shù)為const型
{
if(this == &other) //得分點(diǎn)：檢查自賦值
return *this;
delete [] m_data; //得分點(diǎn)：釋放原有的內(nèi)存資源
int length = strlen( other.m_data );
m_data = new char[length+1]; //加分點(diǎn)：對m_data加NULL 判斷
strcpy( m_data, other.m_data );
return *this; //得分點(diǎn)：返回本對象的引用
}
剖析：
能夠準(zhǔn)確無誤地編寫出String類的構(gòu)造函數(shù)、拷貝構(gòu)造函數(shù)、賦值函數(shù)和析構(gòu)函數(shù)的面試者至少已經(jīng)具備了C++基本功的60%以上！
在這個(gè)類中包括了指針類成員變量m_data，當(dāng)類中包括指針類成員變量時(shí)，一定要重載其拷貝構(gòu)造函數(shù)、賦值函數(shù)和析構(gòu)函數(shù)，這既是對C++程序員的基本要求，也是《Effective C++》中特別強(qiáng)調(diào)的條款。
實(shí)現(xiàn)strcpy
char * strcpy( char *strDest, const char *strSrc )
{
assert( (strDest != NULL) && (strSrc != NULL) );
char *address = strDest;
while( (*strDest++ = * strSrc++) != '\0’ );
return address;
}
編寫一個(gè)函數(shù)，作用是把一個(gè)char組成的字符串循環(huán)右移n個(gè)。比如原來是“abcdefghi”如果n=2，移位后應(yīng)該是“hiabcdefgh”
函數(shù)頭是這樣的：
//pStr是指向以'\0'結(jié)尾的字符串的指針
//steps是要求移動(dòng)的n
void LoopMove ( char * pStr, int steps )
{
//請?zhí)畛?..
}
解答：
正確解答1：
void LoopMove ( char *pStr, int steps )
{
int n = strlen( pStr ) - steps;
char tmp[MAX_LEN];
strcpy ( tmp, pStr + n );
strcpy ( tmp + steps, pStr);
*( tmp + strlen ( pStr ) ) = '\0';
strcpy( pStr, tmp );
}
正確解答2：
void LoopMove ( char *pStr, int steps )
{
int n = strlen( pStr ) - steps;
char tmp[MAX_LEN];
memcpy( tmp, pStr + n, steps );
memcpy(pStr + steps, pStr, n );
memcpy(pStr, tmp, steps );
}
