【6.线性表-顺序表示-王道课后算法题】

已于 2025-02-17 11:33:04 修改
阅读量273 收藏
点赞数 4
分类专栏： 数据结构 文章标签： 数据结构 算法
于 2024-08-06 16:21:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_43520227/article/details/140959113
版权

王道数据结构-第二章-顺序表示算法题

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

#include <iostream>
#define MAXSIZE 5
typedef struct {
    int data[MAXSIZE];
    int length;
} SeqList;

/**
* 从顺序表中删除具有最小值的元素(假设唯一)并由函数返回被删元素的值。空出的位置由最后一个元素填补，若顺序表为空，则显示出错信息并退出运行。
* 解析:记录最小值和最小值位置然后进行置换就行
 */
bool deleteMinElement(SeqList &seqList, int &value) {
    if (seqList.length == 0) {
        return false;
    }
    int pos = 0;
    int minValue = seqList.data[0];
    for (int i = 1; i < seqList.length; i++) {
        if (seqList.data[i] < minValue) {
            minValue = seqList.data[i];
            pos = i;
        }
    }
    seqList.data[pos] = seqList.data[seqList.length - 1];
    value=minValue;
    seqList.length--;
    return true;
}

int main() {
    SeqList seqList;
    seqList.length = 5;
    srand((unsigned) time(NULL));
    for (int i = 0; i < seqList.length; i++) {
        seqList.data[i] = rand() % 100;
        printf("%d ", seqList.data[i]);

    }
    int value=0;
    //输出最小值
    if (deleteMinElement(seqList, value)) {
        printf("\n");
        for (int i = 0; i < seqList.length; i++) {
            printf("%d ", seqList.data[i]);
        }
        printf("\n");
        printf("最小值:%d", value);
    } else {
        printf("没有最小值\n");
    }
    return 0;
}

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

#include <iostream>
#define MAXSIZE 5
typedef struct {
    int data[MAXSIZE];
    int length;
} SeqList;
/**
 * 计一个高效算法，将顺序表L的所有元素逆置，要求算法的空间复杂度为O(1)。
 * 解析:就是对调元素位置  【这里要注意循环结束条件为seqList.length / 2】
 */
void invert(SeqList &seqList) {
        for (int i = 0; i < seqList.length / 2; i++) {
        int temp = seqList.data[i];
        seqList.data[i] = seqList.data[seqList.length - 1 - i];
        seqList.data[seqList.length - 1 - i] = temp;
    }
}

int main() {
    SeqList seqList;
    seqList.length = 5;
    srand((unsigned) time(NULL));
    for (int i = 0; i < seqList.length; i++) {
        seqList.data[i] = rand() % 100;
        printf("%d ", seqList.data[i]);

    }
    invert(seqList);
    printf("\n");
    for (int i = 0; i < seqList.length; i++) {
        printf("%d ", seqList.data[i]);
    }
    return 0;
}

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

#include <iostream>
#define MAXSIZE 5
typedef struct {
    int data[MAXSIZE];
    int length;
} SeqList;
/**
* 对长度为n的顺序表L,编写一个时间复杂度为O(n)、空间复杂度为 O(1)的算法，该算法删除顺序表中所有值为x的数据元素。
* 解析:相当于再来一个标记位，从头开始重新赋值不是x的元素到列表中
 */
void deleteX(SeqList &seqList, int x) {
    int k = 0;
    for (int i = 0; i < seqList.length; i++) {
        if (seqList.data[i] != x) {
            seqList.data[k++] = seqList.data[i];
        }
    }
    seqList.length = k;
}

/**
 * 
 * @param seqList 
 * @param x
 * 解析: 每次移动都记录k的个数，到下一个不是k元素时向前移动k个元素
 */
void deleteX2(SeqList &seqList, int x) {
    int k = 0, i = 0;;
    while (i < seqList.length) {
        if (seqList.data[i] == x) {
            k++;
        } else {
            //当前元素不是x,将当前元素移动k个元素的距离
            seqList.data[i - k] = seqList.data[i];
        }
        i++;
    }
    seqList.length -= k;
}
int main() {
    SeqList seqList;
    seqList.length = 5;
    srand((unsigned) time(NULL));
    for (int i = 0; i < seqList.length; i++) {
        seqList.data[i] = rand() % 10;
        printf("%d ", seqList.data[i]);

    }
    deleteX(seqList, 5);
    printf("\n");
    for (int i = 0; i < seqList.length; i++) {
        printf("%d ", seqList.data[i]);
    }
    return 0;
}

