程序師世界是廣大編程愛好者互助、分享、學習的平台,程序師世界有你更精彩!
首頁
編程語言
C語言|JAVA編程
Python編程
網頁編程
ASP編程|PHP編程
JSP編程
數據庫知識
MYSQL數據庫|SqlServer數據庫
Oracle數據庫|DB2數據庫
 程式師世界 >> 編程語言 >> C語言 >> C++ >> 關於C++ >> C說話中數組的一些根本常識小結

C說話中數組的一些根本常識小結

編輯:關於C++

C說話中數組的一些根本常識小結。本站提示廣大學習愛好者:(C說話中數組的一些根本常識小結)文章只能為提供參考,不一定能成為您想要的結果。以下是C說話中數組的一些根本常識小結正文


初始化數組

int ages[3] = {4, 6, 9};
int nums[10] = {1,2}; // 其他的主動初始化為0
int nums[] = {1,2,3,5,6}; // 依據年夜括號中的元素個數肯定數組元素的個數
int nums[5] = {[4] = 3,[1] = 2}; // 指定元素個數,同時給指定元素停止初始化
int nums[3]; nums[0] = 1; nums[1] = 2; nums[2] = 3; // 先界說,後初始化

界說然則未初始化,數組中有值,然則是渣滓值。
關於數組來講,一旦有元素被初始 化,其他元素都被賦值0。
盤算數組中元素的個數

int count = sizeof(數組) / sizeof(數組[0]) // 數組的長度 = 數組占用的總字節數 / 數組元素占用的字節數

數組留意事項

在界說數組的時刻[]外面只能寫整型常量或許是前往整型常量的表達式。

int ages['A'] = {19, 22, 33};

printf("ages[0] = %d\n", ages[0]);

int ages[5 + 5] = {19, 22, 33};

printf("ages[0] = %d\n", ages[0]);

int ages['A' + 5] = {19, 22, 33};

printf("ages[0] = %d\n", ages[0])

毛病寫法。

沒有指定元素個數(int nums[] = {1,2,3,5,6}; 如許是可以的,然則假如先聲明,並沒有初始化,則是毛病的)

int a[]; // 毛病

[]中不克不及放變量

int number = 10;

int ages[number]; // 不報錯, 然則沒有初始化, 外面是隨機值
  > int number = 10;
  > 
  > int ages[number] = {19, 22, 33} // 直接報錯

 - > int ages10[5];
  > 
  > ages10 = {19, 22, 33};  // 毛病。只能在界說數組的時刻停止一次性(全體賦值)的初始化

  - 拜訪數組越界。

數組的內存分派:

變量在內存中是從年夜到小尋址的(內存中以字節為單元),好比00000000 00000000 00000000 00001010在內存中,00001010的地址是最小的;而數組則有些分歧,數組的元素天然的從上往下分列 存儲,全部數組的地址為首元素的地址。 (然則構成元素的字節照樣按從年夜到小)

留意:字符在內存中是以對應ASCII值的二進制情勢存儲的,而非上表的情勢。 在這個例子中,數組x的地址為它的首元素的地址0x08,數組ca的地址為0x03。
留意數組越界成績,越界會拜訪到其他內容(好比有兩個數組在內存中挨著,第一個數組越界能夠會拜訪到第二個數組的元素),乃至會讓法式瓦解。

當數組名作為函數參數時, 由於主動轉換為了指針類型,所以在函數中沒法靜態盤算除數組的元素個數。

在64位編譯器下,指針類型默許為8個字節。

有的時刻我們能夠想要在一個函數外面靜態盤算數組的個數,所以能夠會這麼做:

void printMyArray(int myArray[]) {
   int length = sizeof(myArray) / sizeof(myArray[0]);
   for(int i = 0; i < length; i++) {
    printf("%i", myArray[i]);
   }
}

int main() {
  int myArray[5] = {1,2,3,4,5};
  printMyArray(myArray);
  return 0;
}

可以看到在printMyArray函數中我們靜態盤算傳出去的數組的個數,然則成果是毛病的,由於它只能輸入前兩個數。

