数据结构顺序表部分功能和C语言面试题

最新推荐文章于 2024-05-19 20:00:00 发布
最新推荐文章于 2024-05-19 20:00:00 发布
阅读量470 收藏
点赞数
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_64682865/article/details/132093679
版权

实现顺序表部分功能 

//定义顺序表类型

//创建顺序表

//判满

//判空

//顺序表添加元素

//遍历顺序表

//任意位置插入元素

//按值进行查找元素

//将顺序表排序，选择排序

//求最值操作

//顺序表逆置

seqlist.h

#ifndef _SEQLIST_H_
#define _SEQLIST_H_

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

#define MAX 40
typedef int datatype;

//定义顺序表类型
typedef struct
{
	datatype data[MAX];
	int size;
}seqList, *seqList_ptr;

//创建顺序表
seqList_ptr list_create();

//判满
int list_full(seqList_ptr SL);

//判空
int list_empty(seqList_ptr SL);

//顺序表添加元素
int list_add(seqList_ptr SL, datatype element);

//遍历顺序表
int list_traverse(seqList_ptr SL);

//任意位置插入元素
int list_insert(seqList_ptr SL, datatype element, int pos);

//按值进行查找元素
int list_search_value(seqList_ptr SL, datatype element);

//将顺序表排序，选择排序
void list_sort(seqList_ptr SL, int flag);

//求最值操作
datatype list_limit_value(seqList_ptr SL, int flag);

//顺序表逆置
void lis_inverse(seqList_ptr SL);

#endif

seqlist.c

#include"seqlist.h"

//创建顺序表
seqList_ptr list_create()
{
	//在堆区申请一个顺序表的空间大小
	seqList_ptr SL = (seqList_ptr)malloc(sizeof(seqList));
	
	//判断是否申请成功
	assert(SL);

	//创建成功后，清空数组和置零
	memset(SL->data, 0, sizeof(SL->data));
	SL->size = 0;

	printf("顺序表创建成功\n");
	return SL;
}

//判满
int list_full(seqList_ptr SL)
{
	return SL->size == MAX;
}

//判空
int list_empty(seqList_ptr SL)
{
	return SL->size == 0;
}

//顺序表添加函数
int list_add(seqList_ptr SL, datatype element)
{
	if(list_full(SL))
	{
		printf("添加失败\n");
		return 0;
	}

	SL->data[SL->size] = element;
	SL->size++;

	printf("添加成功\n");
	return 1;
}

//遍历顺序表
int list_traverse(seqList_ptr SL)
{
	assert(SL);
	
	if(list_empty(SL))
	{
		printf("添加失败\n");
		return 0;
	}
	
	printf("当前顺序表的元素为：");

	for(int i=0; i<SL->size; i++)
	{
		printf("%d  ", SL->data[i]);
	}

	putchar(10);
}

//任意位置插入元素
int list_insert(seqList_ptr SL, datatype element, int pos)
{
	assert(SL);
	if(list_full(SL) || pos<0 || pos>SL->size)
	{
		printf("插入失败\n");
		return 0;
	}

	//从pos位置全体向后移
	for(int i=SL->size; i>pos; i--)
	{
		SL->data[i] = SL->data[i-1];
	}

	SL->data[pos] = element;
	SL->size++;
	printf("插入成功\n");
	return 1;
}

//按值进行查找元素
int list_search_value(seqList_ptr SL, datatype element)
{
	assert(SL);

	for(int i=0; i<SL->size; i++)
	{
		if(element == SL->data[i])
		{
			printf("该值存在，其位置是数组中的第%d位\n", i);
			return 1;
		}
	}

	printf("该值不存在\n");
	return 0;
}

//将顺序表排序，选择排序
void list_sort(seqList_ptr SL, int flag)
{
	assert(SL);

	//flag==0降序
	if(flag == 0)
	{
		for(int i=0; i<SL->size-1; i++)
		{
			int max = i;
			for(int j=i; j<SL->size; j++)
			{
				if(SL->data[max] < SL->data[j])
				{
					max = j;
				}
			}
			datatype temp = SL->data[i];
			SL->data[i] = SL->data[max];
			SL->data[max] = temp;
		}
	}

	//flag==1升序
	if(flag == 1)
	{
		for(int i=0; i<SL->size-1; i++)
		{
			int min = i;
			for(int j=i; j<SL->size; j++)
			{
				if(SL->data[min] > SL->data[j])
				{
					min = j;
				}
			}
			datatype temp = SL->data[i];
			SL->data[i] = SL->data[min];
			SL->data[min] = temp;
		}
	}
}

