第二章线性表

最新推荐文章于 2024-09-11 22:48:33 发布

路哞哞

最新推荐文章于 2024-09-11 22:48:33 发布

阅读量322

点赞数

文章标签：算法数据结构

本文链接：https://blog.csdn.net/qq_34696503/article/details/125786294

版权

本文介绍了顺序表的基本概念，包括静态和动态分配的顺序表定义，并提供了初始化、插入、删除等操作的C语言实现。同时，展示了王道书中的部分算法题目，如找中位数、主元素（摩尔投票法）、最小未出现正整数等，以及相关解决方案。此外，还讨论了数组操作和排序算法，如合并排序、中位数查找和数组元素调整等。

摘要由CSDN通过智能技术生成

一、顺序表

1.1 基本定义

#define MaxSize 10

// 静态分配定义
typedef struct {
	int data[MaxSize];
	int length;
} SqList;

// 初始化
void InitList(SqList &L) {
	for (int i = 0; i < MaxSize; i ++ )
		L.data[i] = 0;
	L.length = 0;
}

// 插入顺序表
bool ListInsert(SqList &L, int i, int e) {
	if (i < 1 || i > L.length + 1) return false;
	if (L.length == MaxSize) return false;
	for (int j = L.length; j >= i; j -- ) L.data[j] = L.data[j - 1];
	L.data[i - 1] = e;
	L.length ++ ;
	return true;
}

// 删除顺序表中的元素
bool ListDelete(SqList &L, int i, int &e) {
	if (i < 1 || i > L.length) return false;
	e = L.data[i - 1];
	for (int j = i; j < L.length; j ++ ) L.data[j - 1] = L.data[j];
	L.length -- ;
	return true;
}

// 按位取值
int GetElem(SqList L, int i) {
	return L.data[i - 1];
}

// 按值获取位置
int LocateElem(SqList L, int e) {
	for (int i = 0; i < L.length; i ++ )
		if (L.data[i] == e) return i + 1;
	return 0;
}

补充一个动态分配的顺序表定义：

#define InitSize 10

typedef struct {
	int *data;
	int MaxSize;
	int length;
} SeqLsit;

// 初始化
void InitList(SeqLsit &L) {
	L.data = (int *)malloc(InitSize * sizeof(int));
	L.length = 0;
	L.MaxSize = InitSize;
}

// 扩大顺序表
void IncreaseSize(SeqLsit &L, int len) {
	int *p = L.data;
	L.data = (int *)malloc((L.MaxSize + len) * sizeof (int));
	for (int i = 0; i < L.length; i ++ ) L.data[i] = p[i];
	L.MaxSize = L.MaxSize + len;
	free(p);
}

1.2 王道书题目（2023版）

01

int Solu_1(int q[], int len) {
	if (len == 0) {
		printf("顺序表为空\n");
		return -1;
	}
	int res = q[0], pos = 0;
	for (int i = 0; i < len; i ++ )
		if (q[i] < res) 
			res = q[i], pos = i;
	q[pos] = q[len - 1];
	return res;
}

02

void Solu_2(int q[], int len) {
	for (int i = 0; i < len / 2; i ++ ) {
		int tmp = q[i];
		q[i] = q[len - i - 1];
		q[len - i - 1] = tmp;
	}
}

03

void Solu_3(int q[], int len, int x) {
	for (int i = 0, j = 0; i < len; i ++ )
		if (q[i] != x) q[j ++ ] = q[i];
}

04

void Solu_4(int q[], int len, int s, int t) {
	if (len == 0) {
		printf("顺序表为空\n");
		return;
	}
	if (s >= t) {
		printf("s和t不合理\n");
		return;
	}
	for (int i = 0, j = 0; i < len; i ++ ) 
		if (q[i] < s || q[i] > t) q[j ++ ] = q[i];
}

06

void Solu_6(int q[], int len) {
	for (int i = 1, j = 0; i < len; i ++ )
		if (q[i] != q[j]) q[ ++ j] = q[i];
}

07

void Solu_7(int q1[], int len1, int q2[], int len2, int ret[]) {
    int i = 0, j = 0, k = 0;
    while (i < len1 && j < len2)
        if (q1[i] <= q2[j]) ret[k++] = q1[i++];
        else ret[k++] = q2[j++];
    while (i < len1) ret[k++] = q1[i++];
    while (j < len2) ret[k++] = q2[j++];
}

