2.1 顺序表

03.对长度为n的顺序表L。编写一个时间复杂度为O(n)，空间复杂度为1的算法,删除顺序表中所有值为x的元素

#include <iostream>
using namespace std;

// 算法空间复杂度为O(1)意味着只能原地修改数组
void deleteAtValue(int arr[], int val, int &length) {
	int k = 0;
	for (int i = 0; i < length; ++i) {
		if (arr[i] == val) { k++; }
		else { arr[i - k] = arr[i]; }
	}
	length = length - k;
}

04从顺序表中删除其值在给定值s和t之间（包括s和t，要求s<t）的所有元素，若s或t不合理或顺序表为空，返回错误信息并退出程序

#include <iostream>
using namespace std;

void deleteAtInterval(int arr[], int s, int t,int &length) {
	int k = 0;
	for (int i = 0; i < length; ++i) {
		if (arr[i] <= t && arr[i] >= s) { k++; }
		else {
			arr[i - k] = arr[i];
		}
	}
	length -= k;
}

int main() {
	int arr[] = { 23,123,445,3,13,213,435,4341,22,2,3,1,3,5,9,8 };
	int len = sizeof(arr) / sizeof(arr[0]);
	deleteAtInterval(arr, 1, 100, len);
	for (int i = 0; i < len; ++i) {
		cout << arr[i] << " ";
	}
}

05.从顺序表中删除所有其值重复的元素，使表中的元素互不相同。

#include <iostream>
using namespace std;

void Deduplicate(int arr[], int &length) {
    for (int i = 0; i < length; i++) {
        for (int j = i + 1; j < length;) {
            if (arr[i] == arr[j]) {
                for (int k = j; k < length - 1; k++) {
                    arr[k] = arr[k + 1];
                }
                length--;
            } else {
                j++;
            }
        }
    }
}

int main() {
    int arr[] = {1, 2, 2, 3, 3, 3, 4, 4, 4, 4};
    int length = sizeof(arr) / sizeof(arr[0]);

    Deduplicate(arr, length);

    for (int i = 0; i < length; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;

    return 0;
}

08.线性表(a1,a2...an)中的元素递增有序且按顺序存储于计算机内，要求设计一个算法，完成用最少时间在表中查找数值为x的元素，若找到，则将其于后继位置相交换，若找不到，则将其插入表中并且使表中元素仍然有序递增

#include <iostream>
using namespace std;

void bSearch(int arr[], int x, int& length) {
	int l = -1;
	int r = length;
	while (l + 1 < r) {
		int mid = (l + r) / 2;
		if (arr[mid] >= x) { r = mid; }
		else { l = mid; }
	}
	if (arr[r] == x) { swap(arr[r], arr[r + 1]); }
	else {
		for (int i = length - 1; i > r; --i) {
			arr[r + 1] = arr[r];
		}
		arr[r] = x;
	}
	length++;

}

09.给定三个序列A,B,C，长度均为n，且均无重复元素的递增序列，请设计一个时间复杂度上尽可能高效的算法，逐行输出同时存在于这三个序列的所有元素

#include <iostream>
using namespace std;

int bSearch(int arr[], int x, int& length) {
	int l = -1;
	int r = length;
	while (l + 1 < r) {
		int mid = (l + r) / 2;
		if (arr[mid] >= x) { r = mid; }
		else { l = mid; }
	}
	return r;
}
int sameElement(int arr1[],int arr2[],int arr3[],int length) {
	for (int i = 0; i < length; ++i) {
		int idx1 = bSearch(arr2, arr1[i],length);
		int idx2 = bSearch(arr3, arr1[i],length);
		if (arr1[i] == arr2[idx1] && arr2[idx1] == arr3[idx2]) { cout << arr1[i] << endl; }
	}
	return 0;
}

13.给定一个含n（n>=1）个整数的数组，请设计一个在时间上尽可能高效的算法，找出数组中未出现的最小正整数。

#include <iostream>
using namespace std;

int findSmallestMissingPositive(int arr[], int n) {
    bool present[100000] = { false };

    for (int i = 0; i < n; i++) {
        if (arr[i] > 0 && arr[i] <= n) {
            present[arr[i]] = true;
        }
    }

    for (int i = 1; i <= n; i++) {
        if (!present[i]) {
            return i;
        }
    }

    return n + 1;
}

14.定义三元组(a,b,c)的距离D = |a-b|+|b-c|+|c-a|,给定三个非空整数集合S1,S2,S3,按升序分别存储在3个数组中。请设计一个尽可能高效的算法，计算并输出所有可能的三元组中的最小距离

#include <iostream>
#include <limits.h>

int minDistance(int arr1[], int size1, int arr2[], int size2, int arr3[], int size3) {
    int minDist = INT_MAX;
    int i = 0, j = 0, k = 0;

    while (i < size1 && j < size2 && k < size3) {
        int dist = abs(arr1[i] - arr2[j]) + abs(arr2[j] - arr3[k]) + abs(arr3[k] - arr1[i]);
        minDist = std::min(minDist, dist);

        int minVal = std::min(arr1[i], std::min(arr2[j], arr3[k]));

        if (arr1[i] == minVal) i++;
        else if (arr2[j] == minVal) j++;
        else k++;
    }

    return minDist;
}

01.从顺序表中删除具有最小值的元素（假设唯一），并由函数返回被删除的元素。空出的位置由最后一个元素填补，若顺序表为空，则显示出错信息并退出运行

#include <iostream>
using namespace std;

// 计算数组中的最小值的索引，同时传入数组长度
int MIN(int arr[], int length) {
    int m = 0x3f3f3f3f;
    int idx = -1;
    for (int i = 0; i < length; ++i) {
        if (arr[i] < m) {
            m = arr[i];
            idx = i;
        }
    }
    return idx;
}

// 弹出最小值所在位置的元素，同时传入数组和数组长度
int pop(int arr[], int& length) {
    int minIndex = MIN(arr, length);
    int res = arr[minIndex];
    arr[minIndex] = arr[length - 1];
    length--;
    return res;
}

int main() {
    int arr[] = { 123, 4, 2, 31, 43 };
    int length = sizeof(arr) / sizeof(arr[0]);
    int res = pop(arr, length);
    for (int i = 0; i < length; i++) {
        cout << arr[i] << " ";
    }
    cout << "弹出的最小元素是:" << res << endl;
}

02.设计一个高效算法，将顺序表L的所有元素逆置，要求算法的空间复杂度为O(1)

#include <iostream>
using namespace std;

// 算法空间复杂度为O(1)意味着只能原地修改数组
void reverse(int arr[],int length) {
	int l, r;
	l = 0;
	r = length - 1;
	while (l < r) {
		int temp = arr[l];
		arr[l] = arr[r];
		arr[r] = temp;
		l++;
		r--;
	}
}