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

    2012-12-03 19:26:48
    顺序表七种基本操作,纯C语言!
  • 顺序表 C语言

    2019-02-17 21:39:06
    线性表之顺序表的操作集 #include <stdio.h> #include <stdlib.h> #define MAXSIZE 100 #define ElemType int struct LNode{ ElemType data[MAXSIZE]; int Last;//表中最后一个元素...

    线性表之顺序表的操作集

    #include <stdio.h>
    #include <stdlib.h> 
    #define MAXSIZE 100
    #define ElemType int
    struct LNode{
    	ElemType data[MAXSIZE];
    	int Last;//表中最后一个元素的下标,表长LAst+1 
    	
    }; 
    typedef struct LNode*List;//结点类型的指针
    
    List  Init()//初始化 
    {
    	List PtrL;
    	PtrL=(List)malloc(sizeof(struct LNode));//申请线性表结构指针 
    	PtrL->Last=-1;//没有元素
    	return PtrL; 
    }
    
    int Search(ElemType x,List p)//查找 
    {
    	int i;
    	while(i<=p->Last&&p->data[i]!=x){
    		i++;
    	}
    	if(i>p->Last)//没找到 
    		return -1;
    	else
    		return i;	
    } 
    
    void Insert(ElemType x,int i,List p) //插入 
    {
    	int j;
    	if(p->Last==MAXSIZE-1){//判断表满, Last==MAXSIZE-1
    		printf("ERROR:表满\n");
    		return;
    	}
    	if(i<1||i>p->Last+2){//判断插入位置 
    		printf("ERROR:位置不合法\n");
    		return;
    	}
    	for(j=p->Last;j>=i-1;j--){//从后往前后挪一位,注意下标 
    		p->data[j+1]=p->data[j];
    	}
    	p->data[i-1]=x;//交换 
    	p->Last++;
    	return;
    }
    
    void Del(int i,List L)
    {
    	int j;
    	if(i>L->Last+1||i<1){
    		printf("ERROR:位置不合法\n");
    		return;
    	}	
    	if(L->Last==-1){
    		printf("ERROR:表空\n");
    		return;
    	}
    	for(j=i;j<=L->Last;j++){
    		L->data[j-1]=L->data[j];
    	}
    	L->Last--;
    	return;
    } 
    
    int main()
    {
    	int i,n,key;
    	List L;
    	L=Init();
    	printf("ok\n");
    	scanf("%d",&n);
    	for(i=0;i<n;i++){
    		Insert(i,i+1,L);
    	}
    	for(i=0;i<n;i++){
    		printf("%d ",L->data[i]);
    	}
    	for(i=1;i<n;i+=2){
    		Del(i+1,L);
    	}
    	for(i=0;i<n/2;i++){
    		printf("%d ",L->data[i]);
    	}
    	printf("请输入要查找的值\n");
    	scanf("%d",&key);
    	int t=Search(key,L);
    	if(t==-1)
    		printf("None\n");
    	else
    		printf("Yes,in %d\n",t);
    	return 0;
    }
    
    展开全文
  • 线性表--顺序表 C语言实现从顺序表开始探索数据结构的魅力数组杂谈数组名和指向数组头的指针遍历整个数组数组下标越界访问数组中存在无效数据数组存在的问题解决数组存在的不足线性表--顺序表线性表的定义:顺序表的...

    从顺序表开始探索数据结构的魅力

    顺序表作为线性表中的一类,可以说是数据结构中最简单的、最基础的一种结构。很多书籍都以此作为开篇,来讲述数据结构的魅力。作为数据结构的开篇,有必要好好学习这一内容,这样才能养成良好的数据结构思维习惯。数据结构从本质上讲,就是定义一种性质,并且在后续的操作中维护这一性质,从而达到特定的目的。

    数组杂谈

    顺序表实际上可以看作一个“高级”的数组,这是因为数组的性质正好满足顺序表的定义,因而在讨论顺序表前,我们先来看看数组的使用和它的不足。

    数组名和指向数组头的指针

    数组名和指向数组头的指针很多时候是可以混为一谈的,但严谨的讲,两者是不同的。
    我们来看一个代码:

    #include <stdio.h>
    
    int main() {
        int array[] = {1,2,3,4,5};
        int *p = array;
    
        printf("sizeof(array) = %d\n",sizeof(array));
        printf("sizeof(p) = %d\n",sizeof(p));
    
        return 0;
    }
    

    在64位机下输出的结果是:

    sizeof(array) = 20
    sizeof(p)= 8

    可以看出,数组名指的是整个数组,其中包含着一个数组占用内存了多少内存,我们可以通过数组名,获取数组中拥有多少个元素。而指向数组头的指针,本质是一个指针变量,它所占的字节数是固定的。
    在这里插入图片描述

    遍历整个数组

    如果只是在数组定义的作用域中,遍历数组是十分简单的,只需要一个数组名即可。

    #include <stdio.h>
    
    int main() {
        int array[] = {1,2,3,4,5};
    	int size = sizeof(array) / sizeof(int);
        for (int i = 0; i < size;i++) {
            printf("%d ",array[i]);
        }
        printf("\n");
    
        return 0;
    }
    

    但想要跨作用域来实现相同的功能,往往会利用到函数,结合传递参数来实现。但C语言中,我们传递的是一个数组名,但编译器会把它变成一个地址进行传递,从而丢失了数组的长度信息。因此下面的做法明显是错误的:

    #include <stdio.h>
    
    void order(int array[]) {
    	int size = sizeof(array) / sizeof(int);
        for (int i = 0; i < size;i++) {
            printf("%d ",array[i]);
        }
        printf("\n");
    }
    
    int main() {
        int array[] = {1,2,3,4,5};
        order(array);
    
        return 0;
    }
    

    而为了避免这样的错误,常见的做法,是把数组的长度作为参数,传递给函数。如下:

    #include <stdio.h>
    
    void order(int array[],int size) {
        for (int i = 0; i < size;i++) {
            printf("%d ",array[i]);
        }
        printf("\n");
    }
    
    int main() {
        int array[] = {1,2,3,4,5};
        int size = sizeof(array) / sizeof(int);
        order(array,size);
    
        return 0;
    }
    

    从这里我们已经能发现数组的第一个短板了:数组的长度信息会在传参中丢失

    数组下标越界访问

    数组的下标越界是一种很常见的错误。在C语言规范中,这属于一种未定义行为。各个编译器对其进行的处理各不相同。但有一点是明确的,这样的操作是很危险的。

    #include <stdio.h>
    
    #define SIZE 5
    int main() {
        int array[SIZE] = {1,2,3,4,5};
    
        for (int i = 0;i < SIZE + 1;i++) {
            printf("%d ",array[i]);
        }
        printf("\n");
    
        return 0;
    }
    

    上面的代码,可以很容易看出,当遍历执行到最后一次,访问的位置是array[5],这明显是下标越界了,我们并不清楚这一块内存中的数值具体是多少。但这个问题在编译期间是不会被发现的,甚至在运行时也很难察觉,因此数组的第二个不足也呼之欲出:数组下标的越界访问是未定义行为,我们无法对其进行有效的防护

    数组中存在无效数据

    很多时候,我们为了图省力,一口气开辟一个很大的数组,但实际运行中,只有其中的一部分被使用了(我们假设用的时候一定是从前往后使用的),那么访问没被使用的数组空间同样是一件危险的事。这实际是编程技巧带来的隐患。
    打个比方:假设我们要按天记录今年的收入,我们理所当然的会以年作单位,直接拿出一个大本子进行记录,假设今天是4月1号,这时我想查阅5月1号的收入,这时我们能在账单上找到这个日子对应的账单,但我们并没有记录到这一天,所有查阅是可以的,但里面的信息是无效的。

    数组存在的问题

    通过前面的三个例子。我们已经得出了普通数组存在的缺陷了,主要有两点:

    • 数组的长度信息会在传参中丢失
    • 数组下标的越界访问是未定义行为,我们无法对其进行有效的防护

    还有一个是编程技巧带来的隐患:

    • 数组中有些数据是无效的

    解决数组存在的不足

    既然明确的知道了数组存在的不足,我们就可以对症下药,逐个解决它们。
    解决前两个问题的方式前面就提到了,就是增加一个size字段,这样不仅能知晓数组的长度,也能避免下标越界。
    而由编程技巧带来的隐患,可以通过增加一个length字段解决。这个字段记录数组前length个数据是有效的,超过length的部分对我们而言是无效数据。
    根据上面的分析,我们就可以着手写代码了:

    #include <stdio.h>
    
    #define SIZE 100
    
    int main() {
        int array[SIZE] = {0};
        int size = sizeof(array) / sizeof(int);   //记录array的长度
        int length = 0;                           //记录array中有效数据的个数
    
    
        return 0;
    }
    

    通过对sizelength字段的使用,我们可以让数组的操作更加安全,也弥补了数组的先天不足。
    至此,实际上我们已经完成了顺序表的结构定义。顺序表其实就是通过数组增加两个字段,达到了比数组更加安全、可靠的目的。

    线性表–顺序表

    这里有必要理清一下线性表和顺序表之间的关系
    线性表是逻辑结构层面的概念,指的是元素间的关系是一对一的
    顺序表是物理结构层面的概念,指的是元素存储在一段连续的内存空间中,而数组正好就有这样的性质。

    线性表的定义:

    线性表(linear list)也被成为有序表(ordered list),它的每一个实例都是元素的一个有序集合。每一个实例的形式为(e0,e1,e2,...en1)(e_0,e_1,e_2,...e_{n-1})
    其中n是有穷自然数,eie_i是线性表的元素,i是元素eie_i索引,n是线性表的长度
    可知索引是从0开始的,到n-1结束。

    顺序表的结构定义

    顺序表实际上就是用一段连续的内存空间实现的线性表,而数组就是不二的选择。其实前面在分析数组的时候,我们就已经把顺序表的结构定义描述出来了,我们将其封装成一个结构体,方便后续操作。

    typedef struct SequentialList{
        int *array;      //数组
        int size;        //记录数组的长度
        int length;      //记录array中有效数据的个数
    }SequentialList; 
    

    顺序表的相关操作

    顺序表的基本操作有:

    • 创建顺序表
    • 销毁顺序表
    • 判空操作
    • 按一个给定索引查找一个元素
    • 按一个给定索引插入一个元素
    • 按一个给定索引删除一个元素
    • 遍历输出顺序表中的全部元素

    等等。接下来我们逐一来实现。
    创建和销毁顺序表
    因为C语言是没有GC机制的,因而这两个操作往往是成对出现的,我们就一起实现了。
    创建顺序表
    在创建之前,我们需要清楚的知道,我们需要初始化哪些量,及它们的值各为多少。
    不难想到,数组的长度是可以自定义的,我们需要通过传参来控制,并且需要为其开辟相应的内存空间。size字段记录的就是数组长度,也可以确定。而初始化后的顺序表,其有效的元素个数为0,length的值也就确定了。

    SequentialList *createSequentialList(int _size) {
        SequentialList *sl = (SequentialList*)malloc(sizeof(SequentialList));
        sl->array = (int*)malloc(sizeof(int) * _size);
        sl->size = _size;
        sl->length = 0;
        return sl;
    }
    

    销毁顺序表
    销毁的操作很简单,就是回收堆上的内存,防止内存泄漏。

    void destroySequentialList(SequentialList *sl) {
        if (sl == NULL) return;
    
        free(sl->array);   //回收数组所占内存
        free(sl);          //回收顺序表对象的内存
    
        return;
    }
    

    判空操作
    判空操作实际上是一个辅助操作,我们只要知道现在的有效数据个数是不是0,就可以判断了。

    int is_empty(SequentialList *sl) {
        if (sl == NULL) return -1;
        return sl->length == 0;
    }
    

    按一个给定索引查找一个元素
    之间根据下标返回元素即可,但需要注意数据索引的有效范围应当是0到length - 1的。

    int getElement(SequentialList *sl,int index) {
        if (sl == NULL) return -1;
        if (index < 0 || index > sl->length) return -1;   
    
        return sl->array[index];
    }
    

    按一个给定索引插入一个元素
    同样需要注意索引的合法取值,应为0到length(因为是插入,插入到末尾是合理的)。同时,插入操作,需要让索引后面的所有值,都依次向后一位,这样才有空的位置可供插入。而向后一位的顺序应当是最后一位开始移动的。
    在这里插入图片描述

    int insert(SequentialList *sl,int index,int element) {
        if (sl == NULL) return 0;
        if (index < 0 || index > sl->length) return 0;
        if (sl->length == sl->size) return 0;
    
        for (int i = sl->length;i > index; i--) {
            sl->array[i] = sl->array[i - 1];
        }
        sl->array[index] = element;
        sl->length++;
    
        return 1;
    }
    

    按一个给定索引删除一个元素
    技巧和插入差不多,不同的是,这次元素的移动方向是从索引的后一个元素开始,统一往前移动一位。
    在这里插入图片描述

    int erase(SequentialList *sl,int index) {
        if (sl == NULL) return 0;
        if (index < 0 || index > sl->length) return 0;
    
        for (int i = index + 1; i < sl->length; i++) {
            sl->array[i - 1] = sl->array[i]; 
        }
        sl->length--;
    
        return 1;
    }
    

    遍历输出顺序表中的全部元素

    void display(SequentialList *sl) {
        if (sl == NULL) return;
        if (is_empty(sl)) return;
    
        for(int i = 0; i < sl->length; i++) {
            printf("%d ",sl->array[i]);
        }
        printf("\n");
    
        return;
    }
    

    顺序表的整体实现

    #include <stdio.h>
    #include <stdlib.h>
    
    //顺序表结构定义
    typedef struct SequentialList{
        int *array;      //数组
        int size;        //记录数组的长度
        int length;      //记录array中有效数据的个数
    }SequentialList; 
    
    //创建顺序表   
    SequentialList *createSequentialList(int _size) {
        SequentialList *sl = (SequentialList*)malloc(sizeof(SequentialList));
        sl->array = (int*)malloc(sizeof(int) * _size);
        sl->size = _size;
        sl->length = 0;
        return sl;
    }
    
    //销毁顺序表
    void destroySequentialList(SequentialList *sl) {
        if (sl == NULL) return;
    
        free(sl->array);   //回收数组所占内存
        free(sl);          //回收顺序表对象的内存
    
        return;
    }
    
    //判空操作
    int is_empty(SequentialList *sl) {
        if (sl == NULL) return -1;
        return sl->length == 0;
    }
    
    //按一个给定索引查找一个元素
    int getElement(SequentialList *sl,int index) {
        if (sl == NULL) return -1;
        if (index < 0 || index > sl->length) return -1;   
    
        return sl->array[index];
    }
    
    //按一个给定索引插入一个元素
    int insert(SequentialList *sl,int index,int element) {
        if (sl == NULL) return 0;
        if (index < 0 || index > sl->length) return 0;
        if (sl->length == sl->size) return 0;
    
        for (int i = sl->length;i > index; i--) {
            sl->array[i] = sl->array[i - 1];
        }
        sl->array[index] = element;
        sl->length++;
    
        return 1;
    }
    
    //按一个给定索引删除一个元素
    int erase(SequentialList *sl,int index) {
        if (sl == NULL) return 0;
        if (index < 0 || index > sl->length) return 0;
    
        for (int i = index + 1; i < sl->length; i++) {
            sl->array[i - 1] = sl->array[i]; 
        }
        sl->length--;
    
        return 1;
    }
    
    //遍历输出顺序表中的全部元素
    void display(SequentialList *sl) {
        if (sl == NULL) return;
        if (is_empty(sl)) return;
    
        for(int i = 0; i < sl->length; i++) {
            printf("%d ",sl->array[i]);
        }
        printf("\n");
    
        return;
    }
    
    int main() {
        SequentialList *sl = createSequentialList(100);           //创建顺序表
        
        for (int i = 0; i < 10; i++) {  
            if (!insert(sl,i,i))                                  //按一个给定索引插入一个元素
                return -1;                                        //插入失败
        }
        display(sl);                                              //遍历输出顺序表中的全部元素
    
        for (int i = 0;i < 5; i++) {
            if (!erase(sl,0))                                     //按一个给定索引删除一个元素
                return -1;                                        //删除失败
        }
        display(sl);                                              //遍历输出顺序表中的全部元素
    
        for (int i = 0; i < sl->length; i++) {
            printf("索引%d对应的数据为:%d\n",i,getElement(sl,i)); //按一个给定索引查找一个元素 
        }
    
        destroySequentialList(sl);                                //销毁顺序表
        return 0;
    }
    

    顺序表的优缺点

    顺序表因为是由连续内存空间实现的,它的优缺点很明显
    优点:查找操作快,之间下标索引,时间复杂度O(1)
    缺点:插入、删除操作慢,需要遍历整个数组,时间复杂度O(n)

    后记

    C语言的数组存在的缺陷,在很多语言中其实已经被消除了。Java、C#等语言的数组本身就带有长度等信息。但这不影响我们的顺序表学习,数据结构归根结底学的是一种思维逻辑,一旦理解了某个结构存在的意义,以及其现实的用途,我们才能把它用到合适的地方中去,发挥它真正的作用。

    展开全文
  • 数据结构-顺序表C语言实现基本操作代码实现 基本操作 1.void InitList(SqList *L):初始化线性表,创建一个空表 2.int GetElem(SqList L,int i):按位置查找,将表L中第i个位置的元素返回 3.int LocateElem(SqList L...

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

    基本操作

    1.void InitList(SqList *L):初始化线性表,创建一个空表
    2.int GetElem(SqList L,int i):按位置查找,将表L中第i个位置的元素返回
    3.int LocateElem(SqList L,ElemType e):按值查找,将表L中查找与给定值相等元素返回
    4.int ListInsert(SqList *L,int i,ElemType e):插入操作,在表L中第i个位置插入新元素e
    5.int ListDelete(SqList *L,int i,ElemType *e):删除操作,在表L中第i个位置元素删除,并用e返回其值
    6.void PrintList(SqList L);打印操作

    代码实现

    #include <stdio.h>
    #include <stdlib.h>
    #define MAXSIZE 100
    #define ElemType int
    
    typedef struct{
        ElemType Data[MAXSIZE];
        int length;
    }SqList;
    
    void InitList(SqList *L);
    int GetElem(SqList L,int i);
    int LocateElem(SqList L,ElemType e);
    int ListInsert(SqList *L,int i,ElemType e);
    int ListDelete(SqList *L,int i,ElemType *e);
    void PrintList(SqList L);
    
    int main()
    {
    	SqList L; 
        printf("===========请输入您的选择=============\n");
        printf("1.初始化顺序表\t\t 2.查找(按位置查找)元素\t\t 3.查找(按值查找)元素\n");
        printf("4.插入操作( 1<=i<=L.length+1 )\t\t 5.删除操作(1<=i<=L.length)\t\t 6.输出所有元素\t\t#.退出 \n");
        char c;
        while (1){
        	scanf("%c",&c);
            if(c=='1'){
                InitList(&L); 
                printf("初始化成功\n");     	
    		}else if(c=='2'){
    			int i;
    	    	printf("请输入您要查询的元素位置:\n");
    	    	scanf("%d",&i);
    	    	int a=GetElem(L,i);
    	    	printf("%d\n",a);			
    		}else if(c=='3'){
    			int e;
    			printf("请输入您要查询的元素值:\n");
    			scanf("%d\n",&e);		
    			int a=LocateElem(L,e);
    			printf("%d\n",a);
    		}else if(c=='4') {
                int e;
                char d='n';
                int i=1;
                while(d=='n'){
    	            printf("请输入您要添加的元素:\n");
    	            scanf("%d",&e);
    	            ListInsert(&L,i,e);
    	            printf("添加成功\n");
    	            i++;
    	            printf("是否停止添加元素n/y:\n");
    				scanf("%s",&d);
    			}
    		}else if(c=='5'){
    			
    			int i=0;
    			printf("请输入您要删除第几个位置:\n");
    			scanf("%d",&i);
    			int e;
    			ListDelete(&L,i,&e);
    			printf("%d\n",e);
    		}else if(c=='6'){
    			PrintList(L);
    		}else if(c=='#'){
    			break;
    		}
    	}
    	printf("退出\n"); 
    	return 0;	
    }
    
    
    
    //1.初始化表,建立空表 
    void InitList(SqList *L){
    	L->length = 0;
    } 
    
    //2.查找(按位置查找) 
    int GetElem(SqList L,int i){
    	int j=0;
    	if(L.length==0 || i<1 || i>L.length){
    		return 0;
    	}else{
    		return L.Data[i-1];
    	}
    }
    
    //3.查找(按值查找)
    int LocateElem(SqList L,ElemType e) {
    	int j;
    	for(j=0;j<L.length;j++){
    		if(L.Data[j]==e){       //查找成功,元素值i的位序是第j+1个 
    			return j+1;
    		}
    	}
    	return 0;
    }
    
    //4.插入操作   ( 1<=i<=L.length+1 )
    int ListInsert(SqList *L,int i,ElemType e){
    	if(i<1 || i>L->length+1)
    		return 0;
    	if(L->length>=MAXSIZE)
    		return 0;
    	for(int j=L->length-1;j>=i-1;j--){
    		L->Data[j+1]=L->Data[j];		
    	}
    	L->Data[i-1]=e;    /*插入元素*/
    	L->length++;
    	return 1;
    }
    
    //5.删除操作 (1<=i<=L.length)
    int ListDelete(SqList *L,int i,ElemType *e){  //删除L的第i个元素,并用e返回其值 
    	if(L->length==0){
    		return 0;
    	}
    	if(i<1 || i>L->length){
    		return 0;
    	}
    	*e = L->Data[i-1];		//第i个位置的元素下标为i-1,值赋给 
    	for (int j=i;j<L->length;j++){
    		L->Data[j-1]=L->Data[j];
    	} 
    	L->length--;
    	return 1;
    } 
    
    //6.打印操作
    void PrintList(SqList L){
    	for (int i=0;i<L.length;i++)
    		printf("%d ",L.Data[i]);
    	printf("\n");
    }
    
    
    

    编译运行结果

    展开全文
  • 1.顺序表C语言实现; 2.按较简单的方式实现,主要帮助理解,可在此基础上修改,更加完善; 3.提供几个简单函数,可自行添加功能; 4.可用C++封装,得知STL中vector原理。 顺序表容量。 #define CAPACITY 20...

    顺序表等相关概念请自行查阅资料,这里主要是实现。

    注:

    1.顺序表C语言实现;

    2.按较简单的方式实现,主要帮助理解,可在此基础上修改,更加完善;

    3.提供几个简单函数,可自行添加功能;

    4.可用C++封装,得知STL中vector原理。

     

     顺序表容量。

    #define CAPACITY 20 //容量

    顺序表结构体。

    typedef struct 
    {
        int *m_pHead; //指向数组头
        int m_iSize; //大小
        int m_iCapacity; //容量
    }STABLE;

    部分操作,可自行添加其他操作。

    STABLE* createTable();
    void appendElement(STABLE* pTable, int iElement);
    void insertElement(STABLE* pTable, int iElement, int index);
    void delElement(STABLE* pTable, int index);
    int getAt(STABLE* pTable, int index);
    void setAt(STABLE* pTable, int iElement, int index);
    void showTable(STABLE* pTable);
    void releaseMem(STABLE* pTable);

    分配内存,元素个数为0。

    STABLE* createTable()
    {
        STABLE *pTable = (STABLE*)malloc(sizeof(STABLE));
        if(!pTable)
        {
            printf("动态内存分配失败!\n");
            return pTable;
        }
    
        pTable->m_pHead = (int*)malloc(sizeof(int) * CAPACITY);
        if(!pTable->m_pHead)
        {
            printf("动态内存分配失败!\n");
            return NULL;
        }
    
        pTable->m_iSize = 0;
        pTable->m_iCapacity = CAPACITY;
    
        return pTable;
    }

    追加

    void appendElement(STABLE* pTable, int iElement) 
    {
        if(!pTable || !pTable->m_pHead)
        {
            printf("顺序表不存在!\n");
            return;
        }

        if(pTable->m_iSize == pTable->m_iCapacity)
        {
            printf("顺序表已满!\n"); //可以重新分配内存 这里就不实现了 从简
            return;
        }
        
        pTable->m_pHead[pTable->m_iSize] = iElement;
        pTable->m_iSize++;
    }

    插入

    void insertElement(STABLE* pTable, int iElement, int index)
    {
        if(!pTable || !pTable->m_pHead)
        {
            printf("顺序表不存在!\n");
            return;
        }

        if(pTable->m_iSize == pTable->m_iCapacity)
        {
            printf("顺序表已满!\n"); //可以重新分配内存 这里就不实现了 从简
            return;
        }

        if(index < 0 || index > pTable->m_iSize)
        {
            printf("插入位置不合理!\n");
            return;
        }

        //后移
        for(int i = pTable->m_iSize - 1; i >= index; i--)
        {
            pTable->m_pHead[i+1] = pTable->m_pHead[i];
        }
        pTable->m_pHead[index] = iElement;
        pTable->m_iSize++;
    }

    删除

    void delElement(STABLE* pTable, int index)
    {
        if(!pTable || !pTable->m_pHead)
        {
            printf("顺序表不存在!\n");
            return;
        }
    
        if(pTable->m_iSize < 1)
        {
            printf("顺序表元素个数为0!\n");
            return;
        }
    
        if(index < 0 || index > pTable->m_iSize - 1)
        {
            printf("删除元素位置不合理!\n");
            return;
        }
    
        //前移
        for(int i = index; i < pTable->m_iSize - 1; i++)
        {
            pTable->m_pHead[i] = pTable->m_pHead[i+1];
        }
    
        pTable->m_iSize--;
    }

    获取

    int getAt(STABLE* pTable, int index)
    {
        if(!pTable || !pTable->m_pHead)
        {
            printf("顺序表不存在!\n");
            return -1;
        }
    
        if(index < 0 || index > pTable->m_iSize - 1)
        {
            printf("索引不合理!\n");
            return -1;
        }
    
        return pTable->m_pHead[index];
    }

    修改

    void setAt(STABLE* pTable, int iElement, int index)
    {
        if(!pTable || !pTable->m_pHead)
        {
            printf("顺序表不存在!\n");
            return;
        }
    
        if(index < 0 || index > pTable->m_iSize - 1)
        {
            printf("索引不合理!\n");
            return;
        }
    
        pTable->m_pHead[index] = iElement;
    }

    打印所有元素。

    void showTable(STABLE* pTable)
    {
        if(!pTable || !pTable->m_pHead)
        {
            printf("顺序表不存在!\n");
            return;
        }
    
        printf("容量:%d,大小:%d,打印元素:\n", pTable->m_iCapacity, pTable->m_iSize);
        for(int i = 0; i < pTable->m_iSize; i++)
            printf("%d ", pTable->m_pHead[i]);
    
        printf("\n");
    }

    内存释放。

    void releaseMem(STABLE* pTable)
    {
        if(!pTable)
        {
            printf("顺序表不存在!\n");
            return;
        }
    
        if(pTable->m_pHead)
            free(pTable->m_pHead);
    
        free(pTable);
        printf("内存释放成功!\n");
    }

    转载于:https://www.cnblogs.com/chendong-leslie/p/10189170.html

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

    2020-03-19 22:31:05
    头文件 list.h #define MaxSize 50 //表长度的初始定义 typedef struct{ ... //顺序表的元素 int length; //顺序表的当前长度 }SqList; //顺 序表的类型定义 //初始化 int Initiate(SqList &L) { ...
  • 顺序链表C语言实现

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

    2020-01-24 22:13:49
    #include <stdio.h> #include <stdlib.h> #define LIST_INIT_SIZE 100 #define LISTINCREAMENT 10 typedef int Status;...//定义顺序表类型 typedef struct { ElemType *elem; int ...
  • 顺序表C语言

    2019-06-14 23:21:45
    //顺序表 #include <stdio.h> #include <iostream> #define MAXSIZE 10 typedef int ElementType; typedef struct LNode *SList; struct LNode { ElementType Data[MAXSIZE]; int Last;//线...
  • 顺序表顺序储存结构C语言实现版 #include <stdio.h> #define MAXSIZE 100 #define OVERFLOW 0 #define OK 1 #define ERROR 0 int main(){ } //顺序表顺序储存结构 ,这里泛型定义为整形 typedef struct{ ...
  • 数据结构顺序表c语言

    2020-04-18 14:45:37
    #include <stdio.h> #include <malloc.h> #define MaxSize 100 typedef int ElemType; typedef struct{ ElemType elem[MaxSize];...//定义顺序表结构体 void InitList(SqList &L) {L=(SqL...
  • 实现顺序表的初始化、创建、遍历、查找、插入、删除等算法。 该程序的功能是对元素类型为整型的顺序表进行一些操作。该程序包括顺序表结构类型的定义以及对顺序表操作的具体的函数定义和主函数。 #include "...
  • 线性表-顺序表C语言实现

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

    2018-04-07 22:12:09
    实现涉及到顺序表的增删改查排序。 seqList.h #pragma once typedef int DataType; #define MAX_SIZE 10 typedef struct SeqList { DataType _array[MAX_SIZE]; int _size; // 表示顺序表中有效元素的个数 }...
  • 动态顺序表c语言实现

    2018-04-12 17:37:31
    主要操作结构体中的指针,在init函数里对指针进行内存开辟,checkCapacity...其他操作与静态顺序表无大区别。 seqList.h #pragma once #define DataType int typedef struct seqList { DataType * array; ...
  • 包括链表的正序创建和逆序创建,输出,删除插入一个节点,求链表长度,合并。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,157
精华内容 2,462
关键字:

顺序表c语言

c语言 订阅