C語言數組

當我們處理大量資料值時，我們需要任意數量的不同變量。随着變量數量的增加，程式的複雜性也會增加，是以程式員會對變量名稱感到困惑。在某些情況下，我們需要處理大量類似的資料值。為了使這項工作更容易，C程式設計語言提供了一個名為“數組”的概念。

數組是一種特殊類型的變量，用于一次存儲多個相同資料類型的值。
數組是存儲在具有單個名稱的連續記憶體位置中的類似資料項的集合。

數組聲明

在C語言中，當我們想要建立一個數組時，我們必須知道要存儲在該數組中的值的資料類型以及要存儲在該數組中的值的數量。

建立一個數組文法: 類型數組名[size]
建立具有大小和初始值的數組的文法:類型數組名[size]={value1,value2,…};
建立沒有大小和初始值的數組的文法:類型數組名[ ]={value1,value2,…};

在上面的文法中，資料類型指定我們存儲在該數組中的值的類型，size指定可以存儲在該數組中的最大值數。

示例代碼

int a [3] ;

這裡，編譯器使用單個名稱“a”配置設定6個位元組的連續記憶體位置，并告訴編譯器将三個不同的整數值（每個記憶體為2個位元組）存儲到該6個位元組的記憶體中。對于上述聲明，記憶體組織如下:

在上面的記憶體配置設定中，所有三個記憶體位置都有一個通用名稱“a”。是以無法直接通路單個記憶體位置。編譯器不僅配置設定記憶體，還為數組的每個單獨的記憶體位置配置設定一個數字引用值。該參考編号稱為“索引”或“下标”。以上示例的索引值如下，數組下标從0開始，故最大下标是 size-1

不同的初始化方式

int arr[8]; //不初始化

int arr[8]=0; //error 數組初始化需要代扣好的初始值設定項清單(大括号初始化)

int arr[8]={0}; //true 告訴編譯器，所有的都按一個方式初始化

int arr[8]={6}; //true 隻有第一個為6，剩下的元素都自動初始化為0

int arr[8]={1,2,3,4,5,6}; //true

int arr[8]={0,1,2,3,4,5,6,7,8}; //error 初始值太多，超出了數組的存儲範圍

int arr[8]={,,,5,2,0}; //error 初始化隻從從左到右，前面和中間都不能省略

int arr[]={1,2,3,4,5}; //true 數組裡有幾個元素？未指定數組大小，編譯器會自動推導出來

int arr[]; //error 既不告訴編譯器要多大記憶體，也不說有幾個元素，編譯器并不知道改怎麼配置設定記憶體

數組的周遊通常通過循環操作，如下代碼

#include <stdio.h>
int main() 
{
  int arr[5] = { 1,2,3,4,5 };
  int length = 5;
  printf("------數組列印--------\n");
  for (int i = 0; i < length; i++)
  {
    printf("%d ", arr[i]);
  }
  printf("\n");
  printf("------使用者輸入--------\n");
  for (int i = 0; i < length; i++)
  {
    int result=scanf("%d", &arr[i]);
  }
  printf("------數組列印--------\n");
  for (int i = 0; i < length; i++)
  {
    printf("%d ", arr[i]);
  }
  printf("\n");
  return 0;
}

數組輸入可以采用換行作為資料間隔，也可以用空格作為資料間隔，運作結果如下:

一維數組正常操作

插入資料

數組的插入主要場景有以下幾種:

從零無序插入
從零有序插入,需要調整資料
有資料按序号插入，需要挪動數組

示例程式| 從零無序插入數組，輸入一組資料，-1作為結束

數組在做任何插入前都需要考慮滿的狀态，數組充當一個容器，插入資料隻需要計數變量count改變，并且充當數組下标，整體操作比較簡單，圖示如下:

示例代碼實作如下:

