王道数据结构代码题（C语言） 线性表部分

已于 2023-06-25 16:07:33 修改
阅读量169 收藏 1
点赞数
分类专栏： 王道数据结构代码题（C语言） 文章标签： 数据结构 c语言 算法
于 2023-05-20 13:26:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Cerulea_n/article/details/130778325
版权

线性表

1.在这里插入图片描述

#include <stdio.h>                   //标准输入输出头文件
#include <stdlib.h>                  //standard library标准库头文件 ，包含了C、C++语言的最常用的系统函数。

void delete(int *arr, int len){
    if(!len){
        printf("数组为空");
        return;
    }
    int min = *arr, minpos = 0;
    for(int i = 0; i < len; i++){
        if(min > *(arr + i)){
            min = *(arr + i);
            minpos = i;
        }
    }
    //找到最小值后，将最后一个元素补到删除位置
    *(arr + minpos) = *(arr + len - 1);
    *(arr + len - 1) = NULL;
}

int main()
{
    int n;    //数组元素个数
    printf("输入数组元素个数n= ");
    scanf("%d", &n);
    int *arr = (int*)malloc(sizeof(n));    //动态分配数组     它会向内存申请一块连续可用的空间，空间大小是 size 个字节，并返回指向这块空间的指针
    printf("输入数组元素值: ");
    for(int i = 0; i < n; i++){
        scanf("%d", arr + i);       //地址+1
    }
    for(int i = 0; i < n; i++){
        printf("%d ", arr[i]);
    }
    printf("\n");
    delete(arr, n);

    for(int i = 0; i < n - 1; i++){
        printf("%d ", arr[i]);
        // 等同于 printf("%d ",arr + i);
    }

    return 0;
}

知识点补充

malloc 是我们见得最多的动态内存函数。

它会向内存申请一块连续可用的空间，空间大小是 size 个字节，并返回指向这块空间的指针。

它返回的是个指针，所以在使用它时要用指针接收：

char* ch = malloc(sizeof(char) * size1);
int* arr = malloc(sizeof(int) * size2);
struct S* s = malloc(sizeof(stuctt S) * size3);

但这样并不严谨，因为 malloc 返回类型是空指针，所以在接受它的返回值时最好再对它进行强制类型转换：

char* ch = (char*)malloc(sizeof(char) * size1);
int* arr = (int*)malloc(sizeof(int) * size2);
struct S* s = (struct S*)malloc(sizeof(stuctt S) * size3);

但是，当动态内存开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查：

char* ch = (char*)malloc(sizeof(char) * size);
if(ch == NULL)
{
	perror("fun_name");
	return;
}

2.

在这里插入图片描述

#include <stdio.h>
#include <stdlib.h>

void reverse(int *arr, int len){
    int tmp;
    for (int i = 0; i < len / 2; i++){
        tmp = *(arr + i);
        *(arr + i) = *(arr + len -i - 1);
        *(arr + len - i - 1) = tmp;
    }
}

int main(){
    int n;  //数组元素个数
    printf("输入数组元素个数n= ");
    scanf("%d", &n);
    int *arr = (int*)malloc(sizeof(n));  //动态分配数组
    printf("输入数组元素值: ");
    for(int i = 0; i < n; i++){
        scanf("%d", arr + i);
    }

    for (int i = 0; i < n;i++){
        printf("%d ", *(arr + i));
    }
    printf("\n");
    reverse(arr, n);
    for (int i = 0; i < n;i++){
        printf("%d ", *(arr + i));
    }

    return 0;
}

3.

在这里插入图片描述

#include <stdio.h>
#include <stdlib.h>

int delX(int *arr, int len, int x){
    int k = 0, i = 0;   //k记录删除元素的总数

    while (i < len){
        if(*(arr + i) == x){
            k++;
        }
        else{
            *(arr + i - k) = *(arr + i);
        }
        i++;
    }
    for(int i = len - k; i < len; i++){
        *(arr + i) == NULL;
    }
    return k;
}

int main(){
   int arr[] = {1,2,3,2,2,4};
   int len = sizeof(arr) / sizeof(int), k;       // int型数组，数组的大小除以int型数据的大小，得到数组的长度。
   k = delX(arr, len, 2);
   for(int i = 0; i < len - k; i++){
        printf("%d ", *(arr + i));
   }
   return 0;
}

补充：

sizeof是计算数据（包括数组、变量、类型、结构体等）所占内存空间，用字节数表示。

在32位的系统中，sizeof(int)的值为4。如果x是int型的数组，则sizeof(x)/sizeof(int)代表x的位数。

