精华内容
下载资源
问答
  • 主要介绍了C语言实现顺序表基本操作汇总,对学习数据结构的朋友有一定的借鉴价值,需要的朋友可以参考下
  • C语言数据结构实现顺序表的动态申请内存并且合并,代码可以直接使用。
  • 本文实例为大家分享了C语言实现顺序表的顺序查找和折半查找的具体代码,供大家参考,具体内容如下 顺序查找: #include using namespace std; int SeqSearch(int r[],int n,int k) { r[0]=k;//下标0用作哨兵存放...
  • C语言实现顺序表

    万次阅读 多人点赞 2019-03-31 19:10:14
    c语言实现顺序表 线性表是最简单的数据结构,而顺序表又是最简单的线性表,其基本思想是用一段地址连续的储存单元依次存储线性表的数据元素,比如我们常用的一位数组,下面代码实现了顺序表的定义以及基本操作。 ...

    c语言实现顺序表

    线性表是最简单的数据结构,而顺序表又是最简单的线性表,其基本思想是用一段地址连续的储存单元依次存储线性表的数据元素,比如我们常用的一维数组,下面代码实现了顺序表的定义以及基本操作。

    编译环境:vs2017。

    运行试例:在这里插入图片描述
    贴代码如下:

    #include "stdio.h"
    #include "windows.h"
    #include "stdlib.h"
    
    #define MAXSIZE 20//顺序表最大长度
    
    /*定义顺序表*/
    typedef struct {
    	int data[MAXSIZE];
    	int length;
    }SeqList;
    
    /*初始化顺序表*/
    void InitList(SeqList *l)
    {
    	l->length = 0;
    }
    
    /*建立顺序表*/
    int CreatList(SeqList *l, int a[], int n) {
    	if (n > MAXSIZE)
    	{
    		printf("空间不够,无法建立顺序表。\n");
    		return 0;
    	}
    	for (int k = 0; k < n; k++)
    	{
    		l->data[k] = a[k];
    	}
    	l->length = n;
    	return 1;
    }
    
    /*判空操作*/
    int Empty(SeqList *l)
    {
    	if (l->length == 0)
    		return 1;
    	else
    		return 0;
    }
    
    /*求顺序表长度*/
    int Length(SeqList *l)
    {
    	return l->length;
    }
    
    /*遍历操作*/
    void PrintList(SeqList *l)
    {
    	for (int i = 0; i < l->length; i++)
    		printf("%d ", (l->data[i]));
    }
    
    /*按值查找*/
    int Locate(SeqList *l,int x)
    {
    	for (int i = 0; i < l->length; i++)
    	{
    		if (l->data[i] == x)
    		{
    			return i + 1;
    		}
    		return 0;
    
    	}
    	return 1;
    }
    
    /*按位查找*/
    int Get(SeqList *l, int x,int *ptr)
    {//若查找成功,则通过指针参数ptr返回值
    	if ( x <1 || x>l->length){
    		printf("查找位置非法,查找错误\n");
    		return 0;
    	}
    	else
    	{
    		*ptr = l->data[x];
    		return 1;
    	}
    }
    
    /*插入操作*/
    int Insert(SeqList *l, int i, int x)
    {
    	if (l->length > MAXSIZE)
    	{
    		printf("上溢错误!");
    		return 0;
    	}
    	if (i<1 || i>l->length)
    	{
    		printf("插入位置错误!");
    		return 0;
    	}
    	for (int k = l->length; k > i; k--)
    	{
    		l->data[k] = l->data[k - 1];
    	}
    	l->data[i] = x;
    	l->length++;
    	return 1;
    }
    
    /*删除操作*/
    int Delete(SeqList *l, int i, int *ptr)
    {
    	if (l->length == 0)
    	{
    		printf("发生下溢错误,即将要访问顺序表之前的地址.\n");
    		return 0;
    	}
    	if (i > l->length || i < 1)
    	{
    		printf("删除位置错误!\n");
    		return 0;
    	}
    	*ptr = l->data[i - 1];//把要删除的数据返回
    	for (int j = i; j < l->length; j++)
    	{
    		l->data[j - 1] = l->data[j];
    	}
    	l->length--;
    	return 1;
    }
    
    /*修改操作*/
    int Modify(SeqList *l, int i, int x)
    {
    	if (i > l->length || i < 1)
    	{
    		printf("位置错误!\n");
    		return 0;
    	}
    	l->data[i] = x;
    	return 1;
    }
    
    int main()
    {
    	int a[5] = {1,2,3,4,5 };
    	int  i, x;
    	SeqList list1;
    	InitList(&list1);//初始化顺序表
    	if (Empty(&list1))
    	{
    		printf("初始化顺序表成功!\n");
    	}
    	printf("给顺序表赋值:1 2 3 4 5\n遍历并输出顺序表:\n");
    	CreatList(&list1,a,5 );//建立一个长度为5的线性表
    	PrintList(&list1);//遍历输出此顺序表
    	printf("\n在第三位后插入一个100:\n");
    	Insert(&list1, 3, 100);
    	PrintList(&list1);
    	if (Modify(&list1, 3, 50) == 1) {
    		printf("\n把第三位改成50\n");
    		PrintList(&list1);
    	}
    	if (Delete(&list1, 4, &x) == 1) {
    		printf("\n把第四位删除,删除的值是%d\n",x);
    		PrintList(&list1);
    	}
    	system("pause");
    	return 0; 
    }
    

    水平有限,有错希望各位能不吝指出。

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

    2012-11-08 22:23:59
    c语言实现顺序表的多种功能
  • 顺序表是线性表中的一种重要的数据结构,也是最基础的数据结构,所以他不仅是学习中的重点,也是应用开发非常常用的一种数据结构。这篇文章介绍如何利用C语言实现顺序表
  • c语言实现顺序表的完整代码,结构体中元素使用指针形式(非数组),main函数中取消注释即可测试相应模块。
  • C语言实现顺序表基本操作

    千次阅读 2021-02-16 23:17:20
    C语言实现顺序表前言一、顺序表二、使用步骤1.基本操作代码2.主函数测试总结 前言 用C语言实现顺序表的基本操作。 提示:以下是本篇文章正文内容,下面案例可供参考 一、顺序表 数据结构C语言版的顺序表 二、使用...


    前言

    用C语言实现顺序表的基本操作。


    提示:以下是本篇文章正文内容,下面案例可供参考

    一、顺序表

    数据结构C语言版的顺序表

    二、使用步骤

    1.基本操作代码

    代码如下(示例):

    #include <stdio.h>
    #include <stdlib.h>
    #include <malloc.h>
    #define ERROR -1
    #define OK 0
    #define INCREMENT 10//增量
    #define LISTSIZE 100//初始空间
    typedef int Status;
    typedef int Elemtype;
    //顺序存储结构 
    typedef struct {
    	Elemtype *elem;
    	int length;
    	int listsize; 
    }SqList;
    //初始化
    Status InitSqList(SqList &L){
    	L.elem=(Elemtype*)malloc(LISTSIZE*sizeof(Elemtype));
    	if(!L.elem){
    		return ERROR;
    	}
    	
    	L.length=0;
    	L.listsize=LISTSIZE;
    }
    //获取顺序表长度 
    Status getLength(SqList &L){
    	return L.length;
    }
    //创建顺序表 
    Status createList(SqList &L,int n){
    	printf("请输入%d个元素:\n",n);
    	int i = 0;
    	int num;
    	for(i=0;i<n;i++){
    		scanf("%d",&num);
    		L.elem[i]=num;
    		L.length++;
    	} 
    	return OK;
    }
    //插入 
    Status insertList(SqList &L,int i,Elemtype e){
    	if(i<1||i>L.length+1)
    		return  ERROR;
    	//空间不够从新分配 
    	if(L.length>=L.listsize){
    		Elemtype *newbase = (Elemtype *)realloc(L.elem,(LISTSIZE+INCREMENT)*sizeof(Elemtype));
    		if(!newbase)
    		return ERROR;
    		L.elem=newbase;
    		L.listsize=LISTSIZE+INCREMENT;
    	}
    	//标记插入位置和末尾位置 
    	Elemtype *p=L.elem+i-1,*q=L.elem+L.length-1;
    	for(q;q>=p;q--)
    		*(q+1)=*q;//移动元素 
    		*p=e;
    		L.length++;
    		
    		return OK;
    }
    //删除 
    Status deleteList(SqList &L,int i){
    	if(i<1||i>L.length+1)
    		return  ERROR;
    	Elemtype *p=L.elem+i-1,*q=L.elem+L.length-1;
    	for(p;p<q;p++)
    	*p=*(p+1);
    	L.length--;
    	return OK;
    } 
    //获取某元素 
    Status getElem(SqList &L,int i){
    	return L.elem[i-1];
    }
    //获取该元素下标 
    Status getIndex(SqList &L,Elemtype e){
    	int i=0;
    	for(i=0;i<L.length;i++){
    		if(e==L.elem[i])
    		return i;
    	}
    	if(i>L.length)
    	return ERROR;
    } 
    void displayList(SqList &L){
    	int i;
    	for(i=0;i<L.length;i++){
    		printf("%d ",*(L.elem+i));
    	}	
    	printf("\n");
    }
    

    2.主函数测试

    代码如下(示例):

    int main(){
    	SqList L;
    	InitSqList(L);
    	
    	createList(L,5);
    	printf("创建的新顺序表:\n");
    	displayList(L);
    	insertList(L,2,888);
    	printf("插入新元素之后的顺序表:\n");
    	displayList(L);
    	deleteList(L,2);
    	printf("删除之后的顺序表:\n");
    	displayList(L);
    	int e = getElem(L,1);
    	printf("\n获取的元素是:%d",e);
    	int index = getIndex(L,e);
    	printf("\n获取到%d的下标是%d",e,index);
    	return 0;
    } 
    

    总结

    数据测试本文仅仅简单介绍了顺序表基本操作的实现。

    展开全文
  • C语言实现顺序表的创建及基本操作

    万次阅读 多人点赞 2020-03-21 18:06:06
    今天主要是分享一下我在学习数据结构的顺序表实现的一些基本操作,以及学习过程当中遇到的一些问题。我觉得学习这一部分内容的时候,除了要掌握基本操作方法的编写,还要学会对方法进行**实例化**。由于课本上这一...

    C语言实现顺序表的创建及基本操作

    今天主要是分享一下我在学习数据结构的顺序表时实现的一些基本操作,以及学习过程当中遇到的一些问题。我觉得学习这一部分内容的时候,除了要掌握基本操作方法的编写,还要学会对方法进行实例化。由于课本上这一部分的内容比较少,我也是查阅了CSDN上的许多文章才明白的。
    废话到此,下面正式开始。

    1. 顺序表的结构定义
      顺序表的存储结构可以借助于一维数组来表示,一维数组的下标与元素在线性表中的序号相对应。
    #include<stdio.h>
    #include<stdlib.h>
    #define max 100
    
    typedef struct {//顺序表的存储结构定义 
    	int data[max];//顺序表占用的数组空间 
    	int last; //记录顺序表中最后一个元素在数组中的位置 空表为0
    }list;
    
    1. 顺序表的初始化
    void start(list l){//初始化顺序表 设置为空表 
    	l.last=0; 
    	printf("顺序表已经初始化为空表\n");
    } 
    
    1. 对顺序表进行顺序插入
    void shunxu(list *l,int n){//顺序插入  
    	int i=0;
    	int j;
    	while(i<n)
    	{
    		scanf("%d",&j);
    			l->data[i]=j;
                i++; 
    	}
    	l->last=n;
    }
    
    1. 进行指定位置插入

      进行元素的插入后要将表长加1

    void enterlist(list *l,int i,int e){//顺序表的插入操作(指定位置的插入) i为数组下标 e为要填进去的值 
    	int k;
    	if((i<0)||(i>l->last)){//判断插入的位置是否合法 
    		printf("插入的位置不合法\n");
    	}
    	if(l->last>max){//判断顺序表是否已满 
    		printf("表满,无法插入\n");
    	}
    	for(k=l->last;k>=i;k--){
    		l->data[k+1]=l->data[k];
    	} 
    	l->data[i]=e;
    	l->last++;//表长加一 
    } 
    
    1. 对指定位置删除
      对元素删除后要将表长减1
    void dellist(list *l,int i){//顺序表的删除操作 删除指定位置 数组下标为 i 的元素 
    	int k;
    	if(i<0||i>l->last){
    		printf("删除的位置不合法\n"); 
    	}
    	else{
    		printf("删除的元素是%d\n",l->data[i]);
    		for(k=i;i<=l->last;k++){//使后面的元素依次前移 填补删除的空缺 
    			l->data[k]= l->data[k+1];
    		}
    		l->last--;//删除一个元素 表长减一 
    	}
    }
    
    1. 顺序表的打印
    void printlist(list l){//顺序表的打印 
         int i=0; 
    	 while(i<l.last){
    	 	printf("%d ",l.data[i]);
    	 	i++;
    	 }
    } 
    
    1. 主函数
    int main(){
    	list l;
    	start(l);
    	int n;
    	printf("你想输入的数据的个数:\n");
    	scanf("%d",&n); 
    	printf("请向顺序表中输入数据:\n");
        shunxu(&l,n); 
        printf("顺序表的值为:\n");
        printlist(l); 
    	printf("\n请输入要删除元素的下标:\n") ;
    	int j;
    	scanf("%d",&j);
    	dellist(&l,j);
    	return 0;
    }
    

    运行结果:
    在这里插入图片描述

    遇到的问题

    在进行函数的传参时遇到的问题:
    首先我把顺序表的数据类型定义为list,使用的变量定义为l
    变量l的定义与使用方法有两种:

    1. 通过变量定义语句
    list l;
    l.data[i]//访问下标为i的数据元素
    l.last//得到顺序表最后一个元素的下标
    l.last+1//得到顺序表的长度
    
    1. 通过指针变量定义语句
    list l1,*l;
    l=&l1;
    l->data[i]//作用同上
    l->last//作用同上
    l->last+1//作用同上
    

    这两种定义方式看上去很像,但实际使用的时候是有所不同的。
    我总结为当使用的时候不涉及数据的改变(即查找,打印等等),两种使用方式都可以获得想要的结果。
    有数据变化时,使用第二种方式才可以,否则是改变不了数据值的。例如:

    void enterlist(list *l,int i,int e)//指定位置插入时的参数定义
    l->data[k+1]=l->data[k];//具体语句的使用
    shunxu(&l,n); //主函数中对函数的调用
    

    总结

    这是我写的第一篇博客,希望以后可以再接再厉,天道酬勤,加油加油!

    展开全文
  • 数据结构——C语言实现顺序表

    千次阅读 2019-09-11 23:03:34
    数据结构——C语言实现顺序表 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构。一般情况下顺序表是以数组为基础,结构体为框架来实现的。数组存储。在数组上完成数据的增删查改,而结构体中包含...

    数据结构——C语言实现顺序表

    顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构。一般情况下顺序表是以数组为基础,结构体为框架来实现的。数组存储。在数组上完成数据的增删查改,而结构体中包含了存储数据的数组、所存储数据的实际长度以及顺序表的容量。
    顺序表一般可分为:
    1.静态顺序表:使用定长数组存储

    #define N 100
    typedef int SLDataType;
    typedef struct SeqList
    {
    SLDataType array[N]; // 定长数组
    size_t size; // 有效数据的个数
    }SeqList;
    
    1. 动态顺序表:使用动态开辟的数组存储
    typedef struct SeqList
    {
    SLDataType* array; // 指向动态开辟的数组
    size_t size ; // 有效数据个数
    size_t capicity ; // 容量空间的大小
    }SeqList;
    

    静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大了,空间开多了浪费,开少了不够用。所以现实中基本都是使用动态顺序表,根据需要动态的分配空间大小,所以下面我们以实现动态顺序表为例进行描述:
    其动态顺序表的定义以及函数接口的声明如下:

    typedef struct SeqList
    {
    	SLDataType* array;
    	size_t size;
    	size_t capacity;
    }SeqList;
    void SeqListInit(SeqList* psl);//初始化顺序表
    void SeqListDestory(SeqList *psl);//摧毁顺序表
    void SeqListCheckCapacity(SeqList *psl);//检查容量
    void SeqListPushBack(SeqList *psl, SLDataType x);//尾插
    void SeqListPopBack(SeqList *psl);//尾删
    void SeqListPushFront(SeqList *psl, SLDataType x);//头插
    void SeqListPopFront(SeqList *psl);//头删
    void SeqListInsert(SeqList *psl, size_t pos, SLDataType x);//向第pos位插入数据
    void SeqListRErase(SeqList *psl, size_t pos);//删除第pos位数据
    int SeqListFind(SeqList *psl, SLDataType x);//查找数据
    void SeqListMdfidy(SeqList *psl, size_t pos, SLDataType x);//修改第pos位的元素
    void SeqListPrint(SeqList *psl);//打印顺序表
    size_t SeqListSize(SeqList *psl);//顺序表的长度
    void SeqListRemoveAll(SeqList *psl, SLDataType x);//按内容全部删除
    void SeqListBubbleSort(SeqList *psl);//冒泡法对顺序表排序
    int SeqListBinaryFind(SeqList *psl, SLDataType x);//顺序表二分查找
    

    函数实现以及功能解释将在以下代码体现:

    #define _CRT_SECURE_NO_WARNINGS 1
    #include<stdlib.h>
    #include"SeqList.h"
    #include<assert.h>
    #include<malloc.h>
    
    //初始化
    void SeqListInit(SeqList* psl)
    {
    	assert(psl);//检验sql是否为空
    	psl->array = NULL;//将前地址置为空
    	psl->size = 0;//顺序表当前长度为0
    	psl->capacity = 0;//顺序表当前容量为0
    }
    //摧毁顺序表
    void SeqListDestory(SeqList *psl)
    {
    	assert(psl);//检验psl是否为空
    	if (psl->array)
    	{
    		free(psl->array);//释放psl空间
    		psl->array = NULL;//将前地址置为空
    		psl->capacity = 0;//将其容量置为0
    		psl->size = 0;//将其实际长度置为0
    	}
    }
    //检查容量:此处可以用malloc进行内存空间申请,亦可用realloc进行申请空间,不过切记两者都必须在申请后对空间是否申请成功进行判断以及malloc申请后使用完毕的释放空间。
    void CheckCapacity(SeqList* psl)
    {
    	 assert(psl);
    	 //检查容量
    	 if (psl->size == psl->capacity)
    	 {
    	  //建立新容量
    	  size_t newcapacity = psl->capacity == 0 ? 5 : 2 * psl->capacity;
    	  //分配空间
    	  psl->array = (SLDataType*)realloc(psl->array, newcapacity * sizeof(SLDataType));
    	  //检查是否分配成功
    	  assert(psl->array);
    	  //更新容量
    	  psl->capacity = newcapacity;
    	 }
    }
    //尾插
    void SeqListPushBack(SeqList* psl, SLDataType x)
    {
    	assert(psl);//检验sql是否为空
    	SeqListCheckCapacity(psl);
    	psl->array[psl->size] = x;//为尾部插入需要插入的值
    	psl->size++;//顺序表当前长度加一
    }
    //尾删
    void SeqListPopBack(SeqList *psl)
    {
    	assert(psl);//检验sql是否为空
    	if (psl->size == 0)//判断顺序表是否为空
    	{
    		printf("SeqList has been empty\n");
    		return;
    	}
    	psl->size--;//顺序表不为空时,顺序表长度减一
    }
    //头插
    void SeqListPushFront(SeqList *psl, SLDataType x)
    {
    	size_t end = 0;
    	assert(psl);//检验sql是否为空
    	SeqListCheckCapacity(psl);//检查容量
    	for (end = psl->size; end > 0; end--)
    	{
    		psl->array[end] = psl->array[end - 1];//将当前顺序表的数据向后移一位
    	}
    	psl->array[0] = x;//为头部插入要插入的值
    	psl->size++;//当前顺序表长度加1
    }
    //头删
    void SeqListPopFront(SeqList *psl)
    {
    	size_t start = 0;
    	assert(psl);//检验psl是否为空
    	if (psl->size == 0)//判断顺序表是否为空
    	{
    		printf("SeqList has been empty!\n");
    		return;
    	}
    	for (start = 0; start < psl->size - 1; start++)
    	{
    		psl->array[start] = psl->array[start + 1];//将当前顺序表的数据向后移一位
    	}
    	psl->size--;//当前顺序表长度减一
    }
    //第pos位插入数据
    void SeqListInsert(SeqList *psl, size_t pos, SLDataType x)
    {
    	//pos==0-->头插
    	//pso==szie-->尾插
    	size_t end = 0;
    	assert(psl && (pos >= 0) && (pos <= psl->size));//检查psl是否为空并判断插入位置的合法性
    	SeqListCheckCapacity(psl);
    	for (end = psl->size; end > pos; end--)
    	{
    		psl->array[end] = psl->array[end - 1];//将当前顺序表pos位以后的数据向后移一位
    	}
    	psl->array[pos] = x;//将第pos位更新为x
    	psl->size++;//当前顺序表长度加1
    }
    //删除第pos位数据
    void SeqListErase(SeqList *psl, size_t pos)
    {
    	size_t start = 0;
    	assert(psl && (pos >= 0) && (pos <= psl->size));//检查psl是否为空并判断插入位置的合法性
    	if (psl->size == 0)//判断顺序表是否为空
    	{
    		printf("SeqList has been empty\n");
    		return;
    	}
    	for (start = pos; start < psl->size - 1; start++)
    	{
    		psl->array[start] = psl->array[start + 1];//将第pos位后的数据向前移一位
    	}
    	psl->size--;//顺序表当前长度减一
    }
    //查找数据
    int SeqListFind(SeqList *psl, SLDataType x)
    {
    	size_t i = 0;
    	assert(psl);//检验psl是否为空
    	if (psl->size == 0)//判断顺序表是否为空
    	{
    		printf("SeqList has been empty\n");
    		return -1;
    	}
    	for (i = 0; i < psl->size; i++)
    	{
    		if (psl->array[i] == x)//遍历顺序表查找数据
    		{
    			return i;//找到返回下标
    		}
    	}
    	return -1;//未找到返回-1
    }
    
    //修改第pos位数据
    void SeqListModify(SeqList *psl, size_t pos, SLDataType x)
    {
    	assert(psl && (pos >= 0) && (pos <= psl->size));//检查psl是否为空并判断修改位置的合法性
    	if (psl->size == 0)//判断顺序表是否为空
    	{
    		printf("SeqList has been empty\n");
    		return;
    	}
    	psl->array[pos] = x;//修改pos位的数据
    }
    //打印顺序表
    void SeqListPrint(SeqList *psl)
    {
    	size_t i = 0;
    	assert(psl);//检查psl是否为空
    	for (i = 0; i < psl->size; i++)
    	{
    		printf("%d ", psl->array[i]);//打印
    	}
    	printf("\n");
    }
    //顺序表的长度
    size_t SeqListSize(SeqList *psl)
    {
    	assert(psl);//检查psl是否为空
    	return psl->size;//返回长度
    }
    //按内容全部删除
    void SeqListRemoveAll(SeqList *psl, SLDataType x)
    {
    	size_t i = 0;
    	size_t index = 0;
    	assert(psl);//检验psl是否为空
    	if (psl->size == 0)//判断顺序表是否为空
    	{
    		printf("SeqList has been empty\n");
    		return;
    	}
    	for (i = 0; i < psl->size; i++)
    	{
    		//两种思维实现删除操作
    		//惯性思维
    		//if (psl->array[i] == x)//找到数据
    		//{
    		//psl->size--;//当前长度减一
    		//	for (index=i; index < psl->size ; index++)
    		//	{
    		//		psl->array[index] = psl->array[index + 1];//删除数据,将该数据后的数据向前移一位
    		//	}
    		//	return;
    		//}
    		//逆向思维:不相等时保存,相等时跳过
    		if (psl->array[i] != x)//当前数据不等于x时
    		{
    			psl->array[index] = psl->array[i];//将其保存
    			index++;
    		}
    	}
    	if (index < psl->size)//新长度小于原长度时,删除成功
    	{
    		psl->size = index;//将新长度赋给顺序表的长度
    		return;
    	}
    	printf("SeqList does not the data\n");//未找到该数据
    }
    //冒泡法对顺序表排序
    void SeqListBubbleSort(SeqList *psl)
    {
    	assert(psl);
    	//升序
    	size_t end = psl->size;
    	while (end > 1)
    	{
    		//单趟冒泡排序
    		int flag = 0;
    		for (size_t i = 0; i < end; i++)
    		{
    			if (psl->array[i - 1]>psl->array[i])
    			{
    				flag = 1;
    				//交换
    				(psl->array[i - 1]) ^= (psl->array[i]);
    				(psl->array[i]) ^= (psl->array[i - 1]);
    				(psl->array[i - 1]) ^= (psl->array[i]);
    			}
    		}
    		if (flag == 0)
    		{
    			break;
    		}
    		--end;
    	}
    }
    //顺序表二分查找:必须在顺序表已排好序的前提下进行查找,否则查找是无效的。
    int SeqListBinaryFind(SeqList *psl, SLDataType x)
    {
    	assert(psl);
    	if (psl->size == 0)
    	{
    		printf("SeqList has been empt\n");
    		return -1;
    	}
    	size_t start = 0;
    	size_t end = psl->size - 1;
    	while (start <= end)
    	{
    		size_t mid = start+(end-start) / 2;
    		if (psl->array[mid] == x)
    		{
    			return mid;
    		}
    		else if (psl->array[mid] > x)
    		{
    			end = mid - 1;
    		}
    		else
    		{
    			start = mid + 1;
    		}
    	}
    	return -1;
    }
    

    在实现顺序表接口函数时需要注意,函数体中一定要对接口函数参数的有效性、顺序表的容量以及顺序表是否为空进行判断与检查,防止产生溢出等错误。在进行循环遍历时,切记对边界值的判断,否则极易造成边界的超出或遗漏进而导致内存空间的溢出。

    展开全文
  • 实现了使用C语言完成顺序表的插入,排序(冒泡排序),删除。 #define maxSize 100 //顺序表定义 typedef struct { int data[maxSize]; int length; }Sqlist; int main(){ //顺序表基本操作 void CreatSqlist...
  • C语言实现顺序表代码
  • C语言实现顺序表(注释非常详细了)

    千次阅读 多人点赞 2019-04-08 21:19:53
    最近在学数据结构,记录下我写的顺序表 #include<stdio.h> #include<stdlib.h> #define MAX_SIZE 255 //顺序表最大容量 /* InitList: seqlist : 要初始化的顺序表 Array : 初始化时添加的元素组成...
  • c语言实现顺序表(详细代码)

    千次阅读 2020-06-12 23:47:57
    #define MaxSize 100 //顺序表的最大长度 typedef struct{ ElemType *data; //存储空间基址 int length; }SqList; //初始化顺序表,创建一个空表 void InitList(SqList *L) { L->data = (ElemType *
  • C语言实现顺序表(顺序存储结构)

    千次阅读 2020-01-13 16:48:04
    顺序表(顺序存储结构)及初始化过程详解 顺序表,全名顺序存储结构,是线性表的一种。通过《线性表》一节的学习我们知道,线性表用于存储逻辑关系为“一对一”的数据,顺序表自然也不例外。 不仅如此,顺序表对...
  • 数据结构顺序表操作 代码如下:#include <stdio>#include <stdlib>#include <malloc>#define LIST_INIT_SIZE 100#define LISINCREMENT 10#define ElemType int#define Status inttypedef struct Sq{ ElemType *elem...
  • C语言实现顺序表的插入

    千次阅读 2020-06-07 22:57:10
    下面是实现的代码:对循序只是初相识了,甚至发现结构也运用得不是很熟练(根本不熟)。 #include <stdio.h> /*自定义*/ #define MAX 6 typedef int elemtype; /*自定义一个结构*/ typedef struct { ...
  • 本程序介绍什么是顺序表的逆置,中间包含初始化和遍历,最后为逆置。简单实用。
  • C语言实现顺序表的初始化、增删查改基本功能引言定义原理实现过程及结果代码运行结果总结 引言 定义 顺序表是线性表的顺序存储结构。形如A_1 、A_2…….A_n的表,这个表的大小为N;并且,我们称大小为0的表为空表。 ...
  • C语言实现顺序表的基本操作 写得比较烂 #include <stdio.h> #include <stdlib.h> #define SIZE 2 typedef struct Array { int count; int isize; int *p; }List; List *initArray();//初始化并置空 ...
  • 算法与数据结构中顺序表C语言实现
  • 这篇博客采用纯c语言完成数据结构顺序表的 增删改查几个基本操作 当作是自己每一次学习后的小总结 下面po代码!! #include<stdio.h> #include<stdlib.h> #define LISTSIZE 20 typedef struct { int* ...
  • C语言实现静态顺序表的实例详解 线性表 定义一张顺序表也就是在内存中开辟一段连续的存储空间,并给它一个名字进行标识。只有定义了一个顺序表,才能利用该顺序表存放数据元素,也才能对该顺序表进行各种操作。 接...

空空如也

空空如也

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

c语言实现顺序表

c语言 订阅