顺序表应用

最新推荐文章于 2024-11-01 12:24:48 发布

他人恐惧我贪婪

最新推荐文章于 2024-11-01 12:24:48 发布

阅读量187

点赞数

文章标签： c语言数据结构 linux

本文链接：https://blog.csdn.net/m0_72847002/article/details/132093713

版权

7、static在C语言中的用法

Static，顾名思义是静态、静止的意思，个人理解的含义是私有、静态。

私有就是隐藏。

static函数只能声明后的本文中调用
static全局变量只能声明后的本文中调用
static局部变量只能声明后的本函数调用

静态就是一直存在，相对于每次调用动态分配而言。

static函数（未验证是否每次调用代码地址都是一致的）
static全局变量生命周期到程序或进程结束；
static局部变量生命周期到程序或进程结束。

8、`const`在C语言中的用法

1、const只读变量

const修饰的变量是只读的，本质还是变量
const修饰的局部变量在栈上分配空间
const修饰的全局变量在全局数据区分配空间
const只在编译期有用，在运行期无用

1.1 const的本质

C语言中的const使得变量具有只读属性
现代C编译器中的const将具有全局生命周期的变量存储于只读存储区
const不能定义真正意义上的常量

1.2 const修饰函数参数和返回值

const修饰函数参数表示在函数体内不喜欢改变参数的值
const修饰函数返回值表示返回值不可改变，多用于返回指针的情形
C语言中的字符串字面量存储于只读存储区中，在程序中需要使用==const char*==指针

1.3 现代C编译器中的const

const全局变量：只读，值不可改变

const局部变量：

const局部变量：只读，值不可改变
普通局部变量：只读，值可改变

9、结构体中字节对齐原值

C语言中的struct可以看作变量的集合
C语言中的结构体，不能封装函数
一般而言，结构体的大小是各个成员变量所占内存之和
特殊而言，结构体需要进行字节对齐，有利于数据偏移，和寻址功能
字节对齐内容
- 在结构体中的每个属性会根据自己所占内存大小，来设置起始存储位置，起始存储位置，必须是自身类型的整数倍
- 在上面对齐的基础上，最后整体会进行一次对齐，整体的字节个数要是一个数据的整数倍，这个数据是系统字节对齐和结构体中最大成员所占字节的之间取最小值。（系统对齐字节数，结构体中所占内存最大字节数）

10、数据结构的逻辑结构有哪些

逻辑结构：表示数据元素之间的关联情况，根据元素间的关联情况，分为以下四种
1. 集合结构：任意两个数据元素之间没用任何关系，只是单纯存储在同一个同一个集合中
2. 线性结构：数据元素之间存在一对一的关系，在该结构中，除了第一个元素没有前驱，最后一个元素没有后继，其余所有数据都有且只有一个前驱和一个后继
3. 树形结构：数据元素之间存在一对多的关系
4. 图形结构：数据元素之间存在多对多的关系

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

存储结构：数据的逻辑结构在计算机中的映射存储

顺序存储：将逻辑上连续的数据元素，存储在物理内存也连续的空间内
链式存储：将逻辑上相邻的数据元素，存储在物理内存上随机位置
索引存储：在存储数据元素时，单独创建一个索引表记录数据元素所在位置
散列存储：也叫哈希存储，将数据元素存储的位置跟数据元素的关键字有关

12、带参宏与函数的区别

宏表达式被预处理器处理，编译器不知道宏表达式的存在
宏表达式用 “实参” 完全替代形参，不进行任何运算
宏表达式没有任何 “调用” 开销
宏表达式中不能出现递归定义

13、宏定义与typedef的区别

执行时间不一样，预处理只执行简单的替换
宏定义不能连续定义指针类型，typedef可以

顺序表

头文件

#ifndef __TEST_H__
#define __TEST_H__

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


#define MAX 40

typedef int datatype;
typedef struct
{
	datatype data[MAX];
	int index;
} seqlist;

//创建顺序表
seqlist* list_create(); 
 
//判满
int list_full(seqlist* S); 
 
//判空
int list_empty(seqlist* S); 
 
//向顺序表中添加元素
int list_add(seqlist* S, datatype value); 
 
//遍历顺序表
int list_show(seqlist* S); 
 
//任意位置插入元素
int list_insert_pos(seqlist* S,int pos, datatype value); 
 
//任意位置删除元素
int list_delete_pos(seqlist* S,int pos); 