4.

在这里插入图片描述

#include <stdlib.h>

void deletePoint(int *arr, int s, int t, int len){
    int k = 0, i = 0;
    
    for (i = 0; i < len && *(arr + k) < s; i++);  // 找到第一个大于s的元素
    if (i >= len)  return;

    for (k = i; k <= len && *(arr + k) <= t; k++);  // 找到第一个大于t的元素
    for (; k < len; i++, k++){
        *(arr + i) = *(arr + k);
    }
    
    printf("当前数组为：");
    for (int j = 0; j < i; j++){
        printf("%d ", *(arr + j));
    }

}

int main(){
    int arr[] = {1, 2, 4, 6, 10, 15};
    int s, t;
    int len = sizeof(arr) / sizeof(int);     // 计算数组元素个数
    do{     // 输入区间范围
        printf("s = ");
        scanf("%d", &s);
        printf("t = ");
        scanf("%d", &t);
    }while (s > t);

    deletePoint(arr, s, t, len);
    return 0;
}

5.

在这里插入图片描述

同第三题

6.

在这里插入图片描述

#include <stdio.h>
#include <stdlib.h>

int deleteRepitition(int *arr, int len){   // C语言无法直接修改数组长度，这里返回去重后的数组长度
    int k = 0;
    for (int i = 0; i < len; i++){       // 判断前后元素是否相同
        if(*(arr + i) - *(arr + i + 1)){
            *(arr + k++) = *(arr + i);
        }
    }
    if(*(arr + len - 1) == *(arr + len)){   // 最后一个元素处理（如果最后一个元素和后一个存储空间的元素相同）
        *(arr + k++) = *(arr + len - 1);
    }
    return k;
}

int main(){
   int arr[] = {1,1,2,2,2,3,3,4,5,5};
   int len = sizeof(arr) / sizeof(int);     // 数组元素个数
   len = deleteRepitition(arr,len);
   for(int i = 0; i < len; i++){
        printf("%d ", *(arr + i));
   }
   return 0;
}

7.

在这里插入图片描述

#include <stdio.h>
#include <stdlib.h>

int *mergeList(int *l1, int *l2, int len1, int len2){
    int *newArr = (int *)malloc(len1 + len2);
    int k = 0, i = 0, j = 0;
    for (; i < len1 && j < len2;){
        *(l1 + i) < *(l2 + j) ? *(newArr + k++) = *(l1 + i++) : *(newArr + k++) = *(l2 + j++);
        //条件运算符的优先级比赋值运算符的优先级高,在一些编译器中需要加括号，建议使用下面if语句
//        if (*(l1 + i) < *(l2 + j)){
//           *(newArr + k++) = *(l1 + i++);
//        }
//        else{
//          *(newArr + k++) = *(l2 + j++);
//        }
    }
    while(i < len1){
        *(newArr + k++) = *(l1 + i++);
    }
    while(j < len2){
        *(newArr + k++) = *(l2 + j++);
    }
    return newArr;
}

int main(){
   int l1[] = {1,3,5,7,8};
   int l2[] = {2,4,4,6};
   int len1 = sizeof(l1) / sizeof(int);     // 数组元素个数
   int len2 = sizeof(l2) / sizeof(int);

   int *res;
   res = mergeList(l1, l2, len1, len2);
   for (int i = 0; i < len1 + len2; i++){
        printf("%d ", *(res + i));
   }

   return 0;
}

补充：

条件表达式的优先级顺序：

(e < a[mi]) ? (hi = mi) : (lo = mi +1);
程序完美运行，这也就提示我们要经常加括号。
条件运算符的优先级比赋值运算符的优先级高，所以通常条件运算符的用法如下：

x = y < 0 ? -y : y; //求一个数的绝对值;

附：

①、上面的例子的使用的编译器是codeblocks，报错。但是同样是不加括号，在c-free下是可以运行的，编译器之间还是有少许的区别的。

②、在线编译器有时候还真的挺好用，可以测试程序的正确性啊。虽然缺点是速度慢点，还不能保存。

③、在线编译器：菜鸟教程在线编译器、ideone、dooccn，特别是dooccn，界面炫酷友好，操作还比较方便。

8.

在这里插入图片描述

#include <stdio.h>
#include <stdlib.h>

void reverse(int *arr, int from, int end){
    if (from > end){
        return;
    }
    int tmp;
    for (int i = from; i <= (from + end) / 2; i++){
        tmp = *(arr + i);
        *(arr + i) = *(arr + end - i + from);
        *(arr + end - i + from) = tmp;
    }
}