這是由於,在把數組當做函數的參數的時刻,數組會被以為成指針,所所以8個字節,所以盤算出的length是2,所以只能輸入前兩個數字。

處理:我們須要給出一個新的參數來取得length,在main()外面盤算好length然後傳入printMyArray。

void printMyArray(int myArray[], int length) {
  for(int i = 0; i < length; i++) {
    printf("%i ", myArray[i]);
  }
}

int main(int argc, const char * argv[]) {
  int myArray[5] = {1,2,3,4,5};
  int length = sizeof(myArray) / sizeof(myArray[0]);
  printMyArray(myArray, length);
  return 0;
}

“填坑法”的思惟:

好比給出如許一題。請求從鍵盤輸出6個0~9的數字,排序後輸入。

做法有許多,”填坑法”的意思就是起首界說一個10個數的數組(0~9),初始化都為0。

接著接收用戶的輸出(可以用for輪回),症結的一步是,將用戶輸出的值作為數組的下標,將這個下標所對應的值改成1(填坑),再接著for輪回輸入數組中值是1的索引。

// 空間換時光, 合適數據比擬少
//  1.界說數組,保留用戶輸出的整數
//  必定要給數組初始化, 不然有能夠是一些隨機值
  int numbers[10] = {0};
//  2.吸收用戶輸出的整數
//  2.1界說變量吸收用戶輸出的整數
  int index = -1;
  for (int i = 0; i < 6; i++) {
    printf("請輸出第%d個整數\n", i + 1);
    scanf("%d", &index);
//    將用戶輸出的值作為索引取修正數組中對應的元素的值為1
//    指針的時刻回來演示適才的成績
    numbers[index] = 1 ;
  }

  int length = sizeof(numbers) / sizeof(numbers[0]);
  for (int i = 0; i < length; i++) {
    if (1 == numbers[i]) {
      // 輸入索引
      printf("%d", i);
    }
  }

這個做法的要點是數組中的初始值都為0,而數組的索引和用戶輸出的數字是逐個對應的,所以只須要將用戶輸出的數字絕對應的索引的元素改成1,然後再for輪回輸入的話相當於有序輸入,最初獲得成果。

然則這類做法是有成績的,好比用戶輸出了反復的數字,然則下面的做法只能將雷同的數字輸入一次。我們的做法是將雷同索引的元素的數字累加,以後再增長一層輪回來停止輸入。

//  1.界說數組,保留用戶輸出的整數
  int numbers[10] = {0};
//  2.吸收用戶輸出的整數
//  2.1界說變量吸收用戶輸出的整數
  int index = -1;
  for (int i = 0; i < 6; i++) {
    printf("請輸出第%d個整數\n", i + 1);
    scanf("%d", &index);
//    將用戶輸出的值作為索引取修正數組中對應的元素的值為1
//    假定 用戶輸出的是 1,1,1,2,2,2
    numbers[index] = numbers[index] + 1 ;
  }

  int length = sizeof(numbers) / sizeof(numbers[0]);
  for (int i = 0; i < length; i++) {
//    j = 1 由於假如數組元素中存儲的值是0不消輸入
//    將i對應存儲空間中的元素掏出,斷定須要輸入幾回
    for (int j = 1; j <= numbers[i]; j++) {
      printf("%d", i);// 1 1 1 2 2 2
    }
  }

選擇排序

重要思惟就是,根本上默許數組中第一個元素為最年夜(最小)值,以後將這個元素和前面的每一個元素都停止比擬,以由年夜到小排序為例,當第一個值碰到比其年夜的,就停止交流。如許第一輪事後,第一名就是最年夜的。接著停止第二輪,由第二個數開端逐一比擬,碰到比第二個數年夜的停止交流,如許第二輪以後第二個數就是第二年夜的了,以此類推,赓續停止選擇,最初完成排序。

void selectSort(int numbers[], int length) {
  for (int i = 0; i < length; i++) {
    for (int j = i + 1; j < length; j++) {
      if (numbers[i] < numbers[j]) {
        int temp = numbers[i];
        numbers[i] = numbers[j];
        numbers[j] = temp;
      }
    }
  }
}