4. 从顺序表中删除其值在给定值s和t之间(包含s和t,要求s<t)的所有元素，若s或t不合理或顺序表为空，则显示出错信息并退出运行。

#include <iostream>
#define MAXSIZE 5

typedef struct {
    int data[MAXSIZE];
    int length;
} SeqList;
/**
* 从顺序表中删除其值在给定值s和t之间(包含s和t,要求s<t)的所有元素，若s或t不合理或顺序表为空，则显示出错信息并退出运行。
* 解析:与第3题类似，用k做标记为从头开始扫，仅把不需要删除的赋值到列表中
 */
bool deleteRange(SeqList &seqList, int s, int t) {
    if (s >= t || seqList.length == 0) {
        return false;
    }
    int k = 0;
    for (int i = 0; i < seqList.length; i++) {
        if (seqList.data[i] < s || seqList.data[i] > t) {
            seqList.data[k++] = seqList.data[i];
        }
    }
    seqList.length = k;
    return true;
}

/**
 *
 * @param seqList
 * @param s
 * @param t
 * 解析:记录删除的个数，从第一个开始扫，遇到需要删除的元素，记录个数，否则赋值到列表中
 */
bool deleteRange2(SeqList &seqList, int s, int t) {
    int k = 0, i = 0;
    if (s >= t || seqList.length == 0) {
        return false;
    }
    for (int i = 0; i < seqList.length; i++) {
        if (seqList.data[i] >= s && seqList.data[i] <= t) {
            k++;
        } else {
            seqList.data[i - k] = seqList.data[i];
        }
    }
    seqList.length -= k;
    return true;
}

int main() {
    SeqList seqList;
    seqList.length = 5;
    srand((unsigned) time(NULL));
    for (int i = 0; i < seqList.length; i++) {
        seqList.data[i] = rand() % 10;
        printf("%d ", seqList.data[i]);
    }
    deleteRange(seqList, 2, 5);
    printf("\n");
    for (int i = 0; i < seqList.length; i++) {
        printf("%d ", seqList.data[i]);
    }
    return 0;
}

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

#include <iostream>
#define MAXSIZE 50

typedef struct {
    int data[MAXSIZE];
    int length;
} SeqList;

/**
 * 5.从有序顺序表中删除所有其值重复的元素，使表中所有元素的值均不同。
 * 解析:题目说有序的，所以用两个指针，一个指向当前元素，一个指向下一个元素，如果当前元素和下一个元素相等，则删除下一个元素，否则当前元素向后移动
 * 与第3题类似，用k做标记为从头开始扫，仅把不需要删除的赋值到列表中
 * 其次注意这里要先++,也就是++k因为我们默认第一个元素就是不重复列表的第一个所以遇到下一个要从第二个开始放置，所以是++k
 */
bool deleteRepeat(SeqList &seqList) {
    if (seqList.length == 0) {
        return false;
    }
    int k=0;
    for (int i=1; i < seqList.length; i++) {
        if (seqList.data[k] != seqList.data[i]) {
            seqList.data[++k] = seqList.data[i];
        }
    }
    seqList.length = k + 1;
    return true;
}

int main() {
    SeqList seqList={1, 1, 1, 2, 2, 3, 3, 3, 4, 4};
    seqList.length = 10;
    deleteRepeat(seqList);
    printf("\n");
    for (int i = 0; i < seqList.length; i++) {
        printf("%d ", seqList.data[i]);
    }
    return 0;
}

//默认第一个直接存进去，不重复，后面的有序和前面不重复就加入

bool deleteRepeat(SeqList &seqList) {
    if (seqList.length == 0) {
        return false;
    }
    int k = 0;
    for (int i = 0; i < seqList.length; i++) {
        if (i == 0 || seqList.data[i] != seqList.data[i - 1]) {
            seqList.data[k++] = seqList.data[i];
        }
    }
    seqList.length = k ;
    return true;
}