int main(){
    int arr[] = {1,2,3,4,5,11,22,33,44,55, 66};
    reverse(arr, 0, 10);
    reverse(arr, 0, 5);
    reverse(arr, 6, 10);

    for (int i = 0; i< 11; i++){
        printf("%d ", *(arr + i));
    }
    
    return 0;
}

补充：

这里用到了逆置思想，先整体逆置，再分别逆置，这样复杂度最小

9.

在这里插入图片描述

#include <stdio.h>
#include <stdlib.h>

int findX(int *arr, int len, int x){
    int low = 0, high = len - 1, mid;
    while (low <= high && (mid = (low + high) / 2)){      // 折半查找
        if ( x == *(arr + mid)){
            break;
        }
        if (x < *(arr + mid)){
            high = mid -1;
        }
        else{
            low = mid + 1;
        }
    }
    if (low > high){   // 未找到，插入该元素
        int i;
        for (i = len - 1; i > high; i--){
            *(arr + i + 1) = *(arr + i);
        }
        *(arr + i + 1) = x;
        return len + 1;
    }
    else{   // 找到了，和下一元素对调
        int tmp = *(arr + mid);
        *(arr + mid)  = *(arr + mid + 1);
        *(arr + mid + 1) = tmp;
        return len;
    }

}

int main(){
    int arr[10] = {1,3,4,5,7,22,37,41};   // 为便利，创建十个元素的数组，放入八个元素
    int x, len;
    scanf("%d", &x); // 输入需要查找的数
    len = findX(arr, 8, x);
    
    for (int i = 0; i< len; i++){
        printf("%d ", *(arr + i));
    }
    return 0;
}

补充：

题目要求用时最少，折半查找用时最少

10.

在这里插入图片描述

和第8题相似
#include <stdio.h>
#include <stdlib.h>

void reverse(int *arr, int from, int end){
    if (from > end){
        return;
    }
    int tmp;
    for (int i = from; i <= (from + end) / 2; i++){
        tmp = *(arr + i);
        *(arr + i) = *(arr + end - i + from);
        *(arr + end - i + from) = tmp;
    }
}


int main(){
    int arr[] = {1,2,3,4,5,6,7,8,9,10};
    reverse(arr, 0, 9);
    reverse(arr, 4, 9);
    reverse(arr, 0, 9);

    for (int i = 0; i< 10; i++){
        printf("%d ", *(arr + i));
    }
    return 0;
}

11.

在这里插入图片描述

#include <stdio.h>
#include <stdlib.h>

int findMidNum(int *l1, int *l2, int len){      // 这里题目要求两个数组一样长，那么可以得出中位数必是排序后第一个数组最后一个元素，即第len-1个元素
    int count = 0, midlle;
    for (int i = 0, j = 0; *(l1 + i) && *(l2 + j);){
        if (count++ == len){
            if (*(l1 + i) < *(l2 + j)){
                midlle = *(l1 + i);
            }
            else{
                midlle = *(l2 + j);
            }
            break;
        }
        else{
            if (*(l1 + i) < *(l2 + j)){
                i++;
            }
            else{
                j++;
            }
        }

    }
    return midlle;
}


int main(){
    int l1[] = {1,3,5,7};
    int l2[] = {2,4,6,8};
    int len = sizeof(l1) / sizeof(int);    // 数组长度
    printf("中位数的值为：%d", findMidNum(l1, l2, len -1));
    return 0;
}

12.

在这里插入图片描述

#include <stdio.h>
#include <stdlib.h>

int findMidNum(int *arr, int len){     // "两两抵消"，最后留下最多个数元素，再判断是否是主元素
    int count = 1, c = *arr, mainCount;
    for (int i = 1; i < len; i++){
        if (c == *(arr + i)){
            count++;
        }
        else{
            if(count > 0){
                count--;
            }
            else{
                c = *(arr + i);
                count = 1;
            }
        }
    }
    if (count > 0){
        for (int i = 0; i < len; i++){
            if (*(arr + i) == c){
                mainCount++;
            }
        }
    }
    if (mainCount > len / 2){
        return c;
    }
    else{
        return -1;
    }
}


int main(){
    int arr[] = {0,5,5,3,5,7,5,5};
    int mainNum;
    mainNum = findMidNum(arr, 8);
    printf("%d",mainNum);
    return 0;
}

13.

在这里插入图片描述

#include <stdio.h>
#include <stdlib.h>

