C/C++常見問題

如果代碼裡面有 while(*p) 判斷字串結束的，要用 *p!='\0' 代替。
1)sizeof相關係列問題, const相關係列問題
a. 對於 struct s{char a;int b}  sizeof(s) = 8 因為記憶體對齊
b. 對於struct s{int a;char b}  sizeof(s) = 5  這裡不需要記憶體對齊，對齊只向上不向下，這種考得少
c.  對於 int a[200] sizeof(a) = 200* sizeof(int) = 800 對整個數組評測 ，int* a = new int[200] , sizeof(a) = 4 對指標評測
d. 這種使用位域的也有，從上到下最多相加不大於8便佔1個位置， bits = 1 +  1(4+2 < 8) + 1(3) = 3. 其中元素最大為1個char 大小 8 位
struct  bits
{
    char a:8;
    char b:4;
    char c:2;
    char d:3;
};

2)寫出二分尋找的代碼.
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;   //沒有找到
}
3)寫出在母串中尋找子串出現次數的代碼.
int count1(char* str,char* s)
{
    char* s1;
    char* s2;
    int count = 0;
    while(*str!='\0')
    {
        s1 = str;
        s2 = s;
        while(*s2 == *s1&&(*s2!='\0')&&(*s1!='0'))
        {
            s2++;
            s1++;
        }
        if(*s2 == '\0')
            count++;
        str++;
    }
    return count;
}

尋找第一個匹配子串位置,如果返回的是s1長度len1表示沒有找到
size_t find(char* s1,char* s2)
    {
        size_t i=0;
         size_t len1 = strlen(s1)
        size_t len2 = strlen(s2);
        if(len1-len2<0) return len1;
        for(;i<len1-len2;i++)
        {
            size_t m = i;
            for(size_t j=0;j<len2;j++)
            {
                if(s1[m]!=s2[j])
                    break;
                m++;
            }
            if(j==len)
                break;
        }
        return i<len1-len2?i:len1;
    }

*4)寫出快速排序或者某種排序演算法代碼
快速排序:
int partition(int* a,int l,int r)
{
    int i=l-1,j=r,v=a[r];
    while(1)
    {
        while(a[++i]<v);
        while(a[--j]>v) if(j<=i) break;
        if(i>=j)
            break;
        swap(a[i],a[j]);
    }
    swap(a[i],a[r]);
    return i;
}

void qsort(int* a,int l,int r)
{
    if(l>=r) return;
    int i = partition(a,l,r);
    qsort(a,l,i-1);
    qsort(a,i+1,r);
}

冒泡排序:
void buble(int *a,int n)
{
    for(int i=0;i<n;i++)
    {
        for(int j=1;j<n-i;j++)
        {
            if(a[j]<a[j-1])
            {
                int temp=a[j];
                a[j] = a[j-1];
                a[j-1] = temp;
            }
        }
    }
}
插入排序：
void insertsort(int* a,int n)
{
    int key;
    for(int j=1;j<n;j++)
    {
        key = a[j];
        for(int i=j-1;i>=0&&a[i]>key;i--)
        {
            a[i+1] = a[i];
        }
        a[i+1] = key;
    }
}

出現次數相當頻繁
5)寫出尋找從一個集合中輸出所有子集合的演算法.
????
*6)實現strcpy函數
char *strcpy(char *destination, const char *source)
{
assert(destination!=NULL&&source!=NULL);
char* target = destinaton;
while(*destinaton++=*source++);
return target ;
}
出現次數相當頻繁
*7)實現strcmp函數
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;
}

//實現字串翻轉
void reserve(char* str)
{
    assert(str != NULL);
    char * p1 = str;
    char * p2 = str-1;
    while(*++p2);         //一般要求不能使用strlen
    p2 -= 1;
    while(p1<p2)
    {
        char c = *p1;
        *p1++ = *p2;
        *p2-- = c;
   }
}

出現次數相當頻繁
8)將一個單鏈表逆序
struct list_node
{
    list_node(int a,list_node* b):data(a),next(b)  //這個為了測試方便
    {}
    int data;
    list_node* next;
};

 void reserve(list_node* phead)
 {
        list_node* p = phead->next;
        if(p == NULL || p->next == NULL) return; //只有前端節點或一個節點
        list_node* p1=p->next;
        p->next=NULL;
        while(p1!=NULL)
        {
            p = p1->next;
            p1->next = phead->next;
            phead->next = p1;
            p1 = p;
        }
}

測試程式：
    list lt;
    lt.phead = new list_node(0,0);
    lt.phead->next = new list_node(1,0);
    lt.phead->next->next = new list_node(2,0);
    lt.phead->next->next->next =  new list_node(3,0);
    lt.reserve();
    list_node * p = lt.phead;
    while(p)
    {
        cout<<p->data<<endl;
        p = p->next;
    }