#include <stdio.h>
int main() 
{
  int array[20] = { 0 };
  const int max = 20;
  int count = 0;
  int value, data;
  while (1) 
  {
    value = scanf("%d", &data);
    if (data == -1) 
    {
      break;
    }
    if (count == max) 
    {
      printf("已滿!");
      break;
    }
    array[count++] = data;
  }
  for (int i = 0; i < count; i++) 
  {
    printf("%d ", array[i]);
  }
  printf("\n");
  return 0;
}

運作效果如下:

示例程式| 從零插入數組，輸入一組資料，實作資料從小到大存儲，-1作為結束

可以在上述代碼的基礎上進行改進，增加排序的功能，當插入第一個元素的時候，預設有序，後面插入的元素，隻需要和前面的元素比較，如果小于前面的元素就進行交換，調整到第一次小于插入元素的位置，或者調整到下标為0的位置。圖示如下:

示例代碼實作如下:

#include <stdio.h>
int main() 
{
  int array[20] = { 0 };
  const int max = 20;
  int count = 0;
  int value, data;
  while (1) 
  {
    value = scanf("%d", &data);
    if (data == -1) 
    {
      break;
    }
    if (count == max) 
    {
      printf("已滿!");
      break;
    }
    array[count++] = data;
    for (int k = count - 1; k > 0; k--) 
    {
      if (array[k] < array[k - 1])
      {
        int temp = array[k];
        array[k] = array[k - 1];
        array[k - 1] = temp;
      }
      else
        break;
    }

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

運作效果如下:

示例程式| 給定已有數組，在指定第幾個元素的位置插入指定資料

需要注意的問題就是第幾個元素和序号的差別，序号是從0開始的，第幾個元素是從1開始的。編寫代碼時候需要考慮序号的有效性，然後唯一要做的就是騰出一個位置，然後插入元素即可，或者先插入到數組最後面，然後一次挪動元素到指定位置也可以。實作示意圖如下:

示例代碼實作如下:

#include <stdio.h>
int main() 
{
  int array[20] = { 555,567,666,999,888 };
  const int max = 20;
  int count = 5;
  int value = 0;
  int index = 0;
  int insertData = 0;
  value=scanf("%d%d", &index,&insertData);
  if (count == max) 
  {
    printf("已滿無法插入!\n");
    return 0;
  }
  if (index<1 || index>count) 
  {
    printf("序号有誤，無法插入!\n");
    return 0;
  }
  array[count++] = insertData;
  for (int k = count - 1; k >= index; k--) 
  {
    int temp = array[k];
    array[k] = array[k - 1];
    array[k - 1] = temp;
  }
  for (int i = 0; i < count; i++) 
  {
    printf("%d ", array[i]);
  }
  printf("\n");
  return 0;
}

運作效果如下:

查找資料

查找資料相對于來說比較簡單，一般是周遊資料直接if比較即可，當然還有一種有序資料的查找可以采用二分法查找提高查找效率。

示例程式| 給定已有數組，查找指定資料的數組下标

#include <stdio.h>
int main() 
{
  int array[20] = { 555,567,666,999,888 };
  const int max = 20;
  int count = 5;
  int pos = -1;
  int value = 0;
  int searchData = 0;
  value=scanf("%d", &searchData);
  for (int i = 0; i < count; i++) 
  {
    if (array[i] == searchData) 
    {
      pos = i;
      break;
    }
  }
  if (pos == -1) 
  {
    printf("未找到指定資料!\n");
  }
  else 
  {
    printf("指定數組下标是:%d\n", pos);
  }
  return 0;
}

上述代碼中的pos初始值為-1 ，因為數組下标也有0下标，作為未找到的的判定，是以初始值是-1。

運作效果如下:

示例程式| 給定已有有序數組，采用二分法查找指定資料的數組下标

#include <stdio.h>
int main()
{
  int array[10] = { 1,2,3,4,5,6,7,8,9,10 };
  int left = 0;
  int right = 9;
  int mid = 0;
  int value, searchData = 0;
  int pos = -1;
  value = scanf("%d", &searchData);

  while (left < right)
  {
    mid = (left + right) / 2;
    if (array[mid] > searchData)
    {
      right = mid - 1;
    }
    else if (array[mid] < searchData)
    {
      left = mid + 1;
    }
    else
    {
      pos = mid;
      break;
    }
  }
  if (pos == -1)
  {
    printf("未找到指定資料!\n");
  }
  else
  {
    printf("指定數組下标是:%d\n", pos);
  }
  return 0;
}

運作效果如下:

删除資料

要注意的就是數組的删除是僞删除，隻要找到指定資料，然後把後面的元素往前移動即可，然後計數變量做減一操作即可，整體難度不大，當然數組的删除也有按照第幾個元素删除，也有删除指定資料的方式。實作示意圖如下:

示例程式| 給定已有數組，删除指定的第幾個元素。

#include<stdio.h>
int main() {

  int array[10] = { 555,567,666,999,888 };
  const int max = 10;
  int count = 5;
  int index, value = 0;
  value = scanf("%d", &index);
  if (index<1 || index>count) 
  {
    printf("索引有誤,無法删除!\n");
    return 0;
  }
  for (int i = index-1; i < count-1; i++) 
  {
    array[i] = array[i + 1];
  }
  count--;    //數組真正的删除
  for (int i = 0; i < count; i++)
  {
    printf("%d ", array[i]);
  }
  printf("\n");
  return 0;
}

運作效果如下:

示例程式| 給定已有數組，删除指定資料。

#include<stdio.h>
int main() {

  int array[10] = { 555,567,666,999,888 };
  const int max = 10;
  int count = 5;
  int index=-1, value = 0;
  int data = 0;
  value = scanf("%d",&data);
  //先查找到序号，剩下的處理方案和序号删除類似
  for (int i = 0; i < count; i++) 
  {
    if (array[i] == data) 
    {
      index = i;
      break;
    }
  }
  if (index == -1)
  {
    printf("未找到指定資料,無法删!\n");
  }
  else 
  {
    for (int i = index; i < count - 1; i++)
    {
      array[i] = array[i + 1];
    }
    count--;    //數組真正的删除
  }
  for (int i = 0; i < count; i++)
  {
    printf("%d ", array[i]);
  }
  printf("\n");
  return 0;
}

運作效果如下:

修改資料

修改資料相對于來說比較簡單，一種是通過輸入序号進行修改，注意序号有效性，實際下标是序号減一即可，還有一種就是查找資料進行修改。

示例程式| 給定已有數組，修改指定序号下的資料

#include<stdio.h>
int main() {

  int array[10] = { 555,567,666,999,888 };
  const int max = 10;
  int count = 5;
  int index=0, value = 0;
  int data = 0;
  value = scanf("%d",&index);
  //先查找到序号，剩下的處理方案和序号删除類似
  if (index<1 || index>count)
  {
    printf("序号有誤，無法修改！");
  }
  else 
  {
    value=scanf("%d", &array[index]);
  }
  printf("\n");
  return 0;
}

示例程式| 給定已有數組，修改指定資料為新的資料

#include<stdio.h>
int main() {

  int array[10] = { 555,567,666,999,888 };
  const int max = 10;
  int count = 5;
  int index=-1, value = 0;
  int data = 0;
  value = scanf("%d",&data);
  //先查找到序号，剩下的處理方案和序号删除類似
  for (int i = 0; i < count; i++) 
  {
    if (array[i] == data) 
    {
      index = i;
      break;
    }
  }
  if (index == -1)
  {
    printf("未找到指定資料,無法修改!\n");
  }
  else 
  {
    array[index] = data;
  }
  for (int i = 0; i < count; i++)
  {
    printf("%d ", array[i]);
  }
  printf("\n");
  return 0;
}

數組簡單排序

示例程式| 冒泡排序

冒泡排序算法思想是相鄰的兩個元素進行比較，不滿足要求規則進行交換，第一次冒泡決定了第一大元素，故第二次冒泡可減少筆記次數一次。外循環給予每個元素有冒泡機會，内循環描述比較次數，代碼實作如下:

#include<stdio.h>
int main() {

  int array[] = { 0,1,2,9,3,4,5,6,7,8 };
  int arrayNum = 10;
  for (int i = 0; i < arrayNum - 1; i++)
  {
    for (int j = 0; j < arrayNum - 1 - i; j++)
    {
      if (array[j] > array[j + 1])
      {
        int temp = array[j];
        array[j] = array[j + 1];
        array[j + 1] = temp;
      }
    }
  }
  for (int i = 0; i < arrayNum; i++) 
  {
    printf("%d ", array[i]);
  }
  printf("\n");
  return 0;
}

示例程式| 選擇排序

選擇排序算法思想是填坑思想，第一個位置，選擇最小的填進去，第二個位置選擇剩餘元素最小的填充第二個位置，

依次類推，外循環用來周遊每一個坑位，内循環去找剩餘元素最小的，找到和目前坑元素交換即可。代碼實作如下:

int minIndex;
  int temp;
  for (int i = 0; i < arrayNum; i++) 
  {
    minIndex = i;  
    //從剩下的元素中找最小的
    for (int j = i + 1; j < arrayNum; j++) 
    {
      if (array[j] < array[minIndex]) 
      {
        minIndex = j;
      }
    }
    //和選出來的那個元素進行交換
    temp = array[i];
    array[i] = array[minIndex];
    array[minIndex] = temp;
  }

示例程式| 插入排序

插入排序算法思想是插隊思想，第一個元素當做有序資料，後續資料插在最後面，依次和前面元素比較，類似有序插入資料，比較到第一次小于插入元素的位置，或者比較到0的位置即可，外循環周遊每個資料，内循環描述插入過程，代碼實作如下:

#include<stdio.h>
int main() {

  int array[] = { 0,1,2,9,3,4,5,6,7,8 };
  int arrayNum = 10;
  int preIndex, current;
  for (int i = 1; i < arrayNum; i++)   //把第一個元素當做是有序序列
  {
    preIndex = i - 1;        //第一個元素的序号
    current = array[i];        //暫時存儲，騰出一個位置
    while (preIndex >= 0 && array[preIndex] > current)
    {
      array[preIndex + 1] = array[preIndex];
      preIndex--;
    }
    array[preIndex + 1] = current;
  }
  for (int i = 0; i < arrayNum; i++) 
  {
    printf("%d ", array[i]);
  }
  printf("\n");
  return 0;
}

客觀請留步

如果閣下正好在學習C/C++，看文章比較無聊，不妨關注下關注下小編的視訊教程，通俗易懂，深入淺出，一個視訊隻講一個知識點。視訊不深奧，不需要鑽研，在公交、在地鐵、在廁所都可以觀看，随時随地漲姿勢。

C語言之一維數組

C語言數組

數組聲明

一維數組正常操作

客觀請留步

繼續閱讀

一維數組和二維數組記憶體示意圖

LeetCode-Reverse Bits

将多層級數組轉化為一級數組（即提取嵌套數組元素最終合并為一個數組）

[Pointer]C中指針與多元數組學習

【Numpy總結】第四節：Numpy的切片索引與進階索引

【Python-numpy】unique 函數解析

python中兩種将高維數組展平為一維數組的方法

LeetCode-Given two numbers represented as strings, return multiplication of the numbers as a string

資料結構，串

ndarray 的建立及屬性

C語言數組——一維數組執行個體詳解

C語言從青銅到王者——數組詳解總結【一維數組、二維數組、字元數組、數組執行個體】

C語言的一維數組

資料結構壓縮矩陣筆記

6種方式實作JavaScript數組扁平化(flat)方法的總結

LeetCode-House Robber