精华内容
下载资源
问答
  • 顺序链表C语言实现

    千次阅读 2019-11-04 18:15:14
    顺序链表没什么说的啦,直接上代码,参考了传智播客出版的数据结构。创建工程的时候不小心弄成c++了,不过没关系,都一样。 Operation中有一处语法上的疑惑,就是插入的那个函数中,node为什么要强制转换成整型,...

    顺序链表没什么说的啦,直接上代码,参考了传智播客出版的数据结构。创建工程的时候不小心弄成c++了,不过没关系,都一样。

    Operation中有一处语法上的疑惑,就是插入的那个函数中,node为什么要强制转换成整型,既然等式两边都是指针,为什么不是转化成int* ,有心人帮忙解答一下,谢谢。

    SeqList.h头文件

    #ifndef _SEQLIST_H_
    #define _SEQLIST_H_
    
    typedef void SeqList;
    typedef void SeqListNode;
    
    /*
    顺序存储线性表操作
    创建-Create()
    初始化-Init()
    获取长度-GetLength()
    判断表是否为空-IsEmpty()
    获取元素-Get()
    插入-Insert()
    删除-Delete()
    清空表-Clear()
    */
    
    SeqList* SeqList_Create(int capacity);
    void SeqList_Destory(SeqList *list);
    void Seqlist_Clear(SeqList * list);
    int SeqList_Length(SeqList * list);
    int SeqList_Capacity(SeqList * list);
    int SeqList_Insert(SeqList * list,SeqListNode * node,int pos);
    SeqList * SeqList_Get(SeqList *list, int pos);
    SeqList * SeqList_Delete(SeqList * list, int pos);
    
    #endif

    Operation.cpp

    /*
    顺序存储线性表操作
    创建-Create()
    初始化-Init()
    获取长度-GetLength()
    判断表是否为空-IsEmpty()
    获取元素-Get()
    插入-Insert()
    删除-Delete()
    清空表-Clear()
    思路:创建一个头节点存储线性表的容量、长度、首地址等信息,顺序线性表的优点是可以随机访问
    缺点是插入删除等操作效率较低。
    */
    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    #include "SeqList.h"
    typedef struct _tag_SeqList//定义一个头结点
    {
    	int capacity;
    	int length;
    	int * node;
    }TSeqList;
    
    //创建顺序表
    SeqList * SeqList_Create(int capacity)//返回值是void类型的指针,可以用任何类型的指针接住,但是需要强制类型转换
    {
    	int ret;
    	TSeqList *temp = NULL;//声明一个指向头结点的指针
    	temp = (TSeqList*)malloc(sizeof(TSeqList));//为头结点分配空间
    	if (temp == NULL)//健壮性保护,每次malloc后都要判断是否malloc成功,养成好习惯
    	{
    		ret = 1;
    		printf("func SeqList_Create() error:%d\n", ret);
    		return NULL;
    	}
    	memset(temp, 0, sizeof(TSeqList));//初始化将temp指向处到TSeqList个字节的内容置为0
    	temp->capacity = capacity;
    	temp->length = 0;
    	temp->node = (int *)malloc(sizeof(void *) * capacity);//指针不管什么类型,实际上大小都是一样的,所以参数表出用void *。
    	if (temp->node == NULL)
    	{
    		ret = 2;
    		printf("func SeqList_Create() error:%d\n", ret);
    		return NULL;
    	}
        return temp;
    }
    
    int SeqList_Capacity(SeqList * list)//传入的参数是万能指针void类型的,可以用任何类型的指针接着,但是需要强制转换,非常灵活
    {
    	TSeqList *temp = NULL;
    	if (list == NULL)//健壮性判断
    	{
    		return -1;
    	}
    	temp = (TSeqList *)list;//因为传入的万能指针,所以要做个强制类型转化
    	return temp->capacity;
    }
    
    int SeqList_Length(SeqList * list)//传入的参数是万能指针void类型的,可以用任何类型的指针接着,但是需要强制转换,非常灵活
    {
    	TSeqList *temp = NULL;
    	if (list == NULL)//健壮性判断
    	{
    		return -1;
    	}
    	temp = (TSeqList *)list;//因为传入的万能指针,所以要做个强制类型转化
    	return temp->length;
    }
    
    int SeqList_Insert(SeqList *list, SeqListNode * node, int pos)
    {
    	int i;
    	TSeqList *temp = NULL;
    	if (list == NULL || node == NULL)
    	{
    		return -1;
    	}
    	temp = (TSeqList*)list;
    	//如果顺序表满
    	if (temp->length >= temp->capacity)
    	{
    		return -2;
    	}
    	if (pos > temp->length)//如果给出的位置超过了顺序表的长度,就填补到顺序表最后一位
    		pos = temp->length;
    	for (i = temp->length; i > pos; i--)//将插入位置的元素一次向后移动
    	{
    		temp->node[i] = temp->node[i - 1];
    	}
    	temp->node[i] = (int)node;//在插入位置插入新元素节点
    	//node是一个指针数组,且都是万能指针,所以node[i]应该是一个万能指针的地址,那传入的node也是万能指针,要对它明确化
    	//但是为什么是int型呢,应该是指向传入类型的指针,但是又不确定传入类型是什么,只好转成int了? 没太搞懂。
    	//printf("%p\n", temp->node[i]);
    	temp->length++;
    	return 0;
    }
    
    SeqList* SeqList_Delete(SeqList* list, int pos)
    {
    	int i = 0;
    	TSeqList * tlist = NULL;
    	SeqListNode * temp = NULL;
    	tlist = (TSeqList*)list;
    	if (list == NULL || pos < 0 || pos >= tlist->capacity)
    	{
    		printf("SeqList_Delete() error\n");
    		return NULL;
    	}
    	temp = (SeqListNode*)tlist->node[pos];
    	for (i = pos + i; i < tlist->length; i++)
    	{
    		tlist->node[i - 1] = tlist->node[i];
    	}
    	tlist->length--;
    	return temp;
    }
    
    SeqList * SeqList_Get(SeqList *list, int pos)
    {
    	TSeqList * tlist = NULL;
    	SeqListNode *temp = NULL;
    	tlist = (TSeqList *)list;
    	if (list == NULL || pos < 0 || pos >= tlist->capacity)
    	{
    		printf("SeqList_Get() error\n");
    		return NULL;
    	}
    
    	temp = (SeqListNode*)tlist->node[pos];
    	return temp;
    }
    
    void SeqList_Clear(SeqList *list)
    {
    	TSeqList * temp = NULL;
    	if (list == NULL)
    	{
    		return;
    	}
    	temp = (TSeqList *)list;
    	temp->length = 0;
    	memset(temp->node, 0, (temp->capacity * sizeof(void *)));
    	return;
    }
    
    void SeqList_Destory(SeqList * list)
    {
    	TSeqList * temp = NULL;
    	if (list == NULL)
    	{
    		return;
    	}
    	temp = (TSeqList *)list;
    	if (temp->node != NULL)
    	{
    		free(temp->node);
    	}
    	free(temp);
    	return;
    }

    main.cpp测试函数

    #include<stdio.h>
    #include<stdlib.h>
    #include "SeqList.h"
    
    typedef struct _Teacher
    {
    	char name[32];
    	int age;
    }Teacher;
    
    int main()
    {
    	int ret = 0;
    	SeqList * list = NULL;
    	Teacher t1, t2, t3, t4, t5;
    	t1.age = 31;
    	t2.age = 32;
    	t3.age = 33;
    	t4.age = 34;
    	t5.age = 35;
    	//创建结点10个
    	list = SeqList_Create(10);
    	//插入结点
    	ret = SeqList_Insert(list, (SeqListNode *)&t1, 0);
    	ret = SeqList_Insert(list, (SeqListNode *)&t2, 0);
    	ret = SeqList_Insert(list, (SeqListNode *)&t3, 0);
    	ret = SeqList_Insert(list, (SeqListNode *)&t4, 0);
    	ret = SeqList_Insert(list, (SeqListNode *)&t5, 0);
    	//printf("Teacher:%p\n", &t5);
    
    	printf("顺序表容量:%d\n", SeqList_Capacity(list));
    	printf("顺序表长度:%d\n", SeqList_Length(list));
    
    	printf("遍历顺序表:\n");
    	for (int i = 0; i < SeqList_Length(list); i++)
    	{
    		Teacher * temp = (Teacher *)SeqList_Get(list, i);
    		if (temp == NULL)
    		{
    			printf("func SeqList_Get() error: %d\n", ret);
    			return 0;
    		}
    		printf("age:%d\n", temp->age);
    	}
    
    	//销毁链表
    	printf("销毁顺序表时:\n");
    	while (SeqList_Length(list) > 0)
    	{
    		Teacher * temp = (Teacher*)SeqList_Delete(list, 0);//删除头部元素
    		if (temp == NULL)
    		{
    			printf("func SeqList_Get() error %d\n", ret);
    			return 0;
    		}
    		printf("age:%d\n", temp->age);
    	}
    	SeqList_Destory(list);
    	system("pause");
    	return 0;
    }

     

    展开全文
  • 顺序表C语言实现

    千次阅读 2018-10-04 20:36:34
    复习数据结构,写了一段顺序表的代码 定义一个头文件header.h 来描述表结构 #define MaxSize 100 //header 头文件 typedef struct { int data[MaxSize]; //最多存放数据MaxSize int length; //元素个数 }...

     

    复习数据结构,写了一段顺序表的代码

    定义一个头文件header.h 来描述表结构

    #define MaxSize 100
    //header 头文件  
    typedef struct 
    {
    	int data[MaxSize];  //最多存放数据MaxSize
    	int length;   //元素个数
    	
    }SeqList;
    
    
    #include "stdio.h"
    #include "header.h"
    //增加操作
    // x 为元素  i 是下标
    void Inset (SeqList *L,int x ,int i){
    	int q ;    //
    	if (L->length == MaxSize) printf("OverFlow \n");
    	if(q <0|| q >L->length-1) printf("Not exist! \n");
     
    	for(q = L ->length -1 ; q>= i ; q--)
    	{
    		L->data[q+1] = L->data[q]  ;
    	}
    	L ->data[i] = x ;
    	L->length++;
    }
    //删除操作
    //i 删除元素的下标
    void del(SeqList *L ,int i){
    	int q ;
    	if (i < 0 || i> L->length-1) printf("Not Exist! \n");
    	for(q =i;q <L->length-1;q++)
    	{
    		L->data[q] = L->data[q+1];
    		L->length --;
    	}
    }
    
    int main(){
    	int i ;
    	int n =5;
    	SeqList s  = {{1,2,3,4,5},n};
    	//Inset(&s , 99 ,2);
    	del(&s,3);
    	for(i=0 ;i<s.length;i++)
    	{
    		printf("%d \n",s.data[i]);
    	}
    }

     

    展开全文
  • 顺序表顺序储存结构C语言实现版 #include <stdio.h> #define MAXSIZE 100 #define OVERFLOW 0 #define OK 1 #define ERROR 0 int main(){ } //顺序表顺序储存结构 ,这里泛型定义为整形 typedef struct{ ...

    数据结构算法实现

    顺序表顺序储存结构C语言实现版

    #include <stdio.h>
    #define MAXSIZE 100
    #define OVERFLOW 0
    #define OK 1
    #define ERROR 0
    int main(){

    }
    //顺序表顺序储存结构 ,这里泛型定义为整形 
    typedef struct{ 
    	int *elem;
    	int lengh;
    }SqList;
    
    
    // 顺序表顺序储存初始化 
    void InitList(SqList &L){
    	L.elem= new int[MAXSIZE];
    	if(!L.elem){
    		return ;
    	}
    	L.lengh=0;
    	
    }
    
    //顺序表顺序储存赋值
    int SetElem(SqList L,int e){
    	if(L.lengh==MAXSIZE){
    		return ERROR;
    	}
    	
    	L.elem[L.lengh]=e;
    	L.lengh++;
    	return OK;
    } 
    
    //线性表顺序储存的取值
    int GetElem(SqList L,int e){
    	return L.elem[e-1];
    } 
    
    //线性表顺序储存的插入
    int  ListInsert(SqList &L,int i,int e){
    	if(i<1||i>(L.lengh+1)){
    		return ERROR;
    	}
    	if(L.lengh==MAXSIZE){
    		return ERROR;
    	}
    	
    	for(int j=i-1;j<L.lengh;j++){
    	L.elem[j+1]=L.elem[j];	
    	}
    	L.elem[i-1]=e;
    	L.lengh++;
    	return OK;
    }
    
    //顺序表的删除 
    int LIstDelete(SqList &L,int i){
    	if(i<1||i>L.lengh){
    		return ERROR;
    	}
    	for(int j=i-1;j<L.lengh-1;j++){
    	L.elem[j]=L.elem[j+1];	
    	}
    	L.lengh--;
    	return OK;
    }
    
    //顺序表的归并 
    int  MergeList(SqList &L1,SqList &L2){
    	if(L1.lengh+L2.lengh>=MAXSIZE){
    		return ERROR;
    	}
    	
    	for(int i=L1.lengh-1,j=0;i<L1.lengh+L2.lengh;i++,j++){
    		L1.elem[i]=L2.elem[j];
    	}
    	L1.lengh=L1.lengh+L2.lengh;
    	return OK;
    }
    
    展开全文
  • 线性表-顺序表C语言实现

    千次阅读 2020-09-28 23:55:02
    将数据依次存储在连续的整块物理空间中,这种存储结构称为顺序存储结构,(简称顺序表); 数据分散的存储在物理空间中,通过一根线保存他们之间的逻辑关系,这种存储结构称为链式存储结构;(简称链表); 前驱和...

    什么是线性表

    线性表,全名为线性存储结构。使用线性表存储结构的方式可以理解,即“把所有的数据都用一根线串起来在存储到物理空间中”。

    数据的“线性”结构
    在这里插入图片描述

    顺序存储结构和链式存储结构

    • 将数据依次存储在连续的整块物理空间中,这种存储结构称为顺序存储结构,(简称顺序表);
    • 数据分散的存储在物理空间中,通过一根线保存他们之间的逻辑关系,这种存储结构称为链式存储结构;(简称链表);

    前驱和后继

    数据结构中,一组数据中的每个个体被称为“数据元素”(简称元素)。

    • 某一元素的左侧相邻的元素称为“直接前驱”,位于此元素左侧所有的元素都称为“前驱元素”
    • 某一元素的右侧相邻的元素称为“直接后继”,位于此元素右侧所有的元素都称为“后继元素”

    在这里插入图片描述

    顺序表(顺序存储结构)及初始化详解

    顺序表存储数据时,会提前申请一整块足够大小的物理空间,然后将数据依次存储起来,存储时做到数据元素之间不留一丝缝隙。

    顺序表的初始化

    顺序表存储数据之前,除了申请足够大的存储空间之外,还要记录一下数据

    1. 顺序表申请的存储容量
    2. 顺序表的长度,也就是表中存储元素的个数
    提示:正常状态下,顺序表申请的存储容量要大于顺序表的长度。
    

    顺序表C语言实现代码:

    // //顺序表自定义
    // typedef struct Table{
    //     int * head;    //声明了一个名为head的长度不确定的数组,也叫动态数组
    //     int length;    //记录当前顺序表的长度 
    //     int size;      //记录顺序表分配的存储容量
    // }table;
    
    // /*顺序表初始化
    // 1、给Head动态数据申请足够大小的物理空间
    // 2、给size、length赋初值
    // */
    // #define Size 5  //对Size进行宏定义,表示顺序表申请大小
    // table initTable()
    // {
    //     table t;
    //     t.head=(int*)malloc(Size*sizeof(int)); //构造一个空顺序表,动态申请存储空间
    //     if(!t.head)     //出国申请失败,提示并退出程序
    //     {
    //         printf("初始化失败!\n");
    //         exit(0);
    //     }
    //     t.length=0;   //空表的长度为0
    //     t.size=Size;  //空表的初始化存储空间大小为Size
    //     return t;
    // }
    
    /*
    通过在主函数中调用 initTable 语句,就可以成功创建一个空的顺序表,
    与此同时我们还可以试着向顺序表中添加一些元素,C 语言实现代码如下:
    */
    
    #include<stdio.h>
    #include<stdlib.h>
    #define Size 5
    
    typedef struct Table{
        int * head;    //声明了一个名为head的长度不确定的数组,也叫动态数组
        int length;    //记录当前顺序表的长度 
        int size;      //记录顺序表分配的存储容量
    }table;
    
    table initTable()
    {
        table t;
        t.head=(int*)malloc(Size*sizeof(int)); //构造一个空顺序表,动态申请存储空间
        if(!t.head)     //出国申请失败,提示并退出程序
        {
            printf("初始化失败!\n");
            exit(0);
        }
        t.length=0;   //空表的长度为0
        t.size=Size;  //空表的初始化存储空间大小为Size
        return t;
    }
    
     void diaplayTable(table t)
    {
         for(int i=0;i<t.length;i++)
         {
             printf("%d ",t.head[i]);
         }
         printf("\n");
    }
    
    table addTable(table t,int elem,int add);//插入函数
    table delTable(table t,int add);         //删除函数
    
    int main()
    {
        table t=initTable();
        for(int i=0;i<t.size;i++)
        {
            t.head[i]=i;
            t.length++;
        }
        printf("顺序表中存储的元素分别是:\n");
        displayTable(t);
        return 0;
    }
    
    //顺序表插入元素
    //插入函数,其中elem为插入元素,add为插入位置
    table addTable(table t,int elem,int add)
    {
        if(add>t.length+1||add<1)
        {
            printf("插入位置有问题\n");
            return t;
        }
    
        //首先检查是不是有多余的存储空间提供插入元素
        if(t.length==t.size)
        {
            t.head=(int *)realloc(t.head,(t.size+1)*sizeof(int));
            if(!t.head)
            {
                printf("分配内存失败\n");
                return t;
            }
            t.size+=1;
        }
        //插入操作
        for(int i=t.length-1;i>=add-1;i--)
        {
            t.head[i+1]=t.head[i];
        }
        t.head[add-1]=elem;
        t.length++;         //长度加1
        return t;
    }
    
    //顺序表删除元素
    
    table delTable(table t,int add) //add表示删除图标的位置
    {
        if(add>t.length||add<1)
        {
            printf("被删除元素的位置有误\n");
            return t;
        }
        //删除操作
        for(int i=add;i<t.length;i++)
        {
            t.head[i-1]=t.head[i];
        }
        t.length--;
        return t;
    }
    
    // 顺序表查找元素
    //查找算法:二分查找法、差值查找法
    //此处使用顺序查找算法
    
    int selectTable(table t,int elem)  //查找函数,elem表示要查找的数据元素的值
    {
        for(int i=0;i<t.length;++i)
        {
            if(t.head[i]==elem)
            {
                return i+1;
            }
        }
        return -1;
    }
    
    //顺序表更改元素
    /*
    1、找到目标元素
    2、直接修改元素值
    */
    table amendTable(table t,int elem,int newElem)
    {
        int add=selectTable(t,elem);
        t.head[add-1]=newElem;
        return t;
    }
    
    
    
    
    
    
    
    
    
    展开全文
  • 包括链表的正序创建和逆序创建,输出,删除插入一个节点,求链表长度,合并。
  • 简单顺序表 C语言实现

    千次阅读 2007-09-12 20:22:00
    顺序表是以数组为存储结构的线性表。由于数组中各元素的地址是可计算的,所以查找定位操作 有很高的执行效率。但是这种顺序存储结构的缺点也相当明显,要获得连续的内存空间就必须一次性申请,而在程序执行之前往往...
  • 主要介绍了C语言实现动态顺序表的实现代码的相关资料,动态顺序表在内存中开辟一块空间,可以随我们数据数量的增多来扩容,需要的朋友可以参考下
  • 【数据结构】顺序表c语言实现

    千次阅读 多人点赞 2019-05-18 15:21:55
    文章目录顺序表c语言实现定义顺序表结构体初始化顺序表操作计算顺序表的长度获取顺序表中元素新元素插入顺序表删除某位置的元素查询某元素的位置打印整个顺序表顺序表的整体源码 线性表的顺序存储是指用一组...
  • 顺序表的纯C语言实现

    2012-06-05 14:32:32
    顺序表的纯C语言实现
  • C语言实现顺序表代码
  • c语言实现顺序表的完整代码,结构体中元素使用指针形式(非数组),main函数中取消注释即可测试相应模块。
  • 主要为大家详细介绍了C语言实现顺序表的实现代码,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • c语言实现顺序表

    2012-11-08 22:23:59
    c语言实现顺序表的多种功能
  • C语言实现顺序表

    万次阅读 多人点赞 2019-03-31 19:10:14
    c语言实现顺序表 线性表是最简单的数据结构,而顺序表又是最简单的线性表,其基本思想是用一段地址连续的储存单元依次存储线性表的数据元素,比如我们常用的一位数组,下面代码实现了顺序表的定义以及基本操作。 ...
  • 主要介绍了c语言实现顺序表的基本操作,需要的朋友可以参考下
  • 换句话说,顺序表中插入元素问题也就等同于讨论如何向数组中插入数据。因此,顺序表中插入数据元素,无非三种情况:在表头插入;...顺序表插入数据操作的 C 语言实现代码为://插入函数,其中,elem...
  • 1)首先创建一个顺序表:从键盘读入一组整数(长度小于等于20),按输入顺序放入顺序表,输入以-1结束(注意-1不放到顺序表内);将创建好的顺序表元素依次输出到屏幕上。 2)在已创建好的顺序表中插入一个元素:...
  • c语言实现顺序表

    2019-08-12 14:18:48
    c语言实现顺序表 线性表的顺序表示指的是用一组地址连续的存储单元依次存储线性表的数据元素 这里使用c语言简单实现一下顺序表 /* c语言实现顺序表 */ #include<stdio.h> #include<stdlib.h> #include&...
  • C语言实现顺序表基本操作

    千次阅读 2019-07-31 15:42:08
    C语言实现顺序表的基本操作
  • 顺序表是线性表中的一种重要的数据结构,也是最基础的数据结构,所以他不仅是学习中的重点,也是应用开发非常常用的一种数据结构。这篇文章介绍如何利用C语言实现顺序表
  • 主要介绍了C语言实现顺序表基本操作汇总,对学习数据结构的朋友有一定的借鉴价值,需要的朋友可以参考下
  • C语言实现顺序表的操作,简单参考一下,相互交流学习。使用 C语言的顺序表的实现比较简单,是以前学习数据结构时专门记录的,有点帮助。
  • 主要介绍了C语言实现静态顺序表的实例详解的相关资料,这里提供是帮助大家学习理解这部分内容,需要的朋友可以参考下
  • 主要介绍了C语言实现顺序表功能,结合完整实例形式分析了C语言顺序表的创建、添加、删除、排序、合并等相关操作技巧,需要的朋友可以参考下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 95,088
精华内容 38,035
关键字:

顺序表c语言实现

c语言 订阅