6. 两个有序顺序表合并为一个新的有序顺序表，并由函数返回结果顺序表。

#include <iostream>
#define MAXSIZE 50

typedef struct {
    int data[MAXSIZE];
    int length;
} SeqList;

/**
 * 6.两个有序顺序表合并为一个新的有序顺序表，并由函数返回结果顺序表。
 * 解析:第3题的升级版本 k还是新队列的标识位，然后比较两个list的大小 谁小的就先放置，然后i++或者j++ k++直到有一个放完剩下
 * 的两个while实际就是把另一个列表的元素放完
 */

bool mergeSeqList(SeqList &seqList1, SeqList &seqList2, SeqList &seqList3) {
    if (seqList1.length + seqList2.length > seqList3.length) {
        return false;
    }
    seqList3.length = seqList1.length + seqList2.length;
    int i = 0, j = 0, k = 0;
    while (i < seqList1.length && j < seqList2.length) {
        if (seqList1.data[i] < seqList2.data[j]) {
            seqList3.data[k++] = seqList1.data[i++];
        } else {
            seqList3.data[k++] = seqList2.data[j++];
        }
    }
    while (i < seqList1.length) {
        seqList3.data[k++] = seqList1.data[i++];
    }
    while (j < seqList2.length) {
        seqList3.data[k++] = seqList2.data[j++];
    }
    seqList3.length=k;
    return true;
}

int main() {
    SeqList seqList = {1, 1, 2, 3, 3, 4, 5, 6, 7, 8};
    SeqList seqList2 = {1, 2,3,5};
    seqList.length = 10;
    seqList2.length = 4;
    SeqList seqList3;
    mergeSeqList(seqList, seqList2, seqList3);
    printf("\n");
    for (int i = 0; i < seqList3.length; i++) {
        printf("%d ", seqList3.data[i]);
    }
    return 0;
}

7. 知在一维数组A[m+n]中依次存放两个线性表(a1,a2,a3,⋯,am)和(b1,b2,b3,⋯,bn,)。编写个函数，将数组中两个顺序表的位置互换，即将(b1,b2,b3,⋯,bn,)放在(a1,a2,a3,⋯,am)的前面。

/**
* 7.知在一维数组A[m+n]中依次存放两个线性表(a?,a?,a?,⋯,am)和(b?,bz,b?,⋯,b,)。编写个函数，将数组中两个顺序表的位置互换，即将(b?,bz,b?,⋯,b,)放在(aj,a?,a?,⋯,am)的前面。
* 解析:假设两个list分别是m和n 要互换位置 最简单的办法是直接换，但是直接换完与原来逆序，所以再局部换两次。
 * @return
 */
#include <iostream>
#define MAXSIZE 50

typedef struct {
    int data[MAXSIZE];
    int length;
} SeqList;
 
bool invert2(SeqList &seqList, int left, int right) {
    if (left > right) {
        return false;
    }
    while (left < right) {
        int temp = seqList.data[left];
        seqList.data[left] = seqList.data[right];
        seqList.data[right] = temp;
        left++;
        right--;
    }
    return true;
}
bool swap(SeqList &seqList, int m, int n) {
    if (m + n > seqList.length) {
        return false;
    }
    invert2(seqList, 0, m + n-1);
    invert2(seqList, 0, n-1);
    invert2(seqList, n, m + n-1);
    seqList.length = m + n;
    return true;
}
int main() {
    SeqList seqList = {1, 2, 3, 4, 5, 6,7};
    seqList.length = 7;
    swap(seqList, 3, 4);
    printf("\n");
    for (int i = 0; i < seqList.length; i++) {
        printf("%d ", seqList.data[i]);
    }
    return 0;
}

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

