数组数据结构

更新于 2025/10/16 16:21:06

什么是数组？

数组是一种线性数据结构，定义为具有相同或不同数据类型的元素的集合。它们既可以存在于单维，也可以存在于多维。当需要将多个性质相似的元素存储在一个位置时，这些数据结构就派上用场了。

数组索引和内存地址的区别在于，数组索引充当键值对，用于标记数组中的元素。而内存地址是可用内存的起始地址。

以下是理解数组概念的重要术语。

元素 −数组中存储的每个项目称为一个元素。
索引 − 数组中元素的每个位置都有一个数字索引，用于标识该元素。

语法

在 C 和 C++ 编程语言中创建数组 −

data_type array_name[array_size]={元素以逗号分隔}
或，
data_type array_name[array_size];

在 Java 编程语言中创建数组 −

data_type[] array_name = {元素以逗号分隔}
或，
data_type array_name = new data_type[array_size];

数组的必要性

数组可用于解决许多问题，从小型排序问题到更复杂的问题（例如旅行商问题）。除了数组之外，还有许多其他数据结构可以为这些问题提供高效的时间和空间复杂度，那么为什么使用数组更好呢？答案在于随机访问查找时间。

数组提供O(1)的随机访问查找时间。这意味着，访问数组的第一个索引和第 1000 个索引所需的时间相同。这是因为数组带有一个指针和一个偏移量值。指针指向内存的正确位置，而偏移量值指示在该内存中查找的距离。

                           array_name[index]
                              |       |
                           Pointer   Offset

因此，在一个包含 6 个元素的数组中，要访问第一个元素，数组指向索引 0。同样，要访问第 6 个元素，数组指向索引 5。

数组表示

数组表示为存储桶的集合，每个存储桶存储一个元素。这些存储桶的索引从 0 到 n-1，其中 n 是该特定数组的大小。例如，一个大小为 10 的数组的存储桶索引从 0 到 9。

多维数组的索引方式也类似。如果是二维数组，则每个存储桶中都有子存储桶。然后，它将被索引为 array_name[m][n]，其中 m 和 n 是数组中每一层的大小。

根据上图，以下是需要考虑的要点。

索引从 0 开始。
数组长度为 9，这意味着它可以存储 9 个元素。
每个元素都可以通过其索引访问。例如，我们可以将索引 6 处的元素作为 23 获取。

数组的基本操作

数组的基本操作包括插入、删除、查找、显示、遍历和更新。这些操作通常用于修改数组中的数据或报告数组的状态。

以下是数组支持的基本操作。

遍历 − 逐个打印所有数组元素。
插入 − 在给定索引处添加一个元素。
删除 − 在给定索引处删除一个元素。
搜索 − 使用给定索引或值搜索元素。
更新 − 更新给定索引处的元素。
显示 −显示数组的内容。

在 C 语言中，当数组初始化为 size 时，它会按以下顺序为其元素分配默认值。

数据类型	默认值
bool	false
char	0
int	0
float	0.0
double	0.0f
void
wchar_t	0

数组 - 插入操作

在插入操作中，我们向数组中添加一个或多个元素。根据需要，可以在数组的开头、结尾或任何给定的索引处添加新元素。这可以通过编程语言的输入语句完成。

算法

以下是将元素插入线性数组直至到达数组末尾的算法。

1. 开始
2. 创建一个所需数据类型和大小的数组。
3. 将变量"i"初始化为 0。
4. 输入数组第 i 个索引处的元素。
5. 将 i 加 1。
6. 重复步骤 4 和 5，直到到达数组末尾。
7. 停止

示例

这里，我们看到了插入操作的实际实现，我们在数组末尾添加数据 −

C C++ Java Python