//求最值操作
datatype list_limit_value(seqList_ptr SL, int flag)
{
	assert(SL);
	
	//flag==0求最小值
	if(flag == 0)
	{
		datatype max = SL->data[0];
		for(int i=1; i<SL->size; i++)
		{
			if(max < SL->data[i])
			{
				max = SL->data[i];
			}
		}
		return max;
	}

	//flag==1求最大值
	if(flag == 1)
	{
		datatype min = SL->data[0];
		for(int i=1; i<SL->size; i++)
		{
			if(min < SL->data[i])
			{
				min = SL->data[i];
			}
		}
		return min;
	}
}

//顺序表逆置
void lis_inverse(seqList_ptr SL)
{
	assert(SL);

	for(int i=0; i<SL->size-1; i++)
	{
		for(int j=0; j<SL->size-i-1; j++)
		{
			datatype temp = SL->data[j];
			SL->data[j] = SL->data[j+1];
			SL->data[j+1] = temp;
		}

	}
}

main.c

#include"seqlist.h"

int main(int argc, const char *argv[])
{
	seqList_ptr SL = list_create();
	
	//检测申请的指针空间是否合法，为空直接结束程序
	assert(SL);
	
	//调用添加函数
	list_add(SL, 12);
	list_add(SL, 45);
	list_add(SL, 43);
	list_add(SL, 8);
	
	//遍历顺序表
	list_traverse(SL);
	
	//插入元素75
	list_insert(SL, 75, 3);
	//遍历顺序表
	list_traverse(SL);

	//按值进行查找元素
	list_search_value(SL, 12);
	list_search_value(SL, 13);

	//将顺序表排序
	int flag;
	printf("将顺序表排序0降序，1升序：");
	scanf("%d", &flag);
	list_sort(SL, flag);
	//遍历顺序表
	list_traverse(SL);

	//求最值操作
	printf("顺序表求最大值输入1，求最小值输出0：");
	scanf("%d", &flag);
	datatype num = list_limit_value(SL, flag);
	printf("最值为%d\n", num);

	//逆置顺序表
	printf("如果需要逆置顺序表输入1，否则输入0：");
	scanf("%d", &flag);
	if(flag == 1)
	{
		lis_inverse(SL);
		list_traverse(SL);
	}



	return 0;
}

输出结果 

 

 C语言中const的用法

在C语言中，const关键字用于定义常量。常量是在程序执行期间不可修改的值。const关键字可以用于变量、函数参数、函数返回类型等。

  1. 用于变量：

    const int NUM = 5; // 定义一个常量NUM，并初始化为5
int main() {
    const int YEAR = 2022; // 定义一个常量YEAR，并初始化为2022
    int var = 10;
    const int* ptr = &var; // ptr是一个指向常量的指针，指针所指向的值不能通过ptr修改
    *ptr = 20; // 错误，不能修改指针所指向的值
    var = 20; // 可以修改var的值
    return 0;
}

  2. 用于函数参数：

    void printArray(const int arr[], int size) {
    // arr是一个指向常量的指针，不能通过arr修改数组的值
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
}
int main() {
    int arr[] = {1, 2, 3, 4, 5};
    printArray(arr, 5);
    return 0;
}

  3. 用于函数返回类型：

    const int* getMax(const int* arr, int size) {
    // 返回一个指向常量的指针，指针所指向的值不能通过指针修改
    const int* max = arr;
    for (int i = 1; i < size; i++) {
        if (arr[i] > *max) {
            max = &arr[i];
        }
    }
    return max;
}
int main() {
    int arr[] = {1, 2, 3, 4, 5};
    const int* maxPtr = getMax(arr, 5);
    printf("Max value: %d\n", *maxPtr);
    return 0;
}

总结：const关键字用于定义常量，可以用于变量、函数参数、函数返回类型等。它用来指示编译器该值在程序执行期间不可被修改。

 C语言中extern的用法

在C语言中，extern关键字用于声明一个变量或函数，表明该变量或函数是在其他地方定义的。它的主要用途有两个：

  1. 声明全局变量：当在一个源文件中定义全局变量，而在其他源文件中也需要使用该变量时，可以使用extern关键字进行声明。这样，在其他源文件中就可以直接使用该全局变量而不需要重新定义它。

    // File1.c