/**
* 8.线性表(a1,a2,a3,⋯,an,)中的元素递增有序且按顺序存储于计算机内。要求设计一个算法，完成用最少时间在表中查找数值为x的元素，若找到，则将其与后继元素位置相交换，
* 若找不到，则将其插入表中并使表中元素仍递增有序。
* 解析:有序列表时间最少 二分查找 这里利用二分查找会有两种情况
* 第一种是找到了 则目标值与目标值的后继互换(注意：如果目标值是最后一个元素无需互换)
* 第二种没找到 则插入目标值并且目标值之后的后移，这里如果没找到利用low<=high的判断条件的话没找到的时候high【必定在要插入位置的前一个位置】
* @return
*/
#include <iostream>
#define MAXSIZE 50
typedef struct {
    int data[MAXSIZE];
    int length;
} SeqList;
bool searchAndSwap(SeqList &seqList, int x) {
    int low = 0, high = seqList.length - 1, mid;
    while (low <= high) {
        mid = (low + high) / 2;
        if (seqList.data[mid] == x) {
            break;
        } else if (seqList.data[mid] < x) {
            low = mid + 1;
        } else {
            high = mid - 1;
        }
    }
    //找到了x并且不是最后一位要参与交换
    if (seqList.data[mid] == x && mid != seqList.length - 1) {
        int temp = seqList.data[mid];
        seqList.data[mid] = seqList.data[mid + 1];
        seqList.data[mid + 1] = temp;
    }
    //没找到 插入之后的后移
    if (low > high) {
        seqList.length++;
        int i;
        for ( i = seqList.length - 1; i > high; i--) {
            seqList.data[i + 1] = seqList.data[i];
        }
        seqList.data[high + 1] = x;
    }
    return true;
}
int main() {
    SeqList seqList = {1, 3, 3, 4, 4, 6, 7};
    seqList.length = 7;
    searchAndSwap(seqList, 5);
    printf("\n");
    for (int i = 0; i < seqList.length; i++) {
        printf("%d ", seqList.data[i]);
    }
    return 0;
}

9. 给定三个序列 A、B、C,长度均为 n,且均为无重复元素的递增序列，请设计一个时间上尽可能高效的算法，逐行输出同时存在于这三个序列中的所有元素。例如，数组A为{1,2,3],数组B为{2,3,4],数组C为{-1,0,2},则输出2。

#include <iostream>
#define MAXSIZE 50
typedef struct {
    int data[MAXSIZE];
    int length;
} SeqList;
/**
*9.给定三个序列 A、B、C,长度均为 n,且均为无重复元素的递增序列，请设计一个时间上尽可能高效的算法，逐行输出同时存在于这三个序列中的所有元素。例如，数组A为
{1,2,3],数组B为{2,3,4],数组C为{-1,0,2},则输出2。要求：
1)给出算法的基本设计思想。
2)根据设计思想，采用C或 C+语言描述算法，关键之处给出注释。
3)说明你的算法的时间复杂度和空间复杂度。
 * @return
 * 解析:这里看题解用了max函数，第一次没想明白为啥要找最大的，其实对三个列表的元素稍微列举下就知道，如果每个列表第一个元素都不一样，那么能出现重复元素的只能是
 * 三个列表中最大的那个元素重复，因为是递增数列，只能是列表第一个位置的最大值重复所以我们就以最大值作为思路，先求出最大值 看看其他队列是否有与最大值相同的，如果前进一位后没有
 * 最大值，且最大值变化了，则原来的最大值必没有相同项，以此类推
 * 找到为止
 *
 * 时间复杂度为O(n) 空间复杂度为O(1)
 */