//按位置进行修改
int list_modify_pos(seqlist* S,int pos, datatype value); 

//按值进行修改
int list_modify_value(seqlist* S, datatype value1, datatype value2);

//查找指定位置的元素
int list_find_pos(seqlist* S,int pos);
 
//按值进行查找元素
int list_search_value(seqlist* S, datatype value); 
 
//将顺序表排序,选择排序
int list_sort(seqlist* S, int flag); 
  
//顺序表去重
 
//扩容
 
//求最值操作
int list_mvalue(seqlist* S, int b, int flag); 
 
//顺序表反转
int list_reverse(seqlist* S); 
 
//释放顺序表

#endif

#include "test.h"

函数定义

/*
 函数功能：在堆空间中给顺序表申请一片空间
 函数参数：void
 函数返回值：堆空间首地址
 */
seqlist *list_create()
{	
	seqlist *L = NULL;
	L = (seqlist*)malloc(sizeof(seqlist)*MAX);
	if(NULL == L)//判断空间是否申请成功
	{
		puts("malloc memory file!");
		return NULL;
	}

	memset(L->data, 0, sizeof(L->data));//对申请的空间初始化为0
	L->index = 0;//将顺序表数据长度置0

	puts("seqlist is complete!");

	return L;
}

/*
函数功能：判断顺序表空间是否已满
函数参数：顺序表首地址
函数返回值：传参异常：-1  正常：0  表满：1
 */
int list_full(seqlist* S)
{
	if(NULL == S)
	{
		puts("malloc memory file!");
		return -1;
	}

	return S->index == MAX;
}

/*
函数功能：判断顺序表空间是否为空
函数参数：顺序表首地址
函数返回值：传参异常：-1  正常：0  表空：1
 */
int list_empty(seqlist* S)
{

	if(NULL == S)
	{
		puts("malloc memory file!");
		return -1;
	}

	return S->index == 0;
}

/*
函数功能：顺序表的尾部插入
函数参数：顺序表首地址，需要插入的数据
函数返回值：传参异常：-1  正常：0
 */
int list_add(seqlist* S, datatype value)
{
	if(list_full(S) || NULL == S)
	{
		puts("malloc memory file!");
		return -1;
	}

	S->data[S->index] = value;
	S->index++;
	puts("Add complete!");

	return 0;
}

/*
函数功能：遍历顺序表
函数参数：顺序表首地址
函数返回值：传参异常：-1  正常：0
 */
int list_show(seqlist* S)
{
	if(list_full(S) || NULL == S)
		{
			puts("malloc memory file!");
			return -1;
		}

	int i = 0;
	for(i = 0; i < S->index; i++)
	{
		printf("%d\t", S->data[i]);
	}
	puts("");

	return 0;
}

/*
函数功能：在顺序表指定位置插入数据
函数参数：顺序表首地址，插入位置，插入数据
函数返回值：传参 地址/pos 异常：-1/-2  正常：0
 */
int list_insert_pos(seqlist* S,int pos, datatype value)
{
	if(list_full(S) || NULL == S)
	{
		puts("malloc memory file!");
		return -1;
	}

	if(pos < 0 || pos > MAX)
	{
		puts("pos error!");
		return -2;
	}

	int i = 0;
	for(i = S->index; i >= pos; i--)
	{
		S->data[i] = S->data[i-1];
	}

	S->data[pos-1] = value;
	S->index++;
	printf("Value add to No.%d complete!\n", pos);

	return 0;
}

/*
函数功能：在顺序表指定位置删除数据
函数参数：顺序表首地址，删除的位置
函数返回值：传参 地址/pos 异常：-1/-2  正常：0
 */
int list_delete_pos(seqlist* S,int pos)
{
	
	if(list_full(S) || NULL == S)
	{
		puts("malloc memory file!");
		return -1;
	}

	if(pos < 0 || pos > MAX)
	{
		puts("pos error!");
		return -2;
	}

	int i = 0;
	for(i = pos; i < S->index; i++)
	{
		S->data[i-1] = S->data[i];
	}
	
	S->index--;
	printf("No.%d delete complete!\n", pos);
	return 0;
}

/*
函数功能：在顺序表指定位置修改数据
函数参数：顺序表首地址，修改的位置，修改的数据
函数返回值：传参 地址/pos 异常：-1/-2  正常：0
 */
