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

    2013-12-10 12:36:21
    基于C语言编写的顺序表,层次分明、结构清楚、能成功运行
  • 主要介绍了C语言顺序表实现方法,大家参考使用吧
  • C语言顺序表的插入删除

    万次阅读 多人点赞 2018-09-13 22:08:41
    首先声明一个顺序表的结构 (数组的第一个元素是0,但是顺序表的第一个一般 从1(人为设定)开始) #include <stdio.h> #include <stdlib.h> #define MAXSIZE 10 #define OK 1 #define ...

    首先声明一个顺序表的结构 (数组的第一个元素是0,但是顺序表的第一个一般 从1(人为设定)开始)

    #include <stdio.h>
    #include <stdlib.h>
    
    #define MAXSIZE 10
    #define OK	  1
    #define FALSE 0 
    
    typedef int Elemtype;
    typedef bool Status;
    
    typedef struct list
    {
    	Elemtype *elem;
    	int len;        //数据个数
    	int listsize;   //顺序表长度
    }List;
    

    listsize 代表这个顺序表的最大容量,可以随时扩容

    len 代表在你创建的这个顺序表中有几个有效的数据,总是小于等于listsize

    一、初始化顺序表属性

    void list_init(List *L)
    {
    	L->elem=(Elemtype *)malloc(MAXSIZE*sizeof(Elemtype));//开辟空间
    	if(L->elem==NULL)//判断空间是否开辟成功
    	{
    		printf("malloc fail\n");
    		exit(0);
    	}
    
    	L->len=0;	//初始化数据有效数据为0
    	L->listsize=MAXSIZE;	//初始化数组长度为MAXSIZE
    }

    二、顺序表的插入

    Status list_insert(List *L,int i,Elemtype data)
    {
    	Elemtype *base,*insert,*p;
    	if(i<1 || i>L->len+1 || L==NULL)
    	{
    		printf("位置输入错误\n");
    		return FALSE;
    	}
    	if(L->len > L->listsize)
    	{
    		base=(Elemtype *)realloc(L->elem,(L->listsize+MAXSIZE)*sizeof(Elemtype));//动态扩容
    		L->elem=base;
    		L->listsize+=MAXSIZE;//更新顺序表大小
    	}
    	insert=&(L->elem[i-1]);//目标指针指向要插入的目标地址
    	  //指向最后一个元素的地址
    	for(p=L->elem + L->len-1;p>=insert;p--)
    	{
    		*(p+1)=*p;
    	}
    	*insert=data;
    	L->len++;
    	return OK;
    }

    三、删除 

    Status delete_list(List *L,int i)
    {
    	ElemType *q,*delete_i;
    	if(L==NULL||i<0||i>L->len)
    	return FALSE;
    	delete_i=&(L->elem[i-1]);//用指针指向要删除位置的地址
    	q=L->elem + L->len-1;    //q指针指向顺序表最后一个位置的地址   首地址加上数组长度就是最后一个元素地址
    	for(delete_i=delete_i+1;delete_i<=q;++delete_i)//从删除位置的地址的下一个元素开始,每个往前移动一位
    	{
    		*(delete_i-1)=*delete_i;		//前一个位置等于后一个
    	}
    	L->len--;
    	
    	return OK;
    }

     

     全部程序

    #include <stdio.h>
    #include <stdlib.h>
    
    #define MAXSIZE 10
    #define OK	  1
    #define FALSE 0 
    
    typedef int Elemtype;
    typedef bool Status;
    
    typedef struct list
    {
    	Elemtype *elem;
    	int len;
    	int listsize;
    }List;
    
    
    void list_init(List *L)
    {
    	L->elem=(Elemtype *)malloc(MAXSIZE*sizeof(Elemtype));//开辟空间
    	if(L->elem==NULL)//判断空间是否开辟成功
    	{
    		printf("malloc fail\n");
    		exit(0);
    	}
    
    	L->len=0;	//初始化数据有效数据为0
    	L->listsize=MAXSIZE;	//初始化数组长度为MAXSIZE
    }
    
    Status list_insert(List *L,int i,Elemtype data)
    {
    	Elemtype *base,*insert,*p;
    	if(i<1 || i>L->len+1 || L==NULL)
    	{
    		printf("位置输入错误\n");
    		return FALSE;
    	}
    	if(L->len > L->listsize)
    	{
    		base=(Elemtype *)realloc(L->elem,(L->listsize+MAXSIZE)*sizeof(Elemtype));
    		L->elem=base;
    		L->listsize+=MAXSIZE;
    	}
    	insert=&(L->elem[i-1]);//目标指针指向要插入的目标地址
    	  //指向最后一个元素的地址
    	for(p=L->elem + L->len-1;p>=insert;p--)
    	{
    		*(p+1)=*p;
    	}
    	*insert=data;
    	L->len++;
    	return OK;
    }
    
    Status list_delete(List *L,int i)
    {
    	Elemtype *aim,*p;
    	if(i<0 || i>L->len)
    	{
    		printf("位置输入错误\n");
    		return FALSE;
    	}
    	aim=&(L->elem[i-1]);//目标指针指向要删除的目标地址
    	p=(L->elem+L->len-1); //指向最后一个元素的地址
    	for(aim=aim+1;aim<=p;++aim) //目标地址滑动删除
    	{
    		*(aim-1)=*aim;
    	}
    	L->len--;
    	return OK;
    }
    void show_list(List *L)
    {
    	int i;
    	for(i=0;i<L->len;i++)
    	{
    		printf("elem[%d]=%d\n",i+1,L->elem[i]);
    	}
    	printf("\n");
    }
    int main()
    {
    	int i;
    	List L;
    	list_init(&L);
    	for(i=0;i<10;i++)
    	{
    		list_insert(&L,i+1,i+1);
    	}
    	printf("插入前的顺序表\n");
    	show_list(&L);
    
    	printf("插入后的顺序表  在5位置插入99\n");
    	list_insert(&L,5,99);
    	show_list(&L);
    
    	printf("删除后的顺序表  把5位置删除\n");
    	list_delete(&L,5);
    	show_list(&L);
    	return 0;
    }
    
    

     

    展开全文
  • 数据结构c语言 顺序表操作 源代码 运行正常
  • C语言顺序表实例

    2012-11-28 18:36:44
    自己写的顺序表的定义,创建,插入、删除等常用操作,有详细注释,结构清晰,适合初学者。
  • c语言 顺序表的基本操作(创建、初始化、赋值、插入、删除、查询、替换、输出) 1、创建、申请空间 2、初始化、顺序表数据结构大小、长度 3、赋值、顺序表数据结构赋值 4、插入、在指定位置插入数据,后续数据...

    c语言 顺序表的基本操作(创建、初始化、赋值、插入、删除、查询、替换、输出)

    1、创建、申请空间

    2、初始化、顺序表数据结构大小、长度

    3、赋值、顺序表数据结构赋值

    4、插入、在指定位置插入数据,后续数据循环后移,长度增加,空间大小增加或者不变

    5、删除、删除指定位置的数据,后续数据循环前移,长度减小、空间大小不变

    6、查询、查看指定数据是否在顺序表结构中

    7、替换、将顺序表结构中指定数值替换为另外的数值

    8、输出、输出顺序表结构中存储的数据(根据长度大小输出)

    代码如下:

    #include <stdio.h>
    #include <stdlib.h>
    #include <Windows.h>
    #define Size 5
    //显示日期、时间、文件信息
    void xinxi()
    {
    
    	printf("Date : %s\n", __DATE__);
    	printf("Time : %s\n", __TIME__);
    	printf("File : %s\n", __FILE__);
    	printf("Line : %d\n", __LINE__);
    	printf("\n***以下是程序部分***\n\n");
    	
    }
    //定义顺序表结构
    typedef struct Table
    {
    	int *head;//类似于数组指针
    	int length;//数据长度
    	int size;//机构大小
    }table;
    //初始化顺序表结构
    table initcreact()
    {
    	table t;
    	if ((t.head = (int *)malloc(Size*sizeof(int))) == NULL)
    	{
    		printf("申请存储空间失败!");
    			exit(1);
    	}
    	t.length = 0;//初始化长度为 0
    	t.size = Size;//结构大小
    	return t;
    }
    //结构赋值
    table fuzhi(table t)
    {
    	int i;
    	for (i = 0; i < t.size; i++)
    	{
    		t.head[i] = i + 1;
    		t.length++;//长度随赋值情况增加
    	}
    	return t;
    }
    //输出结构存储情况
    table prt(table t)
    {
    	printf("存储的数据如下:\n");
    	for (int i = 0; i < t.length; i++)
    		printf("%d ", t.head[i]);
    	printf("\n");
    	return t;
    }
    //插入数据
    table insert(table t,int elme,int add)
    {
    	if (t.length == t.size)//如果数据结构已满,增加存储空间
    		t.head= (int *)realloc(t.head, (t.size + 1) * sizeof(int));
    	if (t.head == NULL)
    	{
    		printf("申请存储空间失败!\n");
    		exit(1);
    	}
    	else t.size++;//空间大小增加
    	int i = t.size;
    	for (; i >= elme-1; i--)//数据循环后移
    		t.head[i] = t.head[i - 1];
    	t.head[elme-1] = add;//指定位置插入数据,赋值
    	t.length++;//长度增加
    	return t;
    }
    //删除指定数据
    table deleter(table t, int elme)
    {
    	int i = elme-1;
    	for (; i <= t.size; i++)
    		t.head[i] = t.head[i +1];
    	t.head[i] = 0;
    	t.length--;
    	return t;
    }
    //查询指定数据,返回在数据结构中的位置
    int select(table t, int elme)
    {
    	int i;
    	for (i = 0; i <= t.length; i++)
    	{
    		if (t.head[i] == elme)
    			return i+1;
    	}
    	return -1;
    }
    //替换指定数据
    table tihuan(table t, int elme, int add)
    {
    	int i=select(t,elme);
    	
    		t.head[i-1] = add;
    		return t;
    	
    }
    //主函数
    int main()
    {
    	xinxi();
    	table t = initcreact();
    	t = fuzhi(t);
    	t = prt(t);
    	int elme;
    	printf("请输入插入的位置:");
    	scanf("%d", &elme);
    	int add;
    	printf("请输入插入数据:");
    	scanf("%d", &add);
    	if (elme > t.size+1 || elme < 0)
    	{
    		printf("输入的位置错误\n");
    		exit(0);
    	}
    	t = insert(t, elme,add);
    	t = prt(t);
    	printf("请输入删除的位置:");
    	scanf("%d", &elme);
    	if (elme > t.size || elme < 0)
    	{
    		printf("输入的位置错误\n");
    		exit(0);
    	}
    	t = deleter(t, elme);
    	t = prt(t);
    	printf("查找 5 的位置\n");
    	elme = select(t, 5);
    	printf("5 的位置是 %d\n", elme);
    
    	t = prt(t);
    	printf("用 55 替换 5\n");
    	tihuan(t, 5, 55);
    	t = prt(t);
    
    	system("pause");
    	return 0;
    }

     

     

    展开全文
  • 1顺序表: 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构,一般情况下采用数组存储。在数组 上完成数据的增删查改。 顺序表一般可以分为: 静态顺序表:使用定长数组存储。 动态顺序表:使用...

    1顺序表:

    顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构,一般情况下采用数组存储。在数组
    上完成数据的增删查改。

    顺序表一般可以分为:

    1. 静态顺序表:使用定长数组存储。
    2. 动态顺序表:使用动态开辟的数组存储

    顺序表中的问题:

    • 1. 中间/头部的插入删除,时间复杂度为O(N)
    • 2. 增容需要申请新空间,拷贝数据,释放旧空间。会有不小的消耗。
    • 3. 增容一般是呈2倍的增长,势必会有一定的空间浪费。例如当前容量为100,满了以后增容到200,
    • 我们再继续插入了5个数据,后面没有数据插入了,那么就浪费了95个数据空间
       

    2链表:

    链表是一种物理存储结构上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链
    接次序实现的。

    • 无头单向非循环链表:结构简单,一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构,如哈希桶、图的邻接表等等。
    • 带头双向循环链表:结构最复杂,一般用在单独存储数据。实际中使用的链表数据结构,都是带头双向循环链表。

    3顺序表和链表的区别和联系

    顺序表:

    优点:空间连续、支持随机访问

    缺点:

    1.中间或前面部分的插入删除时间复杂度O(N)

    2.增容的代价比较大。

    链表:

    缺点:以节点为单位存储,不支持随机访问
    优点:1.任意位置插入删除时间复杂度为O(1) 2.没有增容问题,插入一个开辟一个空间。


     

    展开全文
  • C语言顺序表结构体数据插入代码 #include <stdio.h> #include <stdlib.h> #include <malloc.h> #define MAX 10 typedef struct { int num; char name[10]; char sex[10]; int cj; }student; ...

    C语言顺序表结构体数据插入代码

    #include <stdio.h>
    #include <stdlib.h>
    #include <malloc.h>
    #define MAX 10
    typedef struct {
    	int num;
    	char name[10];
    	char sex[10];
    	int  cj;
    }student;
    
    typedef struct  {
    	student data[MAX];
    	int length;
    }SeqList,*PSeqList;
    
    PSeqList init_SeqList(void)
    {
    	PSeqList PL;
    	PL=(PSeqList)malloc(sizeof(SeqList));
    	if(PL)
    		PL->length=0;
    	return PL;
    }
    
    void ListInsert(PSeqList PL)
    {  
    	int j,i;
    	student s;
    	printf("==============输入要插入的学生信息=================\n");
    
    	printf("*****学号:");  scanf("%d",&s.num);
        printf("*****姓名:");  scanf("%s",&s.name);
        
        printf("*****成绩:");  scanf("%d",&s.cj);
        printf("*****性别:");     scanf("%s",&s.sex);
    	printf("===================输入完成==============================\n\n");
    	printf("请输入要插入的位置:");
    	scanf("%d",&i);
    	if (i<1||i>PL->length+1)
    	{
    		printf("插入位置不合法\n");
    	}
    	for(j=PL->length;j>=i;j--)
    	{
    		PL->data[j+1]=PL->data[j];
    	}
    	PL->data[i-1]=s;
    	PL->length++;
    }
    
    void print_SeqList(PSeqList PL)
    {  
    	int i=0;
    	printf("=========================学生信息表=========================\n");
    	for (i=0;i<PL->length;i++)
    	{
    		printf("学号:%d\n",PL->data[i].num);
    	printf("姓名:%s\n",PL->data[i].name);
    	printf("性别:%s\n",PL->data[i].sex);
    	printf("成绩:%d\n",PL->data[i].cj);
    	
    	}
    	printf("\n");
    }
    void main()
    {  int i;
    	PSeqList PL;
      PL=init_SeqList();
      for (i=0;i<5;i++)
      {ListInsert(PL);
      }
    
    	print_SeqList(PL);
    }
    

    这里成绩改为double类型不知道为啥报错。## 标题

    展开全文
  • C语言顺序表操作

    千次阅读 2019-01-01 15:34:34
    //定义顺序表的长度 }; int main(){ char c; int i; struct link L; int arr[MAX_SIZE]; //创建一个长度为10的int数组 L.data = arr; //让指针指向这片空间 L.length = 0; //初始化顺序表的长度为...
  • c语言顺序表的基本操作

    千次阅读 多人点赞 2018-06-30 15:18:36
    下面是顺序表的基本操作,c语言版的数据结构书上写的操作都实现了因为总体代码太长如果写在一个class中要近500行,阅读和修改都不方便,所以采用分开写,希望大家以后写较长的程序时也采用这种方法,自己运行的所有...
  • C语言顺序表简单实现

    2011-10-25 21:38:48
    建立顺序表; 求顺序表长度; 求顺序表中第i个位置的数据元素的数值; 求数据元素e在顺序表中的位置; 在第i个位置上插入一个数据元素; ...
  • C语言顺序表的简单实现

    千次阅读 2016-10-24 23:24:48
    今天刚学了数据结构,老师教的我是云里雾里的,晚上回来自己又教程视频,不管怎么说算是简单的实现了顺序表的一些简单功能。  顺序表里的难点有向顺序表里插入元素,删除元素,查询元素位置这几个函数比较难写,我...
  • C语言 顺序表的创建

    2010-12-16 13:20:06
    这是我买的一本课程设计案例书上的源代码,上面的案例很经典,特别适合于作 毕业设计的学生使用,当然了,也可以做为做课程设计的学生以参考,希望能给 大家提供帮助!!
  • C语言顺序表的初始化

    2021-02-24 18:26:58
    没学过C语言,将就着看着吧! #include<stdio.h> #include<math.h> // #define 定义一个标识符来表示一个常量 #define OK 1 #define ERROR -1 #define MAX_SIZE 100 // typedef 关键字来定义自己习惯的...
  • C语言 顺序表和链表的区别与总结

    千次阅读 2019-12-13 15:12:47
    顺序表和链表的区别和联系 顺序表 特点:空间连续、支持随机访问 缺点 1. 中间/头部的插入删除,时间复杂度为O(N) 2. 增容需要申请新空间,拷贝数据,释放旧空间。会有不小的消耗。 3. 增容一般是呈2倍的增长,势必...
  • #include<stdio.h> #include<math.h> // #define 定义一个标识符来表示一个常量 #define OK 1 #define ERROR -1 #define MAX_SIZE 100 // typedef 关键字来定义自己习惯的数据类型名称 ...
  • #include<stdio.h> #include<math.h> // #define 定义一个标识符来表示一个常量 #define OK 1 #define ERROR -1 #define MAX_SIZE 100 // typedef 关键字来定义自己习惯的数据类型名称 ...
  • 最近复习到C语言顺序表,把它实现一遍。 给出顺序表的定义#define MAX_SIZE 100 typedef int DataType; typedef struct SeqList { DataType array[MAX_SIZE]; int size; // 记录有效元素的个数 }SeqList, *...
  • #define MaxSize 10 //定义最大容量 typedef struct //类型重命名 { int data[MaxSize]; //存放数据 int length; //当前长度 } Sqlist; //结构体名:Sqlist 初始化 void InitList(Sqlist *L) //初始化 { ...
  • C语言的基础,数据结构的基础,清晰实现算法结构
  • 2017C语言顺序表(动态版本)

    千次阅读 2017-09-18 18:45:52
    题目:用C语言实现数据链 要求: 1.有基本增添,删除功能。 2.动态内存开辟版本。 程序源码: 头文件 #ifndef __ADD_H__ #define __ADD_H__ #define _CRT_SECURE_NO_WARNINGS 1 #include&lt;...
  • C语言顺序表的基本操作

    千次阅读 2016-10-23 21:55:12
    #include #include #include //调用exit();函数 #define N 10 typedef struct List { int a[N]; int last;//相当于就是伪指针。用来表示有效数组的下标 ...//创建顺序表。 void traverse_list
  • c语言 顺序表:结构体+数组

    千次阅读 2019-08-05 19:26:58
    *主要步骤:调用malloc()为顺序表分配一预定大小(ListData)的空间,并将其基址赋值给L.data;() *返回值:无 */ void initList()//初始化 { //构造一个空到顺序表l //l.data=(ListData *)malloc(ListSize*sizeof...
  • #include<stdio.h> #include<stdlib.h> typedef struct{ int *elem; int length;//记录存储的数据个数 }SqList; void Shell(SqList &L,int i){//单位为i的一躺希尔排序 ......
  • ####顺序表的操作,这里先引入头文件 #include<stdio.h> #define MAXSIZE 100 typedef int DataType; typedef struct{ DataType data[MAXSIZE]; int length; }SqList; ######初始化顺序表 只需要让length =...
  • 删除算法的思想和实现和插入算法的思想和实现
  • c语言顺序表的实现与基本操作

    千次阅读 2016-09-09 00:04:00
    顺序表 定义:如图所示顺序表是在计算机内存中以数组的形式保存的线性表,是指用一组地址连续的存储单元依次存储数据元素的线性结构。   顺序表的特性: 1.长度固定; 2.存储空间是连续的; 3.要在顺序表中插入或...
  • 大三狗比较菜,以上代码在我的机子能运行,不保证完全正确...如有错误,欢迎指正!!! 插入操作: #include <stdio.h> #define maxSize 100 typedef struct seqlist ...int insertElem(seqlist *s, int p...
  • C语言顺序表中删除值为x的元素

    千次阅读 2016-12-28 15:50:22
    要求时间复杂度为O(n)、空间复杂度为O(1) 实现代码如下//删除线性表中为x的元素 void deleteX(SqList L,int x){ int k=0; for(i=0;i;i++){ if(L.elem[i]!=x){ L.elem[k]=L.elem[i]; k++;

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 120,774
精华内容 48,309
关键字:

c语言顺序表

c语言 订阅