一个经典错误：在函数内部开一个数组，函数结束后数组被清除，所以在函数外部输出的时候就是错误的数据！

int[] Solu_7(int q1[], int len1, int q2[], int len2) {
	int ret[len1 + len2]; // 这里在函数内部开的数组
	int i = 0, j = 0, k = 0;
	while (i < len1 && j < len2) 
		if (q1[i] < q2[j]) ret[k ++ ] = q1[i ++ ];
		else ret[k ++ ] = q2[j ++ ];
	while (i < len1) ret[k ++ ] = q1[i ++ ];
	while (j < len2) ret[k ++ ] = q2[j ++ ];
	return ret;
}

int main() {
	int q1[] = {2, 2, 3, 4, 4}, q2[] = {3, 5, 6};
	int ret[] = Solu_7(q1, 5, q2, 3);
	for (int i = 0; i < 8; i ++ ) cout << ret[i] << " "; // 打印的全是错误的数据
	return 0;
}

08

void Solu_08(int q[], int len, int left, int right) {
    if (left >= right || right >= len) return;
    int mid = (left + right) >> 1;
    for (int i = 0; i < mid - left + 1; i ++ ) {
        int tmp = q[left + i];
        q[left + i] = q[right - i];
        q[right - i] = tmp;
    }
}

09

void Solu_09(int q[], int len, int x) {
    int l = 0, r = len - 1;
    while (l < r) {
        int mid = (l + r) >> 1;
        if (q[mid] >= x) r = mid;
        else l = mid + 1;
    }
    if (q[l] == x) {
        if (l != len - 1) {
            int tmp = q[l + 1];
            q[l + 1] = q[l];
            q[l] = tmp;
        } else return;
    } else {
        for (int i = len; i > l; i -- ) q[i] = q[i - 1]; // 易错：这一步要从后往前
        q[l] = x;
    }
}

11 找中位数

参见LeetCode 4

暴力做法：将两个数组合并后排序，如果总共有奇数个数，中位数为中间一个数，否则为中间两个数的平均值。
时间复杂度： $O (n l o g n)$
空间复杂度： $O (n + m)$

class Solution {
public:
    double findMedianSortedArrays(vector<int> &nums1, vector<int> &nums2) {
        int total = nums1.size() + nums2.size();
        vector<int> alls;
        for (auto c: nums1) alls.push_back(c);
        for (auto c: nums2) alls.push_back(c);
        sort(alls.begin(), alls.end());
        if (total & 1) return alls[total / 2];
        else return (alls[total / 2] + alls[total / 2 - 1]) / 2.0;
    }
};

优化做法：递归

首先，如果 $(m+n)\&1 = 0$ ，那么中位数为中间两个数之和在除以 $2.0$ ，否则中位数为最中间的一个数。

原问题难以直接递归求解，所以我们先考虑这样一个问题：在两个有序数组中，找出第 $k$ 小数。如果该问题可以解决，那么第 $(n + m) /2$ 小数就是我们要求的中位数。

先从简单情况入手，假设有数组 $n u m s [1, m + n] ， n u m s 1 [1, m] ， n u m s 2 [1, n]$ ，且 $m, n \geq k /2$ 。我们先从 $n u m s 1$ 和 $n u m s 2$ 中各取前 $k /2$ 个元素：

如果 $n u m s 1 [k /2] < n u m s 2 [k /2]$ ，那么在数组 $n u m s 1$ 中小于等于 $n u m s 1 [k /2]$ 的数的个数有 $k /2$ 个；因为 $n u m s 1 [k /2] < n u m s 2 [k /2]$ ，所以在数组 $n u m s 2$ 中小于等于 $n u m s 1 [k /2]$ 的数的个数应该小于 $k /2$ 个。因此，在数组 $n u m s$ 中，小于等于 $n u m s 1 [k /2]$ 的个数应该小于 $k$ 个，所以对于数组 $n u m s 1 [1, k /2]$ 的数都不会是中位数，就可以将这部分数据删去；
对于 $n u m s 1 [k /2] > n u m s 2 [k /2]$ 的时候同理，对于数组 $n u m s 2 [1, k /2]$ 的数都不会是中位数，就可以将这部分数据删去；
当 $n u m s 1 [k /2] = n u m s 2 [k /2]$ 的时候，说明 $n u m s [k /2]$ 恰好是第 $k$ 个元素，这时候可以删去 $n u m s 1 [1, k /2]$ 或 $n u m s 2 [1, k /2]$ 任意一个；