9)迴圈鏈表的節點對換和刪除。

//雙向迴圈
list_node* earse(list_node* node)
{
    // if(node == rear) return node->next;    //對於前端節點可判斷也可不判斷。最好加上
    list_node*  next = node->next;
    next->prev = node->prev;
    node->prev->next = next;
    delete node;
    retrun next;
}
//單項迴圈
list_node* earse(list_node* node)
{
    // if(node == rear) return node->next;    //對於前端節點可判斷也可不判斷。最好加上
    list_node*  p = rear;
     while(p->next != node) p=p->next;
     p->next = node->next;
    delete node;
    retrun p->next;
}

*10)將一個數字字串轉換為數字."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++;
    }
    return num;
}
出現次數相當頻繁
11)實現任意長度的整數相加或者相乘功能。
void bigadd(char* num,char* str,int len)
{
    for(int i=len;i>0;i--)
    {
        num[i] += str[i];
        int j = i;
        while(num[j]>=10)
        {
            num[j--] -= 10;
            num[j] += 1;
        }
    }
}
*12)寫函數完成記憶體的拷貝
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 )   //迴圈展開，提高執行效率
        {
            *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;
}
出現次數相當頻繁

13 static有什麼用途？（請至少說明兩種）
1.限制變數的範圍
2.設定變數的儲存域，只在定於變數的源檔案內可見
經常問
14. 引用與指標有什麼區別？
1) 引用必須被初始化，指標不必。
2) 引用初始化以後不能被改變，指標可以改變所指的對象。
3) 不存在指向空值的引用，但是存在指向空值的指標。
4) 重載操作符使用引用可以完成串試操作
經常問

15. 全域變數和局部變數在記憶體中是否有區別？如果有，是什麼區別？
全域變數儲存在全域靜態儲存區，局部變數在堆棧
16. 什麼是平衡二叉樹？
左右子樹都是平衡二叉樹 且左右子樹的深度差值的絕對值不大於1

17. 什麼函數不能聲明為虛函數？
constructor
13. 冒泡排序演算法的時間複雜度是什嗎？
O(n^2)
18. 寫出float x 與“零值”比較的if語句。
    if(x>0.000001&&x<-0.000001)  
這個都夠古董的, 恐怕是8086以前的事情吧. 彙編早都可以用一條指令比較了. 既然想考精度，就換個不是0的，比如0.00002 ，  if(x-0.00002>0.000001&&x-0.0002<-0.000001) 

19.使用者輸入M,N值，從1至N開始順序迴圈數數，每數到M輸出該數值，直至全部輸出。寫出C程式。
迴圈鏈表，用取餘操作做
//這樣寫感覺不是太好,置1表示被訪問過。
void joe(int n,int m)
{
    int *a = new int[n];
    int i=0;
    int pos=0;
    while(i<n)
    {
        int c=m;
        pos %= n;
        while(c)
        {
            c--;
            while(a[pos]==1)
            {
                pos++;
                pos %= n;
            }
            pos++;
            pos %= n;
        }
        a[pos-1] = 1;
        cout<<pos<<" ";
        i++;
    }
}

20、設有以下說明和定義：
typedef union {long i; int k[5]; char c;} DATE; // sizeof(int)*5 = 20
struct data { int cat; DATE cow; double dog;} too; //4+20+8 = 32
DATE max;
則語句 printf("%d",sizeof(struct date)+sizeof(max));的執行結果是：___52____

21、用指標的方法，將字串“ABCD1234efgh”前後對調顯示
//不要用strlen求字串長度，這樣就沒分了
代碼如下:
    char str123[] = "ABCD1234efgh";
    char * p1 = str123;
    char * p2 = str123-1;
    while(*++p2);
    p2 -= 1;
    while(p1<p2)
    {
        char c = *p1;
        *p1++ = *p2;
        *p2-- = c;
    }

22、有10億個浮點數，求出其中最大的10000個 ,用了標準庫的，不讓用的話，只能自己寫堆函數
    vector<float> bigs(10000,0);
    vector<float>::iterator it;
    for(it=bigs.begin();it!=bigs.end();it++)
    {
        *it = (float)rand()/7;   //資料都是用隨機數類比的
    }
    cout<<bigs.size()<<endl;
    make_heap(bigs.begin(),bigs.end(),greater<float>() );
    float ff;
   
    time_t t1,t2;
    time(&t1);
    for(int i=0;i<1000000000;i++)
    {
        ff = (float) rand()/7;
        if(ff>bigs[0])
        {
            pop_heap(bigs.begin(),bigs.end(),greater<float>());
            bigs.pop_back();
            bigs.push_back(ff);
            push_heap(bigs.begin(),bigs.end(),greater<float>());
        }
    }
    time(&t2);
    cout<<(long)(t2-t1)<<endl;