线性表之数组

一、数组的定义与概念

  数组（Array） 是一组相同类型元素的有序集合，这些元素在内存中是连续存储的。数组通过下标（Index） 来访问每一个元素。

例如：

int arr[5] = {10, 20, 30, 40, 50};

上面定义了一个整型数组 arr，它有 5 个元素，依次存储在连续的内存空间中：

注意：

• 数组下标从 0 开始；
• 元素在内存中是连续存放的；
• 数组大小在定义后 不可改变（静态数组）。

二、数组的特点

优点：

• 下标访问（随机访问）时间复杂度是O(1)
• 末尾位置增加删除元素的时间复杂度是O(1)
• 访问元素前后相邻位置的元素非常方便

缺点：

• 非末尾位置增加删除元素需要进行大量的数据移动O(n)
• 搜索的时间复杂度：无序数组-线性搜索O(n)；有序数组-二分搜索O(logn)
• 数组扩容消耗比较大

三、数组的实现

#include <iostream>
#include <stdlib.h>
#include <time.h>

using namespace std;

 // 数组实现
class Array {
public:
	Array(int size = 10):m_cur(0), m_cap(size) {
		m_pArr = new int[m_cap];
	}

	~Array() {
		delete []m_pArr;
		m_pArr = nullptr;
	}

	// 末尾增加元素 O(1)
	void push_back(int val) {
		if (m_cap == m_cur) {
			expand(2 * m_cap);
		}
		
		m_pArr[m_cur++] = val;
	}
	 
	// 末尾删除元素 O(1)
	void pop_back() {
		if (m_cur == 0) {
			return;
		}
		m_cur--;
	}

	// 按位置增加元素 O(n)
	void insert(int pos, int val) {
		if (pos < 0 || pos > m_cur) {
			return;
		}

		if (m_cur == m_cap) {
			expand(2 * m_cap);
		}

		// 移动元素
		for (int i = m_cur - 1; i >= pos; i--) {
			m_pArr[i + 1] = m_pArr[i];
		}

		m_pArr[pos] = val;
		m_cur++;
	}

	// 按位置删除 O(n)
	void erase(int pos) {
		if (pos < 0 || pos > m_cur) {
			return;
		}

		for (int i = pos + 1; i < m_cur; i++) {
			m_pArr[i - 1] = m_pArr[i];
		}

		m_cur--;
	}

	// 元素查询 O(n)
	int find(int val) {
		for (int i = 0; i < m_cur; i++) {
			if (m_pArr[i] == val) {
				return i;
			}
		}
		return -1;
	}

	// 打印数据
	void show() const {
		for (int i = 0; i < m_cur; i++) {
			cout << m_pArr[i] << " ";
		}
		cout << endl;
	}

private:
	void expand(int size) {
		int* p = new int[size];
		memcpy(p, m_pArr, sizeof(int) * m_cap);
		delete []m_pArr;

		m_pArr = p;
		m_cap = size;
	}

private:
	int* m_pArr; // 指向可扩容的数组内存
	int m_cap;	// 数组的容量
	int m_cur; // 数组有效个数
};

int main() {
	Array arr;

	srand(time(0));
	for (int i = 0; i < 10; i++) {
		arr.push_back(rand() % 100);
	}

	arr.show();
	arr.pop_back();
	arr.show();

	arr.insert(0, 100);
	arr.show();

	arr.insert(10, 200);
	arr.show();

	int pos = arr.find(100);
	if (pos != -1) {
		arr.erase(pos);
		arr.show();
	}
}

输出结果：

四、逆序字符串

#include <iostream>
#include <string.h>

// 逆序字符串
void Reverse(char arr[], int size) {
	char* p = arr;
	char* q = arr + size - 1;
	
	while (p < q) {
		char ch = *p;
		*p = *q;
		*q = ch;
		p++;
		q--;
	}
}

int main() {
	char arr[] = "hello world";
	Reverse(arr, strlen(arr));
	cout << arr << endl;
 }

输出结果：

五、奇偶数调整问题

// 整形数组，把偶数调整到数组的左边，把奇数调整到数组的右边
void adjustArray(int arr[], int size) {
	int* p = arr;
	int* q = arr + size - 1;

	while (p < q) {
		while (p < q) {
			// p 向右找奇数
			if ((*p & 0x1) == 1) {
				break;
			}
			p++;
		}

		while (p < q) {
			// q 向左找偶数
			if ((*q & 0x1) == 0) {
				break;
			}
			q--;
		}

		// p指向了奇数，q指向了偶数
		if (p < q) {
			int tmp = *p;
			*p = *q;
			*q = tmp;
			p++;
			q--;
		}
		
	}
}

int main() {
	int arr[10] = { 0 };
	srand(time(0));
	for (int i = 0; i < 10; i++) {
		arr[i] = rand() % 100;
	}

	for (int v : arr) {
		cout << v << " ";
	}
	cout << endl;

	adjustArray(arr, 10);

	for (int v : arr) {
		cout << v << " ";
	}
	cout << endl;
 }

输出结果：