int globalVariable; // 定义全局变量

// File2.c
extern int globalVariable; // 声明全局变量

    在上面的例子中，File1.c定义了全局变量globalVariable，而File2.c通过extern关键字声明了该全局变量，表示该变量在其他地方定义。这样，File2.c就可以直接使用globalVariable变量了。

  2. 声明外部函数：当在一个源文件中定义了一个函数，而其他源文件需要调用该函数时，可以使用extern关键字进行声明。这样，在其他源文件中就可以直接调用该函数而不需要重新定义它。

    // File1.c
void externalFunction(); // 定义外部函数

// File2.c
extern void externalFunction(); // 声明外部函数

    在上面的例子中，File1.c定义了外部函数externalFunction，而File2.c通过extern关键字声明了该外部函数，表示该函数在其他地方定义。这样，File2.c就可以直接调用externalFunction函数了。

需要注意的是，使用extern关键字声明的变量或函数必须在其他地方定义，否则会导致链接错误。此外，extern关键字只是用于声明，不会分配内存空间，真正的变量或函数定义需要在其他地方进行。

C语言中static的用法

在C语言中，static关键字有多种用法和含义。

  1. 在函数内部使用static关键字：

    • 在函数内部使用static关键字声明的局部变量具有静态存储期，即在函数调用结束后仍然保持其值，而不是被销毁。该变量的作用域仅限于声明它的函数内部。
    • 在函数内部使用static关键字声明的静态局部变量只会被初始化一次，在函数调用时不会重新初始化，每次调用都会保留上一次调用的值。

  2. 在全局作用域使用static关键字：

    • 在全局作用域使用static关键字声明的全局变量具有内部链接，即只能在当前源文件内访问，其他源文件无法访问。
    • 在全局作用域使用static关键字声明的静态全局变量具有静态存储期，即在程序运行期间一直存在，而不是被销毁。

  3. 在函数声明中使用static关键字：

    • 在函数声明中使用static关键字可以将函数的链接属性设置为内部链接，即只能在当前源文件内访问，其他源文件无法调用该函数。

  4. 在函数定义中使用static关键字：

    • 在函数定义中使用static关键字可以将函数的作用域限制在当前源文件内，其他源文件无法调用该函数。

总的来说，static关键字在C语言中的用法主要有两个方面：静态存储期和链接属性控制。

 数据结构的存储结构是什么，分别有哪些

数据结构的存储结构是指数据在计算机内存中的组织方式。常见的数据结构存储结构有以下几种：

  1. 数组（Array）：连续存储结构，数据元素在内存中按照一定的顺序排列。通过下标可以直接访问元素，查找速度快，但插入和删除元素时需要移动其他元素，效率较低。
  2. 链表（Linked List）：离散存储结构，数据元素在内存中通过指针链接起来。插入和删除元素时只需改变指针指向，效率较高，但查找元素时需要遍历链表。
  3. 栈（Stack）：一种特殊的线性表，采用后进先出（LIFO）的存储方式。栈可以用数组或链表实现。
  4. 队列（Queue）：一种特殊的线性表，采用先进先出（FIFO）的存储方式。队列可以用数组或链表实现。
  5. 树（Tree）：非线性数据结构，通过节点和边组成。常见的树结构有二叉树、平衡树、红黑树等。
  6. 图（Graph）：非线性数据结构，由节点和边组成的集合。图可以分为有向图和无向图，常见的图结构有邻接矩阵和邻接表等。
  7. 哈希表（Hash Table）：根据关键字直接访问数据的存储结构。通过哈希函数将关键字映射到哈希表的索引位置，实现快速的查找和插入操作。

除了以上常见的存储结构，还有一些特殊的存储结构，如堆（Heap）、优先队列（Priority Queue）、字典树（Trie）等。不同的存储结构适用于不同的应用场景，选择合适的存储结构可以提高数据操作的效率。

 宏函数与函数的区别

宏函数与函数的主要区别如下：

  1. 执行方式：宏函数是在预处理阶段展开并替换，而函数是在运行时执行。

  2. 参数传递方式：宏函数的参数传递是通过文本替换实现的，没有参数类型检查和强制转换，而函数的参数传递是通过栈或寄存器传递的，有类型检查和强制转换。

  3. 可变参数：宏函数可以接受可变数量的参数，而函数需要使用可变参数函数库（如stdarg.h）来实现可变数量的参数。

  4. 错误检查：函数可以对输入参数进行错误检查和处理，而宏函数没有错误检查机制。

  5. 作用域：宏函数的作用域是全局的，可以在程序的任何地方使用，而函数的作用域可以根据需要进行限制。

  6. 可重用性：函数可以在多个地方调用，提高代码的重用性，而宏函数只能在定义的地方展开，不具备重用性。

  7. 调试：函数可以通过调试工具进行单步调试和查看变量的值，而宏函数在预处理阶段展开，不能进行调试。