int getMaxValue(int a, int b) {
    return a > b ? a : b;
}
bool printCommonElement(SeqList &seqList1, SeqList &seqList2, SeqList &seqList3) {
    int i = 0, j = 0, k = 0;
    while (i < seqList1.length && j < seqList2.length && k < seqList3.length) {
        if (seqList1.data[i] == seqList2.data[j] && seqList2.data[j] == seqList3.data[k]) {
            printf("%d ", seqList1.data[i]);
            i++;
            j++;
            k++;
        } else {
            int max=getMaxValue(seqList1.data[i],getMaxValue(seqList2.data[j],seqList3.data[k]));
            if (seqList1.data[i]<max) i++;
            if (seqList2.data[j]<max) j++;
            if (seqList3.data[k]<max) k++;

        }
    }
}
//要想相等,不能比其他两个小，所以小的位置队列元素向后移动下一位看是否匹配
void findCommon(SeqList seqList1, SeqList seqList2, SeqList seqList3) {
    int i=0, j=0, k = 0;
    while (i < seqList1.length && j < seqList2.length && k < seqList3.length) {
        if (seqList1.data[i] == seqList2.data[j] && seqList2.data[j] == seqList3.data[k]) {
            cout << seqList1.data[i] << " ";
            i++; j++; k++;
        }
        if (seqList1.data[i] < seqList2.data[j] && seqList1.data[i] < seqList3.data[k]) {
            i++;
        }
        if (seqList2.data[j] < seqList1.data[i] && seqList1.data[j] < seqList3.data[k]) {
            j++;
        }
        if (seqList3.data[k] < seqList1.data[i] && seqList3.data[k] < seqList2.data[j]) {
            k++;
        }
    }
}
int main() {
    SeqList seqList = {1, 3, 4};
    SeqList seqList2 = {1, 2, 3};
    SeqList seqList3 = {-1, 2, 3};
    seqList.length = 3;
    seqList2.length = 3;
    seqList3.length = 3;
    printCommonElement(seqList, seqList2, seqList3);
    printf("\n");
    for (int i = 0; i < seqList.length; i++) {
        printf("%d ", seqList.data[i]);
    }
    return 0;
}

10. 设将n(n>1)个整数存放到一维数组R中。设计一个在时间和空间两方面都尽可能高效的算法。将R中保存的序列循环左移p(0<p<n)个位置，即将R中的数据由(X0、X1,⋯,Xn-1)变换为(Xp，Xp+1,⋯,Xn-1,X0,X1,⋯,Xp-1)

189. 轮转数组-LeetCode

#include <iostream>
#define MAXSIZE 50

typedef struct {
    int data[MAXSIZE];
    int length;
} SeqList;
bool invert2(SeqList &seqList, int left, int right) {
    if (left > right) {
        return false;
    }
    while (left < right) {
        int temp = seqList.data[left];
        seqList.data[left] = seqList.data[right];
        seqList.data[right] = temp;
        left++;
        right--;
    }
    return true;
}/**
*10.设将n(n>1)个整数存放到一维数组R中。设计一个在时间和空间两方面都尽可能高效的算法。将R中保存的序列循环左移p(0<p<n)个位置，即将R
中的数据由(X0、X1,⋯,Xn-1)变换为(Xp，Xp+1,⋯,Xn-1,X0,X1,⋯,Xp-1)。要求：
1)给出算法的基本设计思想。
2)根据设计思想，采用C或C+或Java语言描述算法，关键之处给出注释。
3)说明你所设计算法的时间复杂度和空间复杂度。
*解析：对于数列123456
*左移2 得到：3456 12
*左移3 得到：456 123
*左移4 得到：56 1234
*左移5 得到：6 12345
*不难看出规律：先将前半部分反转，再反转后半部分，再反转整个数列即结果
 */
bool leftMove(SeqList &seqList, int p) {
    if (p <= 0 || p >= seqList.length) {
        return false;
    }
    invert2(seqList, 0, p-1);
    invert2(seqList, p, seqList.length-1);
    invert2(seqList, 0, seqList.length-1);
    return true;
}
int main() {
    SeqList seqList = {0, 1, 2,3,4};
    seqList.length = 5;
    leftMove(seqList,4);
    printf("\n");
    for (int i = 0; i < seqList.length; i++) {
        printf("%d ", seqList.data[i]);
    }
    return 0;
}


/**
 * 10 左移所有元素p个单位
 * 这个写法也行，但是时间复杂度太高了O(n2)
 */
  void leftShift(SeqList &list, int p) {
    if (p==list.length){
        return;
    }
    if (p>list.length){
        p=p%list.length;
    }
    for (int i=p;i<list.length;i++){
        int k=i;
        for (int j = i-1; j >=i-p; --j) {
            int temp=list.data[j];
            list.data[j]=list.data[k];
            list.data[k]=temp;
            k--;
        }
    }
}

11. 一个长度为 L(L≥1)的升序序列S,处在第【L/2】个位置的数称为S的中位数。例如，若序列S1=(11,13,15,17,19),则S?的中位数是15,两个序列的中位数是含它们所有元素的升序序列的中位数。例如，若S2=(2,4,6,8,20),则S1和S2的中位数是11。现在有两个等长升序序列 A和 B,试设计一个在时间和空间两方面都尽可能高效的算法，找出两个序列A和B的中位数。