int list_modify_pos(seqlist* S,int pos, datatype value)
{
	if(list_full(S) || NULL == S)
	{
		puts("malloc memory file!");
		return -1;
	}

	if(pos < 0 || pos > MAX)
	{
		puts("pos error!");
		return -2;
	}

	S->data[pos-1] = value;
	printf("No.%d modify complete!\n", pos);

	return 0;
}

/*
函数功能：在顺序表中修改指定数据
函数参数：顺序表首地址，要修改的数据，要传入的数据
函数返回值：传参异常：-1  正常：0
 */
int list_modify_value(seqlist* S, datatype value1, datatype value2) 
{
	if(list_full(S) || NULL == S)
	{
		puts("malloc memory file!");
		return -1;
	}

	int i = 0;
	int flag = 1;
	for(i = 0; i < S->index; i++)
	{
		if(S->data[i] == value1)
		{
			S->data[i] = value2;
			flag = 0;
		}
	}
	if(flag == 1)
	{
		puts("Don't find value");
	}
	return 0;
}

/*
函数功能：在顺序表中查找指定位置数据
函数参数：顺序表首地址，查找的位置
函数返回值：传参 地址/pos 异常：-1/-2  正常：0
 */
int list_find_pos(seqlist* S, int pos)
{
	if(list_full(S) || NULL == S)
	{
		puts("malloc memory file!");
		return -1;
	}

	if(pos < 0 || pos > MAX)
	{
		puts("pos error!");
		return -2;
	}

	printf("pos value is %d\n", S->data[pos-1]);
	return 0;
}

/*
函数功能：在顺序表中查找指定数据
函数参数：顺序表首地址，查找的数据
函数返回值：传参异常：-1  正常：0
 */
int list_search_value(seqlist* S, datatype value) 
{
	if(list_full(S) || NULL == S)
	{
		puts("malloc memory file!");
		return -1;
	}

	int i = 0;
	int flag = 1;
	for(i = 0; i < S->index; i++)
	{
		if(S->data[i] == value)
		{
			printf("No.%d is value\n", i+1);
			flag = 0;
		}
	}
	if(1 == flag)
	{
		puts("Don't find value");
	}
	return 0;
}

/*
函数功能：查找顺序表中的最大最小值
函数参数：顺序表首地址，模式标志（1为最大值，0为最小值）
函数返回值：传参异常：-1   正常：返回最大或最小值的下标
 */
int list_mvalue(seqlist* S, int b, int flag)
{
	if(list_full(S) || NULL == S)
	{
		puts("malloc memory file!");
		return -1;
	}

	int i = 0;

	if(1 == flag)//查找最大值
	{
		int max = b;
		for(i = b; i < S->index; i++)
		{
			if(S->data[max] < S->data[i])
			{
				max = i;
			}
		}
		return max;
	}

	if(0 == flag)//查找最小值
	{
		int min = b;
		for(i = b; i < S->index; i++)
		{
			if(S->data[min] > S->data[i])
			{
				min = i;
			}
		}

		return min;
	}
}

/*
函数功能：顺序表排序
函数参数：顺序表首地址，模式标志（1为升序，0为降序）
函数返回值：传参异常：-1   正常：0
*/
int list_sort(seqlist* S, int flag)
{
	if(list_full(S) || NULL == S)
	{
		puts("malloc memory file!");
		return -1;
	}

	int i = 0;
	int max = 0;
	int min = 0;
	datatype temp;

	if(1 == flag)//升序
	{
		for(i = 0; i < S->index; i++)
		{
			min = list_mvalue(S,i,0);
			if( i != min)
			{
				temp = S->data[i];
				S->data[i] = S->data[min];
				S->data[min] = temp;
			}
		}
	}
	if(0 == flag)//降序
	{
		for(i = 0; i < S->index; i++)
		{
			max = list_mvalue(S,i,1);
			if( i != max)
			{
				temp = S->data[i];
				S->data[i] = S->data[max];
				S->data[max] = temp;
			}
		}
	}

	return 0;
}


int list_reverse(seqlist* S)
{
	if(list_full(S) || NULL == S)
	{
		puts("malloc memory file!");
		return -1;
	}

	datatype *frist = S->data;
	datatype *last = S->data + S->index - 1;
	datatype temp;
	while(frist < last)
	{
		temp = *frist;
		*frist = *last;
		*last = temp;
		frist++;
		last--;
	}
	
	return 0;
}