综上所述，宏函数和函数在执行方式、参数传递、可变参数、错误检查、作用域、可重用性和调试等方面存在显著的区别。选择使用哪种方式取决于具体的需求和场景。

宏定义与typedef的区别

宏定义和typedef都是C语言中用于定义标识符的关键字，但它们有以下区别：

  1. 宏定义是在预处理阶段进行处理的，而typedef是在编译阶段进行处理的。宏定义是通过简单的文本替换来定义标识符，而typedef是通过给已有类型起别名来定义标识符。

  2. 宏定义可以用于定义常量、函数、数据类型等，而typedef只能用于定义数据类型的别名。

  3. 宏定义可以使用参数，而typedef不能使用参数。

  4. 宏定义没有作用域的限制，可以在任何地方使用，而typedef的作用域受限于它所在的代码块。

  5. 宏定义在预处理阶段就会展开，而typedef在编译阶段才会起作用。

总的来说，宏定义更加灵活，可以用于定义常量、函数等，而typedef则更加专注于定义数据类型的别名。在使用时，根据具体的需求和场景选择合适的关键字。

悲欣交集585
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言链表相关面试题.zip
03-13
C语言链表相关的面试题在软件开发领域的面试中是非常常见的，这是因为链表作为一种基本的数据结构，对于理解数据结构、算法以及内存管理等方面有着重要的作用。以下是一些关于C语言链表的面试题及其详细解释。 1. ...
米哈游部分笔试题目-C语言方向.docx
03-10
哈希表数据结构：哈希表是一种以键值对形式存储数据的数据结构，通过哈希函数将键映射到数组的特定位置，实现快速的插入、删除和查找操作。 红黑树数据结构：红黑树是一种自平衡的二叉查找树，通过维护节点的颜色和...
（C语言）数据结构之栈和队列面试题
博主qq1077644249
08-11 791
下一次想出栈的时候就再倒一次，也就是把q2的前n-1个元素出队并入队到q1，然后q2把剩下的那个元素出队即可，此时q2为空下一次再入栈的时候，也就不用管q1还是q2，就直接谁有元素就往谁的里面入队元素即可。每次入队的时候先要判断当先队列是否是满的，不为满，让back当前位置赋值要入队的元素，然后back正常++往后走，关键的来了再进行back=back %（k+1）操作即可实现循环。为了满足栈的特性，即最后入栈的元素最先出栈，在使用队列实现栈时，应满足队列前端的元素是最后入栈的元素。...
【数据结构】顺序表的增删查改(C语言实现)
qq_67582098的博客
10-05 820
【数据结构】顺序表的增删查改(C语言实现)
顺序表 数据结构 顺序表基本操作 C语言实现 顺序表详解
weixin_63666347的博客
04-23 2598
1.线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列，线性表是一种在实际中广泛使 用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串... 线性表在逻辑上是线性结构，也就说是连续的一条直线，但是在物理结构上并不一定是连续的， 线性表在物理上存储时，通常以数组和链式结构的形式存储 2.顺序表 2.1概念及结构 顺序表就是数组，但是数据必须从第一个位置开始连续存储 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况
数据结构（C语言版-顺序表和链表）
代码笔记本
11-20 1364
1.顺序表和链表 线性表 顺序表 链表 顺序表和链表的区别和联系 1.静态顺序表 #pragma once #define N 1000 typedef double SLDataType //静态顺序表 typedef struct SeqList{ SLDataType a[N]; int size; //表示数组中存储了多少个函数 }SL; ///接口函数 ---命名风格跟着STL void SeqInit(SL* ps); //静态特点：如果满了就不让插入 缺点
（C语言）顺序表和链表
博主qq1077644249
08-09 619
线性表（linear list）是n个具有相同特性的数据元素的有限序列。顺序表、链表、栈、队列、字符串。线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上不一定是连续的， 线性表在物理上存储时，通常以数组和链式结构的形式存储。顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。静态顺序表：使用定长数组存储元素。动态顺序表：使用动态开辟的数组存储。......
【数据结构】顺序表的增删查改 (C语言实现)
在平淡的日子里寻找存在的价值
08-03 3605
用C语言实现的对顺序表的增删查改操作以及相关OJ题练习。
顺序表C语言版
iwkxi的博客
03-18 3380
文章目录1.线性表2.顺序表2.1概念及结构2.2接口实现2.2.1 SeqList.h2.2.2 SeqList.c2.2.2.1 初始化顺序表 1.线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串… 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。 2.顺序表 2.1概念及结构 顺序表是用一
C语言常见面试题汇总
热门推荐
Charles Ren's Tech Blog
01-17 5万+
1、描述⼀下gcc的编译过程？ gcc编译过程分为4个阶段：预处理、编译、汇编、链接。 预处理：头⽂件包含、宏替换、条件编译、删除注释 编译：主要进⾏词法、语法、语义分析等，检查⽆误后将预处理好的⽂件编译成汇编⽂件。 汇编：将汇编⽂件转换成 ⼆进制⽬标⽂件 链接：将项⽬中的各个⼆进制⽂件+所需的库+启动代码链接成可执⾏⽂件 ...
【链表】链表常见笔试题和面试题(C语言)
HongKnight的博客
06-15 1万+
本文为链表常见的笔试题和面试题，包含链表反转、判断链表是否有环、查找环形入口、查找公共结点、合并两个有序链表、查找倒数第K个结点、查找中间结点、删除有序链表重复结点
【数据结构】顺序表
m0_64224788的博客
08-13 1046
线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。通俗的说，顺序表就是数组，但是顺序表要求数组里面的元素必须连续存储。# define DEF_SIZE 4 //初始的容量 # define CRE_SIZE 2 //每次增容的倍数 typedef int SLDataType;...
面试题6--从尾到头打印链表.c
06-29
题目描述： 输入一个链表，从尾到头打印链表每个节点的值。 输入： 每个输入件仅包含一组测试样例。 每一组测试案例包含多行，每行一个大于...对应每个测试案例，以从尾到头的顺序输出链表每个节点的值，每个值占一行。
一些C面试题，希望能对大家有帮助
08-04
c面试题 4. static有什么用途？（请至少说明两种） 1.限制变量的作用域 2.设置变量的存储域 7. 引用与指针有什么区别？ 1) 引用必须被初始化，指针不必。 2) 引用初始化以后不能被改变，指针可以改变所指的对象。...
c++ 面试题 总结
09-16
C++面试题 1.是不是一个父类写了一个virtual 函数，如果子类覆盖它的函数不加virtual ,也能实现多态? virtual修饰符会被隐形继承的。 private 也被集成，只事派生类没有访问权限而已 virtual可加可不加 子类的...
【初阶数据结构】带头双向循环链表讲解
s1mplewo的博客
05-15 1228
本文详细讲解了带头双向循环链表的概念及具体实现源码
【数据结构】习题 |树与二叉树 |森林 |哈夫曼树 |线索二叉树
最新发布
2301_77611317的博客
05-19 686
15道题 涉及树与二叉树、哈夫曼树、线索二叉树、森林等知识点本文主要介绍了15道涉及到树与二叉树、哈夫曼树、线索二叉树、森林等知识点的练习题如果文章的论述或代码等出现错误，欢迎前来指正！
数据结构-栈(带图)
2302_78381559的博客
05-16 772
栈（Stack）是一种基本的数据结构，其特点是只允许在同一端进行插入和删除操作，这一端被称为栈顶。遵循后进先出（Last In, First Out, LIFO）原则，即最后存入栈中的元素最先被取出。形象地讲，栈就像是生活中堆放盘子的架子，我们总是把新的盘子放在最上面，而需要拿盘子时也是从最上面开始拿。
每周一算法：恰好经过K条边的最短路
少儿编程乔老师
05-15 757
给定一张由M条边构成的无向图，求从起点S到终点E恰好经过K条边（可以重复经过）的最短路。可以使用快速幂倍增 + Floyd 求解。
数据结构顺序表删除重复元素 C语言实现
05-21
顺序表是一种线性表，可以用数组来实现。删除顺序表中的重复元素，可以先遍历一遍顺序表，统计出每个元素出现的次数。然后再遍历一遍顺序表，删除出现次数大于...如果要处理这种情况，可以使用哈希表等数据结构来实现。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值