#include <iostream>
#define MAXSIZE 50

typedef struct {
    int data[MAXSIZE];
    int length;
} SeqList;
bool getMedian(SeqList &seqList1, SeqList &seqList2) {
    int sumLength = seqList1.length + seqList2.length;
    int mid = sumLength / 2;
    int k = 0;
    int i = 0, j = 0;
    while (k < mid) {
        if (seqList1.data[i] < seqList2.data[j]) {
            i++;
            k++;
            if (k == mid) {
                printf("%d", seqList1.data[i - 1]);
            }
        } else {
            j++;
            k++;
            if (k == mid) {
                printf("%d", seqList2.data[j - 1]);
            }
        }
    }
    return true;
}
int main() {
    SeqList seqList = {1, 2, 5, 7, 9, 11};
    SeqList seqList2 = {1, 2, 4, 6, 8, 9};
    seqList.length = 6;
    seqList2.length = 6;
    getMedian(seqList2, seqList);
    printf("\n");
    for (int i = 0; i < seqList.length; i++) {
        printf("%d ", seqList.data[i]);
    }
    return 0;
}

12. 简而言之就是如果一个数组中出现的相同元素个数大于 list.length/2 则说明这个数是主元素，原题放图

在这里插入图片描述

/**
 * 12.简而言之就是如果一个数组中出现的相同元素个数 大于 list.length/2 则说明这个数是主元素
 * @return
 * 1,2,5,9,5,9,5,5,5
 * 解析：摩尔投票 不多说
 */
int getMajorityElement(SeqList &seqList) {
    int count = 0;
    int value = seqList.data[0];
    for (int i = 0; i < seqList.length; i++) {
        if (seqList.data[i] == value) {
            count++;
        } else {
            count--;
        }
        if (count == 0) {
            value = seqList.data[i];
            count = 1;
        }
    }
    count = 0;
    for (int i = 0; i < seqList.length; i++) {
        if (seqList.data[i] == value) {
            count++;
        }
    }
    if (count > seqList.length / 2) {
        printf("主元素是:%d", value);
        return value;
    } else {
        return -1;
    }
}

13. 找出数组中的最小正整数

在这里插入图片描述

/**
 * 13.找出数组中的最小正整数    {-5,3,2,3}=1  {1,2,3}=4
 * 解析：建立一个桶来放值，每个桶都去放1-n的正整数值，n个数的列表最小值肯定是1-n的某一位最后遍历桶，如果桶中有0，则说明最小正整数是这个
 * @return
 */
int getMinPositiveInteger(SeqList &seqList) {
    int n = seqList.length;
    SeqList B;
    B.length = n;
    for (int i = 0; i < n; i++) {
        B.data[i] = 0;
    }
    int i;
    for (i = 0; i < seqList.length; i++) {
        if (seqList.data[i] > 0 && seqList.data[i] <= n) {
            B.data[seqList.data[i] - 1] = 1;
        }
    }
    for (int i = 0; i < n; i++) {
        if (B.data[i] == 0) {
            printf("最小正整数是:%d", i + 1);
            return i + 1;
        }
        int getMinPositiveInteger(SeqList &seqList) {
    int n = seqList.length;
    SeqList B;
    B.length = n;
    for (int i = 0; i < n; i++) {
        B.data[i] = 0;
    }
    int i;
    for (i = 0; i < seqList.length; i++) {
        if (seqList.data[i] > 0 && seqList.data[i] <= n) {
            B.data[seqList.data[i] - 1] = 1;
        }
    }
    for (int i = 0; i < n; i++) {
        if (B.data[i] == 0) {
            printf("最小正整数是:%d", i + 1);
            return i + 1;
        }
        if (i==n-1&&B.data[i]==1){
            printf("最小正整数是:%d", i + 2);
            return i+2;
        }
    }
}
    }
}

14. 三元组

在这里插入图片描述

/**
 * 14.三元组
 * @return
 * 暴力一下
 */
int abs(int a) { return a < 0 ? -a : a; }