#include <stdio.h>
int main(){
   int LA[3] = {}, i;
   printf("插入前的数组：
");
   for(i = 0; i < 3; i++)
      printf("LA[%d] = %d 
", i, LA[i]);
   printf("插入元素.. 
");
   printf("The array elements after insertion :
"); // 打印数组值
   for(i = 0; i < 3; i++) {
      LA[i] = i + 2;
      printf("LA[%d] = %d 
", i, LA[i]);
   }
   return 0;
}

#include <iostream>
using namespace std;
int main(){
   int LA[3] = {}, i;
   cout << "插入前的数组：" << endl;
   for(i = 0; i < 3; i++)
      cout << "LA[" << i <<"] = " << LA[i] << endl; 
      
   //prints garbage values
   cout << "插入元素.." <<endl;
   cout << "插入后的数组：" << endl; // 打印数组值
   for(i = 0; i < 5; i++) {
      LA[i] = i + 2;
      cout << "LA[" << i <<"] = " << LA[i] << endl;
   }
   return 0;
}

public class ArrayDemo {
   public static void main(String []args) {
      int LA[] = new int[3];
      System.out.println("插入前的数组：");
      for(int i = 0; i < 3; i++)
         System.out.println("LA[" + i + "] = " + LA[i]); //prints empty array
      System.out.println("插入元素..");
      
      // 插入后打印数组
      System.out.println("插入后的数组：");
      for(int i = 0; i < 3; i++) {
         LA[i] = i+3;
         System.out.println("LA[" + i + "] = " + LA[i]);
      }
   }
}

# 使用插入操作插入元素的 Python 程序
def insert(arr, element):
    arr.append(element)
# 驱动程序代码
if __name__ == '__main__':
	# 声明要插入的数组和值
	LA = [0, 0, 0]
	x = 0
	# 插入元素之前的数组
	print("插入前的数组： ")
	for x in range(len(LA)):
	    print("LA", [x], " = " , LA[x])
	print("插入元素....")
	# 插入元素后的数组
	for x in range(len(LA)):
	    LA.append(x);
	    LA[x] = x+1;
	print("插入后的数组： ")
	for x in range(len(LA)):
	    print("LA", [x], " = " , LA[x])

输出

插入前的数组：
LA[0] = 0
LA[1] = 0
LA[2] = 0
插入元素..
插入后的数组：
LA[0] = 2
LA[1] = 3
LA[2] = 4
LA[3] = 5
LA[4] = 6

如需了解数组插入操作的其他变体，请点击此处。

数组 - 删除操作

在此数组操作中，我们从数组的特定索引中删除一个元素。此删除操作发生在我们将后续索引中的值赋值给当前索引时。

算法

假设 LA 是一个包含 N 个元素的线性数组，K 是一个正整数，且 K^{=N。以下是删除 LA 中第 K 个元素的算法。}

1. 开始
2. 设置 J = K
3. 重复步骤 4 和 5，直至 J < N
4. 令 LA[J] = LA[J + 1]
5. 令 J = J+1
6. 令 N = N-1
7. 停止

示例

以下是此操作在各种编程语言中的实现 −

C C++ Java Python

#include <stdio.h>
void main(){
   int LA[] = {1,3,5};
   int n = 3;
   int i;
   printf("原始数组元素为：
");
   for(i = 0; i<n; i++)
      printf("LA[%d] = %d 
", i, LA[i]);
   for(i = 1; i<n; i++) {
      LA[i] = LA[i+1];
      n = n - 1;
   }
   printf("删除后的数组元素：
");
   for(i = 0; i<n; i++)
      printf("LA[%d] = %d 
", i, LA[i]);
}

#include <iostream>
using namespace std;
int main(){
   int LA[] = {1,3,5};
   int i, n = 3;
   cout << "原始数组元素为："<<endl;
   for(i = 0; i<n; i++) {
      cout << "LA[" << i << "] = " << LA[i] << endl;
   }
   for(i = 1; i<n; i++) {
      LA[i] = LA[i+1];
      n = n - 1;
   }
   cout << "删除后的数组元素："<<endl;
   for(i = 0; i<n; i++) {
      cout << "LA[" << i << "] = " << LA[i] <<endl;
   }
}

public class ArrayDemo {
   public static void main(String []args) {
      int LA[] = new int[3];
      int n = LA.length;
      System.out.println("Array Before Deletion:");
      for(int i = 0; i < n; i++) {
         LA[i] = i + 3;
         System.out.println("LA[" + i + "] = " + LA[i]);
      }
      for(int i = 1; i<n-1; i++) {
         LA[i] = LA[i+1];
         n = n - 1;
      }
      System.out.println("Array After Deletion:");
      for(int i = 0; i < n; i++) {
         System.out.println("LA[" + i + "] = " + LA[i]);
      }
   }
}

#python 程序使用 delete 操作删除值
if __name__ == '__main__':
	# 声明数组并删除值
	LA = [0,0,0]
	n = len(LA)
	print("Array Before Deletion: ")
	for x in range(len(LA)):
	    LA.append(x)
	    LA[x] = x + 3
	    print("LA", [x], " = " , LA[x])
	# 如果存在则删除该值
	# 或者显示错误，它不存在于列表中
	for x in range(1, n-1):
	    LA[x] = LA[x+1]
	    n = n-1
	print("Array After Deletion: ")
	for x in range(n):
	    print("LA", [x], " = " , LA[x])

输出

原始数组元素为：
LA[0] = 1
LA[1] = 3
LA[2] = 5
删除后的数组元素：
LA[0] = 1
LA[1] = 5

数组 - 搜索操作

使用键在数组中搜索元素；键元素按顺序比较数组中的每个值，以检查键是否存在于数组中。

算法

假设 LA 是一个包含 N 个元素的线性数组，K 是一个正整数，且 K<=N。以下是使用顺序搜索查找值为 ITEM 的元素的算法。

1. 开始
2. 设 J = 0
3. 当 J < N 时重复步骤 4 和 5
4. 如果 LA[J] 等于 ITEM，则转到步骤 6
5. 设 J = J +1
6. 打印 J, ITEM
7. 停止

示例

以下是此操作在各种编程语言中的实现 −

C C++ Java Python

#include <stdio.h>
void main(){
   int LA[] = {1,3,5,7,8};
   int item = 5, n = 5;
   int i = 0, j = 0;
   printf("原始数组元素为：
");
   for(i = 0; i<n; i++) {
      printf("LA[%d] = %d 
", i, LA[i]);
   }
   for(i = 0; i<n; i++) {
      if( LA[i] == item ) {
         printf("Found element %d at position %d
", item, i+1);
      }
   }
}

#include <iostream>
using namespace std;
int main(){
   int LA[] = {1,3,5,7,8};
   int item = 5, n = 5;
   int i = 0;
   cout << "原始数组元素为： " <<endl;
   for(i = 0; i<n; i++) {
      cout << "LA[" << i << "] = " << LA[i] << endl;
   }
   for(i = 0; i<n; i++) {
      if( LA[i] == item ) {
         cout << "Found element " << item << " at position " << i+1 <<endl;
      }
   }
   return 0;
}

public class ArrayDemo{
   public static void main(String []args){
      int LA[] = new int[5];
      System.out.println("Array:");
      for(int i = 0; i < 5; i++) {
         LA[i] = i + 3;
         System.out.println("LA[" + i + "] = " + LA[i]);
      }
      for(int i = 0; i < 5; i++) {
         if(LA[i] == 6)
            System.out.println("Element " + 6 + " is found at index " + i);
      }
   }
}

#使用python进行搜索操作
def findElement(arr, n, value):
	for i in range(n):
		if (arr[i] == value):
			return i
	# If the key is not found
	return -1
# Driver's code
if __name__ == '__main__':
	LA = [1,3,5,7,8]
	print("Array element are: ")
	for x in range(len(LA)):
	    print("LA", [x], " = ", LA[x])
	value = 5
	n = len(LA)
		# 使用搜索操作找到的元素
	index = findElement(LA, n, value)
	if index != -1:
		print("Element", value, "Found at position = " + str(index + 1))
	else:
		print("Element not found")

输出

原始数组元素为：
LA[0] = 1
LA[1] = 3
LA[2] = 5
LA[3] = 7
LA[4] = 8
Found element 5 at position 3

数组 - 遍历操作

此操作遍历数组的所有元素。我们使用循环语句来执行此操作。

算法

以下是遍历线性数组中所有元素的算法 −

1. 开始
2. 初始化一个特定大小和数据类型的数组。
3. 将另一个变量 i 初始化为 0。
4. 打印数组中的第 i 个值并增加 i。
5. 重复步骤 4，直到到达数组末尾。
6. 结束

示例

以下是此操作在各种编程语言中的实现 −

C C++ Java Python

#include <stdio.h>
int main(){
   int LA[] = {1,3,5,7,8};
   int item = 10, k = 3, n = 5;
   int i = 0, j = n;
   printf("原始数组元素为：
");
   for(i = 0; i<n; i++) {
      printf("LA[%d] = %d 
", i, LA[i]);
   }
}

#include <iostream>
using namespace std;
int main(){
   int LA[] = {1,3,5,7,8};
   int item = 10, k = 3, n = 5;
   int i = 0, j = n;
   cout << "The original 数组元素为：
";
   for(i = 0; i<n; i++)
      cout << "LA[" << i << "] = " << LA[i] << endl;
   return 0;
}

public class ArrayDemo {
   public static void main(String []args) {
      int LA[] = new int[5];
      System.out.println("数组元素为： ");
      for(int i = 0; i < 5; i++) {
         LA[i] = i + 2;
         System.out.println("LA[" + i + "] = " + LA[i]);
      }
   }
}

# 使用 Python 代码迭代数组
LA = [1, 3, 5, 7, 8]
# 元素长度
length = len(LA)
# 使用 For 循环和 range 遍历元素
# 等同于 'for x in range(len(array))'
print("数组元素为： ")
for x in range(length):
	print("LA", [x], " = ", LA[x])

输出

原始数组元素为：
LA[0] = 1
LA[1] = 3
LA[2] = 5
LA[3] = 7
LA[4] = 8

数组 - 更新操作

更新操作是指更新数组中给定索引处的现有元素。

算法

假设 LA 是一个包含 N 个元素的线性数组，K 为正整数，且 K<=N。以下是更新 LA 中第 K 个位置可用元素的算法。

1. 开始
2. 设置 LA[K-1] = ITEM
3. 停止

示例

以下是此操作在各种编程语言中的实现 −

C C++ Java Python

#include <stdio.h>
void main(){
   int LA[] = {1,3,5,7,8};
   int k = 3, n = 5, item = 10;
   int i, j;
   printf("原始数组元素为：
");
   for(i = 0; i<n; i++) {
      printf("LA[%d] = %d 
", i, LA[i]);
   }
   LA[k-1] = item;
   printf("更新后的数组元素：
");
   for(i = 0; i<n; i++) {
      printf("LA[%d] = %d 
", i, LA[i]);
   }
}

#include <iostream>
using namespace std;
int main(){
   int LA[] = {1,3,5,7,8};
   int item = 10, k = 3, n = 5;
   int i = 0, j = n;
   cout << "原始数组元素为：
";
   for(i = 0; i<n; i++)
      cout << "LA[" << i << "] = " << LA[i] << endl;
   LA[2] = item;
   cout << "The array elements after updation are :
";
   for(i = 0; i<n; i++)
      cout << "LA[" << i << "] = " << LA[i] << endl;
   return 0;
}

public class ArrayDemo {
   public static void main(String []args) {
      int LA[] = new int[5];
      int item = 15;
      System.out.println("数组元素为： ");
      for(int i = 0; i < 5; i++) {
         LA[i] = i + 2;
         System.out.println("LA[" + i + "] = " + LA[i]);
      }
      LA[3] = item;
      System.out.println("更新后的数组元素为： ");
      for(int i = 0; i < 5; i++)
         System.out.println("LA[" + i + "] = " + LA[i]);
   }
}

#使用 Python 进行更新操作
#声明数组元素
LA = [1,3,5,7,8]
#更新前
print("原始数组元素为：");
for x in range(len(LA)):
    print("LA", [x], " = ", LA[x])
#更新后
LA[2] = 10
print("更新后的数组元素为： ")
for x in range(len(LA)):
    print("LA", [x], " = ", LA[x])

输出

原始数组元素为：
LA[0] = 1
LA[1] = 3
LA[2] = 5
LA[3] = 7
LA[4] = 8
更新后的数组元素：
LA[0] = 1
LA[1] = 3
LA[2] = 10
LA[3] = 7
LA[4] = 8

数组 - 显示操作

此操作使用打印语句显示整个数组中的所有元素。

算法

假设 LA 是一个包含 N 个元素的线性数组。以下是显示数组元素的算法。

1. 开始
2. 打印数组中的所有元素
3. 停止

示例

以下是此操作在各种编程语言中的实现 −

C C++ Java Python

#include <stdio.h>
int main(){
   int LA[] = {1,3,5,7,8};
   int n = 5;
   int i;
   printf("原始数组元素为：
");
   for(i = 0; i<n; i++) {
      printf("LA[%d] = %d 
", i, LA[i]);
   }
}

#include <iostream>
using namespace std;
int main(){
   int LA[] = {1,3,5,7,8};
   int n = 5;
   int i;
   cout << "原始数组元素为：
";
   for(i = 0; i<n; i++)
      cout << "LA[" << i << "] = " << LA[i] << endl;
   return 0;
}

public class ArrayDemo {
   public static void main(String []args) {
      int LA[] = new int[5];
      System.out.println("数组元素为： ");
      for(int i = 0; i < 5; i++) {
         LA[i] = i + 2;
         System.out.println("LA[" + i + "] = " + LA[i]);
      }
   }
}

#使用 Python 进行显示操作
#使用 Python 进行显示操作
#声明数组元素
LA = [2,3,4,5,6]
#显示数组
print("数组元素为： ")
for x in range(len(LA)):
    print("LA", [x], " = " , LA[x])

输出

原始数组元素为：
LA[0] = 1
LA[1] = 3
LA[2] = 5
LA[3] = 7
LA[4] = 8

数据结构和算法

数据结构

链接列表

堆栈 &队列

搜索算法

排序算法

图形数据结构

树数据结构

递归

分而治之

贪婪算法

动态规划

近似算法

随机算法

DSA 有用资源

数组数据结构

什么是数组？

语法

数组的必要性

数组表示

数组的基本操作

数组 - 插入操作

算法

示例

输出

数组 - 删除操作

算法

示例

输出

数组 - 搜索操作

算法

示例

输出

数组 - 遍历操作

算法

示例

输出

数组 - 更新操作

算法

示例

输出

数组 - 显示操作

算法

示例

输出

颜色选择器

读后有收获微信请站长喝咖啡

错误报告

您的建议:

感谢您的帮助！