c知识点

1.这个关键在实际开发中挺常用的。当我们使用实例成员变量不好处理时，我们将声明为静态变量，因此它有以下特性。

参考答案：

• 函数体内static变量的作用范围为该函数体，不同于auto变量，该变量的内存只被分配一次，因此其值在下次调用时仍维持上次的值
• 在模块内的static全局变量可以被模块内所用函数访问，但不能被模块外其它函数访问
• 在模块内的static函数只可被这一模块内的其它函数调用，这个函数的使用范围被限制在声明它的模块内
• 在类中的static成员变量属于整个类所拥有，对类的所有对象只有一份拷贝
• 在类中的static成员函数属于整个类所拥有，这个函数不接收this指针，因而只能访问类的static成员变量。

2. 下面四个修饰指针有什么区别?

当年在大学时期，我对这几个变量也是经常搞混的。

 

1 2 3 4 5 6

const char *p; char const *p;   char * const p;   const char * const p;

参考答案：

• const char *p定义了一个指向不可变的字符串的字符指针，可以这么看：const char *为类型，p是变量。
• char const *p与上一个是一样的。
• char * const p定义了一个指向字符串的指针，该指针值不可改变，即不可改变指向。这么看：char *是类型，const是修饰变量p，也就是说p是一个常量
• const char * const p定义了一个指向不可变的字符串的字符指针，且该指针也不可改变指向。这一个就很容易看出来了。两个const分别修饰，因此都是不可变的。

3.算法排序

冒泡排序、插入排序。在开发中最常用的就是冒泡排序和插入排序了，不用说那么多高深算法，在平常的工作中，若非BAT，也没有这么严格要求什么多高的效率。能掌握这两种最常用的就基本可以了，搞App开发，若非大数据，并没有什么太高的要求。

冒泡排序： 双重循环就可以实现，在工作中常应用于模型排序。

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

void bubbleSort(int[] unsorted) {     for (int i = 0; i < unsorted.Length; i++)     {         for (int j = i; j < unsorted.Length; j++)          {             if (unsorted[i] > unsorted[j]) {                 int temp = unsorted[i];                 unsorted[i] = unsorted[j];                 unsorted[j] = temp;             }         }     } }

插入排序：

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

void insertionSort(int[] unsorted) {     for (int i = 1; i < unsorted.Length; i++)     {         if (unsorted[i - 1] > unsorted[i])         {             int temp = unsorted[i];             int j = i;                          while (j > 0 && unsorted[j - 1] > temp)             {                 unsorted[j] = unsorted[j - 1];                 j--;             }             unsorted[j] = temp;         }     } }

下面也是插入排序算法，这种写法可能会更好看一些。上面用while循环来查找和移动位置，不好看明白。

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

void insertSort(int *a,int n) {     int i,j,key;          // 控制需要插入的元素     for (i = 1; i < n; i++)     {          // key为要插入的元素         key = a[i];         // 查找要插入的位置,循环结束,则找到插入位置         for (j = i; j > 0 && a[j-1] > key; j--)         {              // 移动元素的位置,供要插入元素使用             a[j] = a[j-1];         }                  // 插入需要插入的元素         a[j] = key;     } }

选择排序

假定存在数组 array[0..n-1], 选择排序的核心思想是：
第 i 趟排序是从后面的 n - i + 1（i = 1，2，3，4，. . .，n - 1）个元素中选择一个值最小的元素与该 n - i + 1 个元素的最前门的那个元素交换位置，即与整个序列的第 i 个元素交换位置。如此下去，直到 i = n - 1，排序结束。
也可描述为：
每一趟排序从序列中未排好序的那些元素中选择一个值最小的元素，然后将其与这些未排好序的元素的第一个元素交换位置。

特点：
1. 算法完成需要 n - 1 趟排序，按照算法的描述，n - 1 趟排序之后数组中的前 n - 1 个元素已经处于相应的位置，第 n 个元素也处于相应的位置上。
2. 第 i 趟排序，实际上就是需要将数组中第 i 个元素放置到数组的合适位置，这里需要一个临时变量 j 来遍历序列中未排好序的那些元素，另一临时变量 d 来记录未排好序的那些元素中值最小的元素的下标值，
3. 一趟遍历开始时，令 d = i，假定未排序序列的第一个元素就是最小的元素，遍历完成后，变量 d 所对应的值就是值最小的元素，判断 d 是否是未排序序列的第一个元素，如果是，则不需要交换元素，如果不是，则需要交换array[d] 和 array[i]。
4. 此方法是不稳定排序算法，可对数组{a1 = 49，a2 = 38, a3 = 65, a4 = 49, a5 = 12, a6 = 42} 排序就可以看出，排序完成后 a1 和 a4的相对位置改变了。
5. 此方法移动元素的次数比较少，但是不管序列中元素初始排列状态如何，第 i 趟排序都需要进行 n - i 次元素之间的比较，因此总的比较次数为
1 + 2 + 3 + 4 +5 + . . . + n - 1 = n(n-1)/2, 时间复杂度是 O(n^2).

void selectSort(int array[], int n)
{
    int i, j, d;
    int temp;
    for(i = 0; i < n - 1; ++i)
    {
        d = i;   //开始一趟选择排序，假定第i个元素是后面n - i + 1个未排序的元素中最小的元素
        for(j = i + 1; j < n; ++j)
            if(array[j] < array[d])  //如果发现比当前最小元素还小的元素，则更新记录最小元素的下标d
                d = j;

        if(d != i)   //如果最小元素的下标不是后面n - i + 1的未排序序列的第一个元素，则需要交换第i个元素和后面找到的最小元素的位置
        {
            temp = array[d];
            array[d] = array[i];
            array[i] = temp;
        }
    }
}

int main()
{
    int array[] = {3, 1, 15, 11, 89, 5};
    int size = sizeof(array)/sizeof(int);
    selectSort(array, size);

    for(int i = 0; i < size; ++i)
    {
        printf("%d ", array[i]);
    }
    printf("
");
}