精华内容
下载资源
问答
  • c语言 顺序结构

    2014-08-04 22:41:40
    c语言 顺序结构
  • C语言顺序结构详情.pdf
  • 主要介绍了C语言顺序表实现方法,大家参考使用吧
  • C语言顺序查找法

    2020-12-05 22:29:59
    C语言顺序查找法 输入5个整数,将他们存入数组a中,再输入1个数x,然后在数组中查找x,如果找到,输出相应的最小下标,否则,输出“Not Found”。 /*在数组中查找指定的数*/ #include <stdio.h> int main(void...

    C语言顺序查找法

    输入5个整数,将他们存入数组a中,再输入1个数x,然后在数组中查找x,如果找到,输出相应的最小下标,否则,输出“Not Found”。

    /*在数组中查找指定的数*/
    #include <stdio.h>
    int main(void)
    {
        int i,flag,x;
        int a[5];
        
        printf("Enter 5 integers:");
        for(i=0;i<5;i++)
            scanf("%d",&a[i]);
        printf("Enter x:");
        scanf("%d",&x);
            /*在数组中查找x*/
        flag=0;  //先假设x不在数组中,置flag为0 
        for(i=0;i<5;i++)
            if(a[i]==x){ 
                printf("Index is %d\n",i);
                flag=1;  //置flag为1,说明x在数组a中 
                break;
            }    
        if(flag==0);
            printf("Not Found\n");
            
        return 0;
            
         
    }
    
    展开全文
  • C语言全套资料 C语言程序设计 C语言算法 C语言课件 C语言顺序程序设计,C语言数组,C语言循环控制,C语言预处理命令,C语言文件操作指针,C语言选择结构程序设计,C语言结构体与共用体,C语言文件操作,C语言函数
  • C语言顺序表的插入删除

    万次阅读 多人点赞 2018-09-13 22:08:41
    首先声明一个顺序表的结构 (数组的第一个元素是0,但是顺序表的第一个一般 从1(人为设定)开始) #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #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语言顺序存顺序找

    2012-12-31 10:52:04
    c语言中的顺序顺序找 简单操作 易懂的代码
  • 在S3c2440下的裸板程序调用C语言顺序点亮led
  • C语言顺序表的插入元素 #include<stdio.h> #include<math.h> // #define 定义一个标识符来表示一个常量 #define OK 1 #define ERROR -1 #define MAX_SIZE 100 // typedef 关键字来定义自己习惯的数据...

    C语言顺序表的插入元素

    
    #include<stdio.h>
    #include<math.h>
    // #define 定义一个标识符来表示一个常量
    #define  OK   1
    #define  ERROR   -1
    #define  MAX_SIZE  100
    //  typedef 关键字来定义自己习惯的数据类型名称
    typedef  int  Status ;
    typedef  int  ElemType ; 
    // struct 结构体
    typedef  struct  sqlist{   
    	// 定义一个数组
    	ElemType  Elem_array[MAX_SIZE] ;
    	// 数组的长度
        int length ;
    } SqList ;
    
    // 传参:指针,插入位置的序号(这个序号索引记得-1),元素:可以为数组,也可以为一个数字**
    Status Insert_SqList(SqList *L,int i,ElemType e)
    {   
         int j ;
         // 如果i小于0,或者大于数组长度,则返回-1;
        if  ( i<0||i>L->length-1)   return  ERROR ;
        // 如果你的数组长度大于或者等于你分配空间则插入不了元素
        if  (L->length>=MAX_SIZE){    
            printf("线性表溢出!\n");  return  ERROR ;  
        }
        // i-1位置以后的所有结点后移
        for  ( j=L->length-1; j>=i-1; --j )
            L-> Elem_array[j+1]=L->Elem_array[j];
        /*  i-1位置以后的所有结点后移  */
        L-> Elem_array[i-1]=e;    /*  在i-1位置插入结点  */
        // 数组长度+1;
        L->length++ ;
        // 返回数组
        return  L ;  
    }
    
    展开全文
  • 数据结构c语言 顺序表操作 源代码 运行正常
  • C语言顺序

    2013-12-10 12:36:21
    基于C语言编写的顺序表,层次分明、结构清楚、能成功运行
  • 主要为大家详细介绍了C语言实现顺序表的实现代码,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • C语言顺序结构与I/O

    2011-03-27 17:49:16
    关于C语言顺序结构与I/O的课件,是概况性的,需要其他详细资料喔
  • 我自己写的一个C语言顺序查找的算法程序,可以运行,是按照结构体定义并实现操作的
  • C语言顺序表代码

    2020-08-23 13:01:09
    顺序表是数据数据结构里链表的内容,同时也是学习数据结构和深入了解以及应用C语言指针的一个好的开头,顺序表顾名思义就是一个有顺序存储结构的表了,这个表在内存中是顺序存储的,如果数据比较短 ...

    顺序表就是顺序存储的一张连续表,表的长度和内容由程序员来决定。数据结构都是用到结构体指针的,作为数据结构里最为简单的顺序表,当然也是用结构体指针,开始写代码了,

    创建属于顺序表的seqlist.h文件

     

    #ifndef __seqlist__h
    #define __seqlist__h
    
    #define MAXSIZE 100   //顺序表长度
    typedef int data_t;	  //顺序表存储数据类型
    
    typedef struct {
    	data_t data[MAXSIZE];  /*顺序表个体数据空间大小*/
    	int last;		/*表元素个数*/ 
    }seqlist_t;
    
    #endif

    这里的顺序表的基本构造,大小由 MAXSIZE决定,存储的数据类型重定义为data_t是int类型,以后方便全部转换其他类型,主要的结构体就是很普通的两个参数。data数组负责存储数据,last 负责记录数据长度,下面继续完善代码,加入所需的函数

    #ifndef __seqlist__h
    #define __seqlist__h
    
    #define MAXSIZE 100   //顺序表长度
    typedef int data_t;	  //顺序表存储数据类型
    
    typedef struct {
    	data_t data[MAXSIZE];  /*顺序表个体数据空间大小*/
    	int last;		/*表元素个数*/ 
    }seqlist_t;
    
    seqlist_t *create_seqlist(void);  /*创建表函数*/
    void clear_seqlist(seqlist_t *L); /*清空表*/
    
    int is_empty_seqlist(seqlist_t *L); /*判断表是否为空*/
    int is_full_seqlist(seqlist_t *L); /*判断表是是否满*/
    void set_empty_seqlist(seqlist_t *L); /*设置表为空*/
    int get_length_seqlist(seqlist_t *L); /*返回表长度*/
    void  show_seqlist(seqlist_t *L); /*显示表有效内容*/
    
    int insert_seqlist(seqlist_t *L,data_t x); /*插入元素*/
    int delete_seqlist(seqlist_t *L,int pos); /*删除元素*/
    int change_seqlist(seqlist_t *L,data_t x,int pos); /*修改元素*/
    int search_seqlist(seqlist_t *L,data_t x); /*查找元素位置*/
    
    #endif
    

    以上就是我们.h文件所有内容了,接下来实现seqlist.c文件,记得头文件

    #include <stdio.h>   
    #include <stdlib.h>    
    #include "seqlist.h"
    
    seqlist_t *create_seqlist(void) /*创建表函数*/
    {
    	seqlist_t *L = NULL;   /*建立顺序表指针*/
    	L = (seqlist_t *)malloc(sizeof(seqlist_t)); /*分配空间*/
    	if(L == NULL) 		/*判断是否分配成功*/
    	{
    		puts("no memory");
    		return NULL;
    	}
    	else
    	{
    		puts("memory application");   //申请成功
    	}
    	
    	L->last = -1;  //表示还没有一个内容
    	return L;
    }
    
    void clear_seqlist(seqlist_t *L)  /*删除表*/
    {
    	if(L == NULL)
    	{
    		puts("seqlist_t *L is NULL");
    		return;
    	}
    	free(L);   /*否则不为空释放内存空间*/
    	return;
    }
    
    int is_empty_seqlist(seqlist_t *L) /*判断表是否为空*/
    {	
    	if(L == NULL)
    	{
    		puts("seqlist_t *L is NULL");
    		return -1;
    	}
    	return (L->last == -1);
    }
    int is_full_seqlist(seqlist_t *L) /*判断表是是否满*/
    {
    	if(L == NULL)
    	{
    		puts("seqlist_t *L is NULL");
    		return -1;
    	}
    	return (L->last == MAXSIZE-1);
    }
    void set_empty_seqlist(seqlist_t *L) /*设置表为空*/
    {	
    	if(L == NULL)
    	{
    		puts("seqlist_t *L is NULL");
    		return;
    	}
    	L->last = -1;
    	return;
    }
    int get_length_seqlist(seqlist_t *L) /*返回表长度*/
    {
    	if(L == NULL)
    	{
    		puts("seqlist_t *L is NULL");
    		return -1;
    	}
    	return (L->last+1);
    }
    void show_seqlist(seqlist_t *L) /*显示表有效内容*/
    {
    	int i = 0;
    	if(L == NULL)
    	{
    		puts("seqlist_t *L is NULL");
    		return ;
    	}
    	for(i=0;i<=L->last;i++)
    	{
    		printf("L-data[%d]= %d \n",i,L->data[i]);
    	}
    	return;
    }
    
    int insert_seqlist(seqlist_t *L,data_t x) /*添加元素*/
    {
    	//int i  = 0;
    	if((is_full_seqlist(L)))
    	{
    		puts("input argv is invalid");
    		return -1;
    	}
    /* 	for(i=L->last;i>=0;i--)   
    	{
    		L->data[i+1] = L->data[i];
    	} */
    	L->data[L->last+1] = x;
    	L->last++;
    	return 0;
    
    }
    int delete_seqlist(seqlist_t *L,int pos) /*删除元素*/
    {
    	int i = 0,y=0;
    	y = get_length_seqlist(L);
    	if((pos<0)||(pos>L->last))
    	{
    		puts("input pos is invaild");
    		return -1;
    	}
    	for(i = pos;i<y;i++)
    	{
    		L->data[i] = L->data[i+1];
    	}
    	L->last--;
    	return 0;
    }
    int change_seqlist(seqlist_t *L,data_t x,int pos) /*修改元素*/
    {
    	if((pos<0)||(pos>L->last))
    	{
    		puts("input pos is invaild");
    		return -1;	
    	}
    	L->data[pos] = x;
    	return 0;
    }
    int search_seqlist(seqlist_t *L,data_t x) /*查找元素位置*/
    {
    	int i = 0,y=0;
    	y = get_length_seqlist(L);
    	if(L == NULL)
    	{
    		puts("seqlist_t *L is NULL");
    		return -1;
    	}
    	printf("find %d ",x);
    	for(i=0;i<y;i++)
    	{
    		if(L->data[i]==x)
    		{
    			printf("the %d in L->data[%d]\n",x,i);
    			return 0;
    		}
    	}		
    	return -1;
    }
    
    
    

    在以上函数中,添加元素这个函数可以分为往后添加或者往前添加,取消注释就是往前添加,否者就是往后添加,

    下面市县main文件来对顺序表进行测试,

    #include <stdio.h>
    #include <stdlib.h>
    #include "seqlist.h"
    
    int main(int argc,const char *argv[])
    {
    	int i=0;
    	seqlist_t * L=NULL;
    
    	L=create_seqlist();  //创建顺序表
    
    	i = is_empty_seqlist(L);  //判断是否为空,是返回1 ,否返回0
    	printf("%d \r\n",i);
    	i = 0;
    
    	for(i=0;i<=4;i++)   	//添加元素
    	{
    	 insert_seqlist(L,i);
    	}
    
    	i = is_full_seqlist(L);  //判断是否满,是返回1 否返回0
    	printf("%d \r\n",i);
    
    	show_seqlist(L);     //显示所有元素
    	
    	delete_seqlist(L,1);    //删除索引为1 的元素
    	show_seqlist(L);		//显示所有元素
    	delete_seqlist(L,6);	//删除索引为6 的元素
    	show_seqlist(L);		//显示所有元素
    	
    	search_seqlist(L,4);   //查找4这个元素的索引值
    	change_seqlist(L,8,3);  //修改索引3 的元素为8
    	show_seqlist(L);		//显示所有元素
    	clear_seqlist(L);  	   //删除表
    	return 0;
    }

    测试结果和预期一致,至此,C语言顺序表建立完成,顺序表相比一维数组并无太大区别,但是顺序表便于管理和移植,

    这些都是鄙人经验所得,大神或者初学者有什么疑问或者指点的欢迎骚扰

    QQ:2278326006

    谢谢

    展开全文
  • C语言顺序查找

    2020-02-23 15:13:26
    顺序査找是一种简单的査找算法,其实现方法是从序列的起始元素开始,逐个将序列中的元素与所要查找的元素进行比较,如果序列中有元素与所要查找的元素相等,那么査找成功,如果査找到序列的最后一个元素都不存在一个...
  • 有利于C语言的学习和提高,顺序语句是C语言的基础部分之一,一定要学号
  • 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语言顺序

    千次阅读 2018-06-09 13:37:25
    #include &lt;stdio.h&gt;#include &lt;stdlib.h&gt;#define MAXSIZE 1000typedef int ElemType;typedef struct //定义结构体{ ElemType data[MAXSIZE];//定义数据域 int top;...
  • C语言顺序表应用

    2013-12-23 14:12:52
    顺序表的添加、删除、查找、取出结点、结点排序
  • c语言顺序程序设计

    2017-10-10 19:41:39
    C语言的语句常用的几大类型:表达式语句函数调用语句控制语句复合语句空语句赋值语句是C语言的其中一种。通常用到的输入输出是一种系统函数体,属于函数调用语句。 printf() scanf() putchar() getchar() 属于系统...
  • c语言 顺序表的基本操作(创建、初始化、赋值、插入、删除、查询、替换、输出) 1、创建、申请空间 2、初始化、顺序表数据结构大小、长度 3、赋值、顺序表数据结构赋值 4、插入、在指定位置插入数据,后续数据...
  • C语言顺序表实例

    2012-11-28 18:36:44
    自己写的顺序表的定义,创建,插入、删除等常用操作,有详细注释,结构清晰,适合初学者。
  • C语言顺序程序设计练习题 描述 要将 “China“ 译成密码,密码规律是:用原来的字母后面第 4 个字母代替原来的字母。(谭浩强 C 语言 第三版 67 页第 3.7 题) 题目 要将 “China” 译成密码,密码规律是:用原来的...
  • 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语言顺序表的初始化

    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语言顺序表的基本操作

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

    千次阅读 2018-07-09 21:07:24
    顺序栈 :它是顺序表的一种,具有顺序表同样的存储结构,由数组定义,配合用数组下标表示的栈顶指针top(相对指针)完成各种操作。sqstack.h //顺序栈头文件(在内存中分配一段连续的存储空间存放入栈的相关数据)#...
  • #include <stdio.h> #include <math.h> int main(){ float a,b; scanf("%1f%1f",&a,&b); float x = (-b) / a; printf("%.6f",x); return 0; }

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 22,526
精华内容 9,010
关键字:

c语言顺序

c语言 订阅