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");
}