int GetMinDistance(int a[], int aa, int b[], int bb, int c[], int cc) {
    int min = 10000000;
    for (int i = 0; i < aa; i++) {
        for (int j = 0; j < bb; j++) {
            for (int k = 0; k < cc; k++) {
                int d = 0; //d用于记录距离
                d = abs(a[i] - b[j]) + abs(b[j] - c[k]) + abs(c[k] - a[i]);
                if (min > d) {
                    //如果出现更小的距离，进行替换
                    min = d;
                }
            }
        }
    }
    return min;
}
int main() {
    int a[3]={-1,0,9};
    int b[4]={-25,-10,10,11};
    int c[5]={2,9,17,30,41};
    printf("最小距离为:%d\n",GetMinDistance(a,3,b,4,c,5));
    return 0;
}
22.07.07---线性表的顺序表示
weixin_50836861的博客
07-12 665
结合王道数据结构的课后算法题与b站中的怪鱼算法讲解用以对线性表的顺序表示的学习和理解 感谢
【王道数据结构课后习题代码练习完整版】顺序表
致力于成为一名data scientist 的奋斗者
05-06 2115
设计一个算法，完成用最少时间在表中查找数值为x的元素，若找到，则将其与后继元素位置交换，若找不到，则将其插入表中并使表中元素仍递增有序。,am）和(b1,b2,…2.2.3-3 对长度为n的顺序表L，编写一个时间复杂度为o(n),空间复杂度为o(1)的算法，该算法删除线性表中所有值为x的元素。2.2.3-4 从有序顺序表中删除其值在s与t之间（s
【7.线性表-链式表示-王道课后算法题】
爱喝阔落的猫的博客
11-14 305
【代码】【5.线性表-链式表示-王道课后算法题】
《王道数据结构2024版课后题》2.2线性表的顺序表示-03
m0_64031852的博客
04-21 422
额，专业课开始的有点晚，现在才开始，然后今晚刷完了顺序表的算法题，发现第三题说了一种解法但并没给出具体代码，我这边在codeblock上写出了对应功能的代码（C语言），第一次写这种如果有错误还希望大家指出，轻点喷。如果不对可以跟我说一下，今后我局的比较不错的算法题还会继续额发出来与大家分享！
【C语言数据结构】线性表-顺序存储-动态分配-王道课后练习（顺序表）
weixin_57807777的博客
09-28 182
【代码】【C语言数据结构】线性表-顺序存储-动态分配-王道课后练习。
25版王道数据结构课后习题详细分析 第二章线性表 2.2线性表的顺序表示 选择题部分
2406_86301373的博客
07-17 1012
下述是顺序存储结构的优点通常说顺序表具有随机存取的特性，指的是一个顺序表所占用的存储空间大小与无关在n个元素的线性表的数组表示中，时间复杂度为O(1)的操作是在一个长度为n的顺序表中删除第i (1≤i≤n)个元素时，需向前移动个元素对于顺序表，访问第i个位置的元素和在第i个位置插入一个元素的时间复杂度为顺序表的插入算法中，当n个空间已满时，可再申请增加分配m个空间，若中请失败，则说明系统没有可分配的存储空间。在下列对顺序存储的有序表（长度为n）实现给定操作的算法中，平均时间复杂度为O(1)的是
王道408考研课后习题---线性表(全二十五题)
weixin_61907955的博客
07-02 1128
int data;第一题：递归算法实现删除不带头结点的单链表L中所有值为x的结点LNode * p;p = L;free(p);} else {} }第二题：非递归实现删除所有x的结点 需要设置一个工作结点和前驱结点while(p!free(q);} } }第三题：逆序打印链表if(L!第四题：删除单链表中的最小值结点算法思路 ： 依次扫描比较 然后记录最小值的结点和其前驱结点while(p。
王道数据结构-线性表2.2.4课后习题
m0_65036580的博客
09-02 651
王道数据结构2.2.4课后习题
2024年王道考研数据结构线性表—顺序表题目
qq_51536841的博客
07-13 819
24王道考研复习书的题
线性表的顺序表示及课后习题
西小庄村高伟 的博客
03-23 384
最近已经开始了王道单科书的学习，但是学习进度很慢，嘿嘿，开学已经第三周了才更新出来线性表的顺序存储代码，由于线性表的顺序存储之前的文章已经介绍过，在此便不再继续展开介绍。 以下是王道的数据结构线性表顺序存储实现代码和课后习题代码，仅供大家参考： 线性表的主要操作和课后习题函数列表 //一般线性表的基本操作 int InitList(SqList &L); //初始化线性表 int Empty(SqList &L); //线性表判空 void PrintList(SqList &am
数据结构-王道课后题-线性表（1）
Dr.sen的博客
06-30 1302
顺序表 1. 从顺序表中是删除最小元素，并返回该元素的值空出位置由最后一位填充。 bool Delete_min(sqList &L, ElemType &value){ if(L.length<=0){ //表为空，直接返回 return false ; } value=L.data[0]; int...
王道课后习题2.2.3：顺序表删除值为x的元素
qq_34941153的博客
08-16 1083
题目描述： 长度为n的顺序表L,编写一个时间复杂度为O(n)、空间复杂度为O(1)的算法,该算法删除线性表中所有值为X的数据元素。 算法思想： 解法1.查找到一个元素值等于x的时候就覆盖掉它，从前往后开始移动元素 解法2.一趟循环。重新往线性表里填元素。 如果当前元素不等于x，就往线性表里填入这个元素后i++。 如果当前元素等于x，i就只++。 这个时候就需要有一个变量new_index来记录...
王道数据结构考研课后习题（线性表）
2201_75825034的博客
08-26 323
int* data;int length;}SeqList;int pos;L.length--;return 0;
数据结构-如果将堆结构应用到TOP-K问题上会怎样？
2201_75587951的博客
06-05 947
本文讲解了如何利用堆结构高效解决TOP-K问题（求前K个最大/最小元素）。针对大数据量场景（如100亿数据），传统排序方法内存消耗过大，而堆结构只需维护K个元素的空间。具体实现时：找前K个最大元素建小堆，将剩余元素逐个与堆顶（最小值）比较，更大则替换并调整；反之，找前K个最小元素建大堆。该方法避免了全局排序，时间复杂度优化至O(NlogK)。文中给出c语言代码实现包括建堆、调整和比较替换流程，适用于海量数据场景。
数据结构-C语言-链表OJ
2201_75587951的博客
06-08 583
本篇讲解了链表分割和合并两个有序链表的问题，并涉及到了哨兵结点的运用，后面会继续讲解其他题目
数据结构-相交链表OJ-如何用环形链表来解决相交链表？
最新发布
2201_75587951的博客
06-09 671
今天讲解了能够将时间复杂度为控制在 O(m + n) 、空间复杂度 控制在O(1) 的解决相交链表的两种解法，同时涉及了快慢指针的思想
408第一季 - 数据结构 - 字符串和KMP算法
m0_72791838的博客
06-07 725
第二个a(下标为1)通过next数组到第一个a(下标为0)，发现第一个a(下标为0)的next是-1，于是就把第二个a(下标为1)的next数组更新为-1。我们可以看见第一次c和b不一样时，通过next数组到下标为2的b，准备移动，但我们本来就知道主串那明明是c啊，你移动到字串下标为2的地方。第一个b(下标为2)通过next数组发现是第二个a(下标为1)，但a和b不一样，无法判断接下来的a是不是多余的比较，所以b不变还是1。然后对应的我们找下标为5的next数组，发现是2，对应是下标为2。
数据结构测试模拟题（4）
2401_88780316的博客
06-07 227
简单模拟排队、表达式转换、出入栈、公路村村通、繁忙的都市、局域网、列出叶子结点、最短路径迪杰斯特拉算法
408第一季 - 数据结构 - 线性表
m0_72791838的博客
06-06 532
比如这里的物理结构（存储结构）长这个样子（已分裂！然后逻辑结构就是这样，4后面可以是NULL。
数据结构课后习题及答案王道
01-25
### 数据结构王道教材课后习题及答案 #### 顺序表删除最小值 对于顺序表操作中的删除最小值问题，在《2024王道数据结构》教材P18-P19的第2.2.1题提供了详细的解答方法[^1]。该题目要求实现一个函数来移除顺序表中的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

青北念

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值