可以发现每一次比较完之后，都可以删去 $k /2$ 个元素，所以每一次 $k$ 都会除以 $2$ 。当 $k = 1$ 的时候，即比较两个数组的最小值。所以这个过程最多递归 $log^k$ 次，因为 $k = (m + n) /2$ ，所以时间复杂度为 $\frac{1}{2} log^{(m+n)}$ ，即为 $log^{(m+n)}$ 。

时间复杂度： $l o g (m + n)$
空间复杂度： $O (1)$

class Solution {
public:
    double findMedianSortedArrays(vector<int> &nums1, vector<int> &nums2) {
        int total = nums1.size() + nums2.size();
        if (!(total & 1)) {
            int left = findKthNumber(nums1, 0, nums2, 0, total / 2);
            int right = findKthNumber(nums1, 0, nums2, 0, total / 2 + 1);
            return (left + right) / 2.0;
        } else return findKthNumber(nums1, 0, nums2, 0, total / 2 + 1);
    }

    int findKthNumber(vector<int> &nums1, int i, vector<int> &nums2, int j, int k) {
        if (nums1.size() - i > nums2.size() - j) return findKthNumber(nums2, j, nums1, i, k); // 使第一个数组较短
        if (nums1.size() == i) return nums2[j + k - 1]; // 第一个数组为空
        if (k == 1) return min(nums1[i], nums2[j]); // 只有一个数
        int si = min(i + k / 2, int(nums1.size())), sj = j + k / 2; // 第一个数组较短，可能越界
        if (nums1[si - 1] > nums2[sj - 1]) return findKthNumber(nums1, i, nums2, sj, k - (sj - j)); // 将nums2前面的数删去
        else return findKthNumber(nums1, si, nums2, j, k - (si - i));
    }
};

12 找主元素：摩尔投票法

int Solu_12(int q[], int len) {
    int cnt = 0, val;
    for (int i = 0; i < len; i ++ ) {
        if (!cnt) val = q[i], cnt ++ ;
        else if (q[i] == val) cnt ++ ;
        else cnt -- ;
    }
    return val;
}

13 数组中未出现过得最小正整数

int Solu_13(int A[], int n) {
    int *B;
    B = (int *)malloc(sizeof (int) * n);
    memset(B, 0, sizeof B);
    for (int i = 0; i < n; i ++ )
        if (A[i] > 0) B[i] = 1;
    int i = 0;
    while (i < n)
        if (!B[i]) break;
    return i + 1;
}

14 三元组的最小距离

三元组 $(a, b, c)$ 之间的距离 = $\times 2$

#include <iostream>
#include <algorithm>
using namespace std;

typedef long long LL;

const int N = 1e5 + 10;

int l, m, n;
int a[N], b[N], c[N];

int main() {
    scanf("%d%d%d", &l, &m, &n);
    for (int i = 0; i < l; i ++ ) scanf("%d", a + i);
    for (int i = 0; i < m; i ++ ) scanf("%d", b + i);
    for (int i = 0; i < n; i ++ ) scanf("%d", c + i);
    LL res = 1e18;
    for (int i = 0, j = 0, k = 0; i < l && j < m && k < n; ) {
        int x = a[i], y = b[j], z = c[k];
        res = min(res, (LL)max(max(x, y), z) - min(min(x, y), z));
        if (x <= y && x <= z) i ++ ;
        else if (y <= x && y <= z) j ++ ;
        else k ++ ;
    }
    printf("%lld\n", res * 2);
    return 0;
}

路哞哞

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第二章线性表

补充一个动态分配的顺序表定义：1.2 王道书题目（2023版）010203040607一个经典错误：在函数内部开一个数组，函数结束后数组被清除，所以在函数外部输出的时候就是错误的数据！080911 找中位数参见LeetCode 4暴力做法：将两个数组合并后排序，如果总共有奇数个数，中位数为中间一个数，否则为中间两个数的平均值。时间复杂度：O(nlogn)O(nlogn)O(nlogn)空间复杂度：O(n+m)O(n + m)O(n+m)优化做法：递归首先，如果(
复制链接

扫一扫