int main(int argc, const char * argv[]) {
  int myArray[] = {42, 7, 1, -3, 88};
  int length = sizeof(myArray) / sizeof(myArray[0]);
  selectSort(myArray, length);
  for (int i = 0; i < length; i++) {
    printf("%i ", myArray[i]);
  }
  return 0;
}

在寫的時刻可以如許想:當第一個數來比擬的時刻,i = 0,那末j應當等於i + 1,由於第一個數要和第二個數開端比,而且比擬length - 1次;當i = 1時,j = 2,而且比擬length - 2次,以此類推;下面寫的是由年夜到小排序。

冒泡排序

重要思惟是兩個相鄰的元素停止比擬,以由小到年夜排序為例,那末由第一個元素開端和第二個比擬,假如第一個比第二個年夜,那末就停止交流;然落後行第二個和第三個元素的比擬,以此類推,第一輪以後,那末數組的最初一個元素就是最年夜的,以此類推。

void bubbleSort(int numbers[], int length) {
  for (int i = 0; i < length - 1; i++) {
    for (int j = 0; j < length - i - 1; j++) {
      if (numbers[j] > numbers[j + 1]) {
        int temp = numbers[j];
        numbers[j] = numbers[j + 1];
        numbers[j + 1] = temp;
      }
    }
  }
}

int main(int argc, const char * argv[]) {
  int myArray[] = {42, 7, 1, -3, 88};
  int length = sizeof(myArray) / sizeof(myArray[0]);
  bubbleSort(myArray, length);
  for (int i = 0; i < length; i++) {
    printf("%i ", myArray[i]);
  }
  return 0;
}

留意這裡和選擇排序分歧的是,比擬的並不是numbers[i]和numbers[j],而是比擬的numbers[j]和numbers[j+1],而外層輪回的i代表比擬的輪數,內層輪回才是真實的每輪停止的比擬。這裡是由小到年夜排序。

折半查找

折半查找望文生義,我們找到數組的最年夜值max,最小值min求出中央值mid,然後用mid作為數組下標獲得對應的元素,用這個元素和目的值key停止比擬:

假如numbers[mid] > key,那末解釋key在min和mid之間,那末就設置max為mid - 1,min不變,然後從新盤算mid,反復上述步調,最初找出key。

假如numbers[mid] < key,那末解釋key在mid和max之間,那末就設置min為mid + 1,max不變,然後從新盤算mid,反復上述步調,最初找出key。

留意這裡的停止前提,有能夠數組中有這個key,也有能夠沒有,那末當min > max時,解釋數組中並沒有這個key,要當心這類情形。

折半查找請求數組必需是有序的。(有序表)

int binSearch(int myArray[], int length, int key) {
  int index = -1;

  int max = length - 1;
  int min = 0;
  int mid = (max + min) / 2;

  while (min <= max) {
    if (myArray[mid] > key) {
      max = mid - 1;
    } else if (myArray[mid] < key){
      min = mid + 1;
    } else if (myArray[mid] == key) {
      index = mid;
      break;
    }
    mid = (max + min) / 2;
  }

  return index;
}

int main(int argc, const char * argv[]) {
  int myArray[] = {-3, 1, 7, 42, 88};
  int length = sizeof(myArray) / sizeof(myArray[0]);
  int index = binSearch(myArray, length, 88);
  printf("index: %i ", index);
  return 0;
}

起首我假定index = -1,表現沒有響應的值。接著獲得max,min,mid的值,留意while輪回的前提,在這裡我用的是當min <= max的時刻輪回,當min > max時刻跳出輪回,解釋並未找到key的值。在輪回體外面,像適才剖析的那樣斷定,當myArray[mid] == key的時刻解釋我們找到了這個值,那末將index設置成找到值的下標,然後跳出輪回。假如未找到值則index = -1。

  1. 上一頁:
  2. 下一頁:
Copyright © 程式師世界 All Rights Reserved