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("\n");

}