int findMin(int *arr, int n){
    int *arrB = (int *)malloc(sizeof(int) * n);

    // arr[i] > 0 ? arrB[arr[i] - 1] = 1 : arrB[i] = 0;
    for (int i = 0;i < n; i++){   // arrB元素置0
        arrB[i] = 0;
    }
    for (int i = 0; i < n; i++){
        if (arr[i] > 0){
            arrB[arr[i] - 1] = 1;
        }
    }

    for (int k = 0;k < n; k++){    //数组中第一个为0的元素下标+1即为最小正整数
        if (arrB[k] == 0){
            return k + 1;
        }
    }
    return n + 1;
}


int main(){
    int arr[] = {1,2,3,4};
    int min = findMin(arr, 4);
    printf("%d",min);
    return 0;
}

14.

在这里插入图片描述

#include <stdio.h>
#include <stdlib.h>

int dis(int a, int b, int c){    //返回距离
    return abs(a - b) + abs(b - c) + abs(a - c);
}

int min(int a, int b, int c){    // 返回当前最小值，移动指针
    if(a < b && a < c)
        return a;
    else if(b < c && b < a)
        return b;
    else
        return c;
}


int findMinofTrip(int *s1,int *s2,int *s3,int len1,int len2,int len3){
    int i = 0, j = 0, k = 0;     // 数组下标，遍历数组
    int Max = 10000;    // 假设一个最大值
    int nowD = 0;
    while(i < len1 && j < len2 && k < len3){
        nowD = dis(s1[i], s2[j], s3[k]);
        if (nowD < Max)
            Max = nowD;
        if (s1[i] == min(s1[i], s2[j], s3[k]))
            i++;
        else if (s2[j] == min(s1[i], s2[j], s3[k]))
            j++;
        else
            k++;
    }
    return Max;
}


