C/C++语言面试题详细解答三

最新推荐文章于 2024-04-18 21:37:55 发布

www.wowothink.com

最新推荐文章于 2024-04-18 21:37:55 发布

阅读量1.9k

点赞数

分类专栏：面试文章标签： C C++ 面试

本文链接：https://blog.csdn.net/encourage2011/article/details/45912675

版权

面试专栏收录该内容

4 篇文章 0 订阅

订阅专栏

以下提到的题目全部来自C语言面试题大汇总.本文章将对其中的题目根据自己的理解进行详细的解答。存在不足或错误的地方敬请指正出来。

排序

以下排序的内容大部分参照下面的文章进行整理：
数据结构复习之【排序】

既然讲到排序，那就肯定要涉及到交换，我们先讲讲两数交换。

两数交换

1、参数为指针

void swap(int *x, int *y)
{
    int temp = 0;
    temp = *x;
    *x = *y;
    *y = temp;
}

2、使用异或^

void swap(int x, int y)
{
    x = x^y;
    y = x^y;
    x = x^y;
}

刚开始看到这个我表示很纳闷，这是什么鬼啊。后来我把式子展开之后我震惊了：
第二个语句：

 y = x^y;

展开后是：

y = (x^y)^y = x^(y^y) = x^0 = x

因为两个相同的值异或为0，任何与0异或的值都是其本身.
第三个语句：

x = x^y;

同理把它展开后可得：

x = x^y = (x^y)^((x^y)^y) = ((x^y)^(x^y))^y = 0^y = y

还是运用那句话：因为两个相同的值异或为0，任何与0异或的值都是其本身.
3、使用加减

void swap(int x, int y)
{
    x = x+y;
    y = x-y;
    x = x-y;
}

还是采用展开的方法就可知x和y对调了。
4、使用乘除

void swap(int x, int y)
{
    if((x!=0) && (y!=0))   // 必须保证x和y都不为0
    {
        x = x*y;
        y = x/y;
        x = x/y;
    }   
}

简单排序

#include <stdio.h>

#define ARRAYLENGTH 10      // 数组长度

void swap(int *x, int *y)
{
    int temp = 0;
    temp = *x;
    *x = *y;
    *y = temp;
}

// 简单排序
/*从第0个元素开始依次与它后面的比较，若大于其后面的元素则与其交换，直到找到最小的值放在第0位置
* 从第1元素开始依次与它后面的比较，处理同上
* 接下来的步骤同上
* 第一层外部循环结束后肯定找到最小值
*/
int normal_sort(int *array, int length)
{
    int i = 0;
    int j = 0;

    if(array != NULL)
    {
        for(i=0; i<length; i++)
        {
            for(j=i+1; j<length; j++)
            {
                if(array[i] > array[j])
                {
                    swap(&array[i], &array[j]);
                }
            }
        }
        return 0;
    }
    else
    {
        // error
        return -1;
    }
}

int main(void)
{
    int i = 0;
    int ret = 0;
    int array[ARRAYLENGTH] = {5, 3, 2, 6, 9, 8, 0, 1, 4, 7};
    ret = normal_sort(array, ARRAYLENGTH);
    for(i=0; i<ARRAYLENGTH; i++)
        printf("%d\t", array[i]);
    printf("\n");

    return 0;
}

冒泡排序

// 冒泡排序
/* 第0个元素与第1个元素比较，若前者更大，则交换；第1个元素与第2个元素比较；
 * 一直下去直到第ARRAYLENGTH-2个元素与第ARRAYLENGTH-1个元素比较。找到最大值放到最ARRAYLENGTH-1的位置
 * 接下来同上，不过所比较到第ARRAYLENGTH-2个元素则停止，找到次大值放到ARRAYLENGTH-2的位置上
 */
int bubble_sort(int *array, int length)
{
    int i = 0;
    int j = 0;
    int k = 0;
    if((array != NULL) && (length <= ARRAYLENGTH))
    {
        for(i=0; i<length; i++)
        {
            for(j=0; j<(length-i-1); j++)
            {
                if(array[j] > array[j+1])
                {
                    swap(&array[j], &array[j+1]);
                }
            }
        }
    }
    else
    {
        // error
        return -1;
    }
}

选择排序

// 选择排序
/* 这个真不太会形容，看视频吧。选择排序视频：http://v.youku.com/v_show/id_XMzMyODk5MDI0.html
 */
int selection_sort(int *array, int length)
{
    int i = 0;
    int j = 0;
    int min = 0;                        // 保存一次外部循环的最小值

    if((array != NULL) && (length <= ARRAYLENGTH))
    {
        for(i=0; i<length; i++)
        {
            for(j=i+1, min = array[i]; j<length; j++)
            {
                if(min > array[j])    // 每个值都与默认的"最小值"比较直至找到最小值
                {
                    min = array[j];   // 找到一次外层循环中的最小值
                    swap(&array[i], &array[j]);
                }
            }
        }

        return 0;
    }
    else
    {
        // error
        return -1;
    }
}

插入排序

// 插入排序
/*
 * 给定序列，存在一个分界线，分界线的左边被认为是有序的，分界线的右边还没被排序，
 * 每次取没被排序的最左边一个和已排序的做比较，并插入到正确位置；
 * 我们默认索引0的子数组有序；每次循环将分界线右边的一个元素插入有序数组中，并将分界线向右移一位
 */
int insert_sort(int *array, int length)
{
    int i = 0;
    int j = 0;
    if((array != NULL) && (length <= ARRAYLENGTH))
    {
        for(i=1; i<length; i++)
        {
            for(j=i; j>0; j--)
            {
                if(array[j] < array[j-1])
                {
                    swap(&array[j], &array[j-1]);
                }
            }
        }

    }
    else
    {
        // error
        return -1;
    }
}