int main(){
    int S1[] = {-1,0,9};
    int S2[] = {-25,-10,10,11};
    int S3[] = {2,9,17,30,41};
    int minD = findMinofTrip(S1,S2,S3,3,4,5);
    printf("%d",minD);
    return 0;
}
Jasper.w
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
王道（2009-2012）统考数据结构试题及精心解析1
08-03
1．为解决计算机主机与打印机之间速度不匹配问题，通常设置一个打印数据缓冲区， 2．设栈 S 和队列 Q 的初始状态均为空，元素 a，b，c，d，e，f，g 依
数据结构线性表的C语言代码
06-27
适合学习数据结构的同学
【王道数据结构课后习题代码练习完整版】顺序表
致力于成为一名data scientist 的奋斗者
05-06 1143
设计一个算法，完成用最少时间在表中查找数值为x的元素，若找到，则将其与后继元素位置交换，若找不到，则将其插入表中并使表中元素仍递增有序。,am）和(b1,b2,…2.2.3-3 对长度为n的顺序表L，编写一个时间复杂度为o(n),空间复杂度为o(1)的算法，该算法删除线性表中所有值为x的元素。2.2.3-4 从有序顺序表中删除其值在s与t之间（s
23王道数据结构代码题全解（一）
漫磋嗟
04-09 9277
此次更新线性表（7/14）计划更新23王道数据结构所有课后代码习题的实现，虽然考试写的一般都是伪代码，但是强迫症的我还是全部实现了一遍，都可以编译运行，包含暴力解和最优解，仓库在这里 https://github.com/mancuoj/wangdao
2021版王道《数据结构》编程题汇总
shazi4399的博客
03-27 6910
2021版王道《数据结构》编程题汇总 第二章 线性表P19 1 ​ 1.从顺序表中删除具有最小值的元素（假设唯一）并由函数返回被删元素的值。空出的位置由最后一个元素填补，若顺序表为空则显示出错信息并退出运行。 ​ 算法思想：搜索整个顺序表，查找最小值元素并记住其位置，搜索结束后用最后一个元素填空出的原最小值元素的位置。 ​ 代码： bool Del_Min(sqList &L, El...
王道数据结构编程题（二叉树）
We choose to go to the moon in this decade and do the other things, not because they are easy, but beacase they are hard.
03-07 1915
王道数据结构编程题（二叉树）
数据结构与算法 c语言 线性表-静态链表
最新发布
04-27
数据结构与算法 c语言 线性表-静态链表 静态链表源码
数据结构 c语言 线性表 增删查改保存.txt
07-24
数据结构 c语言 线性表 增删查改保存 InitList(Linklist &L,int &k); PrintList(Linklist &L,int &k); ListInsert(Linklist &L,int &k); ListDelete(Linklist &L,int &k); void ListSave(Linklist &L); void cd();
王道计算机考研数据结构线性表代码
10-03
王道计算机考研数据结构线性表代码 顺序表 单链表 双链表 循环链表 静态链表 带头节点和不带头节点链表的初始化 链表的节点增加、删除节点、销毁链表、双链表正向打印逆向打印！ 静态链表的初始化以及插入操作
王道数据结构+C语言版+超全笔记(图文)+个人整理版本
04-05
(一)数据元素、数据结构、抽象数据类型等概念 (二)算法设计的基本要求 (三)语句的频度和估算时间复杂度 二、线性表 (一)线性表的定义和基本操作 (二)线性表的实现 1.顺序存储结构 2.链式存储结构 3.线性表的应用 三...
ACM编程题模板和各种经典算法数据结构实现代码
03-06
ACM编程题模板，其中包含各种算法，来源王道论坛，希望对搞ACM的同学有帮助
【王道数据结构编程题】- 链表算法题
m0_56051805的博客
06-20 3981
王道代码题具体实现，可以运行，19. 设有一个带头结点的循环单链表，其结点值均为正整数。设计一个算法，反复找出单链表中结点值最小的结点并输出，然后将该结点从中删除，直到单链表空为止，再删除表头结点。20.设头指针为L的带有表头结点的非循环双向链表，其每个结点中除有pred(前驱指针)、data (数据)和next (后继指针)域外，还有一个访问频度域freq。在链表被启用前，其值均初始化为零。每当在链表中进行一-次Locate(L,x)运算时，令元素值为x的结点中freq域的值增1,并使此链表中结点保持按访
2021版王道数据结构课后代码题全部实现
Otto的学习笔记
03-16 8893
历时3个多月，把21版王道数据结构的课后代码题全部实现了一遍，一共96道题 文件目录结构： 编程环境：Visual Studio 2019 编程语言：C/C++ 其中，每道题都是一个独立的cpp文件，可以独立运行。在树和图的章节，会有输入样例和对应的示例图。 cpp文件结构 建立要求的数据结构 题目说明 题目要求的代码 运行示例 以树章节的题目示例： #include <iostream> #include <stack> #include <queue>
【王道数据结构编程题】- 二叉树算法练习
m0_56051805的博客
06-22 2595
王道数据结构代码具体实现，可以执行。1.假设二叉树采用二叉链存储结构存储，设计一个算法，求先序遍历序列中第k(1
2019《王道数据结构》算法题-顺序表
qq_17713905的博客
09-19 1079
#include&lt;iostream&gt; #include&lt;math.h&gt; #include&lt;string.h&gt; #include&lt;map&gt; using namespace std; template &lt;class T&gt; class Vector{ public: Vector(int sz = INITIAL_CAPACITY){ ...
2019《王道数据结构》算法题-单链表C++实现
qq_17713905的博客
09-27 826
#include&lt;iostream&gt; #include&lt;cmath&gt; #include&lt;stack&gt; using namespace std; template&lt;class T&gt; struct Node{ T data; Node&lt;T&gt;* next; Node(Node&lt;T&gt;* ptr = NULL) { nex...
王道数据结构编程题（顺序存储线性表）
We choose to go to the moon in this decade and do the other things, not because they are easy, but beacase they are hard.
03-01 953
王道数据结构编程题（顺序存储线性表）
王道考研数据结构与算法编程题题目解答
vivi_and_qiao的博客
09-14 7239
2018 请注意函数名为此题的大致意思，函数名后的数字为该章节编程题的序号，请注意以序号为准 ——页面长请使用左侧目录 第2章 2.2 #include&amp;amp;amp;amp;amp;lt;stdio.h&amp;amp;amp;amp;amp;gt; #include&amp;amp;amp;amp;amp;lt;stdlib.h&amp;amp;amp;amp;amp;gt; #
王道数据结构课后题编程（顺序表）
任萌新的小生活
05-22 2009
以下问题都简述! 1.搜索顺序表，查找最小值元素，用最后的元素代替它。 思想：初始为第一个元素为最小值，遍历第2-n个元素，寻找最小值，并记录位置，遍历完成后替换。（为空则退出） bool delete_min(SqList &L) { int i; int Min,pos; if(L.length==0) return false; ...
数据结构c语言线性表
10-26
C语言中的线性表是一种常见的数据结构，它是由一组相同数据类型的元素组成的有限序列。线性表中的元素按照线性的顺序排列，每个元素都有一个前驱和一个后继，除了第一个元素没有前驱，最后一个元素没有后继。 在...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值