数据结构-线性表-顺序表

最新推荐文章于 2024-07-27 16:38:03 发布
最新推荐文章于 2024-07-27 16:38:03 发布
阅读量1.2k 收藏 1
点赞数 2
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dream890527/article/details/10949229
版权 
/*国嵌版的顺序表，主要使用代码复用的原则*/

#ifndef _SEQLIST_H_
#define _SEQLIST_H_

typedef void SeqList;
typedef void SeqListNode;

SeqList* SeqList_Create(int capacity);

void SeqList_Destroy(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);

SeqListNode* SeqList_Get(SeqList* list, int pos);

SeqListNode* SeqList_Delete(SeqList* list, int pos);

#endif


#include "malloc.h"
#include "SeqList.h"

typedef unsigned int TSeqListNode;
typedef struct _tag_SeqList
{
	int capacity; 
	int length;
	TSeqListNode* node;
} TSeqList;

SeqList* SeqList_Create(int capacity)
{
	TSeqList* ret = NULL;
	if( capacity >= 0 ) 
	{
		ret = (TSeqList*)malloc(sizeof(TSeqList)+capacity*sizeof(TSeqListNode));	
	}
	if( ret != NULL )
	{
		ret->capacity = capacity;
		ret->length = 0;
		ret->node = (TSeqListNode*)(ret + 1);
			
	}
    return ret;
}

void SeqList_Destroy(SeqList* list)
{
	free(list);
}

void SeqList_Clear(SeqList* list)
{
	TSeqList* slist = (TSeqList*) list; 
	if( slist != NULL)
	{
		slist->length = 0;
	}
}
int SeqList_Empty(SeqList* list)
{
	TSeqList* slist = (TSeqList*)list;
	int ret = 0;
	if((slist != NULL) && (slist->length ==0))
	{
		ret = 1;	
	}
	return ret;
} 

int SeqList_Length(SeqList* list)
{
	TSeqList* slist = (TSeqList*) list; 
	int ret = -1;
	if( slist != NULL)
	{
		ret = slist->length;
	}
    return ret;
}

int SeqList_Capacity(SeqList* list)
{
	TSeqList* slist = (TSeqList*) list; 
	int ret = -1;
	if( slist != NULL)
	{
		ret = slist->capacity;
	}
    return ret;
}
int SeqList_Insert(SeqList* list, SeqListNode* node, int pos)
{
	TSeqList* slist = (TSeqList*)list;
	int ret = (slist != NULL);
	ret = ret && (slist->length + 1 <= slist->capacity) && (0 <= pos) && (pos <= slist->capacity);
	int i=0;
	if(ret)
	{
		if(pos >= slist->length)
		{
			pos = slist->length;	
		}	
		for(i=slist->length;i>pos;i--)
		{
			slist->node[i] = slist->node[i-1];	
		}
		slist->node[i] = (TSeqListNode)(node);
		slist->length++;
	}
    return ret;
}
/*头插法*/ 
void  SeqList_Insert_Head(SeqList * list, SeqListNode * node)
{
	int i;
	TSeqList* slist = (TSeqList*)list;
	if((list!=NULL) && (node!= NULL))
	{
		for(i = slist->length; i>0;i--)
		{
			slist->node[i] = slist->node[i-1];
		}
		slist->node[0] = (TSeqListNode)node;
		slist->length++;
	}
}
/*尾插法*/
void  SeqList_Insert_End(SeqList * list, SeqListNode * node)  
{
	int i;
	TSeqList* slist = (TSeqList*)list;
	if((list!=NULL) && (node!= NULL) && (slist->length+1<=slist->capacity))
	{
		slist->node[slist->length] = (TSeqListNode)node;
		slist->length++;
	}
}
SeqListNode* SeqList_Get(SeqList* list, int pos)
{
	TSeqList* slist = (TSeqList*)list;
	SeqListNode* ret = NULL;
	if((slist != NULL) && (0 <= pos) && (pos < slist->length))  //pos ±ØÐëСÓÚ length 
	{
		ret = (SeqListNode*)(slist->node[pos]);
	}
    return ret;
}

SeqListNode* SeqList_Delete(SeqList* list, int pos)
{
	TSeqList* slist = (TSeqList*)list;
	SeqListNode* ret = SeqList_Get(list, pos);
	int i =0 ;
	if(ret != NULL)
	{
		for(i=pos+1;i<slist->length;i++)
		{
			slist->node[i-1] = slist->node[i];	
		}
		slist->length--;	
	}
    return ret;
}



 

#include <stdio.h>
#include <stdlib.h>
#include "SeqList.h"

/* run this program using the console pauser or add your own getch, system("pause") or input loop */

int main(int argc, char *argv[]) 
{
    SeqList* list = SeqList_Create(5);
    
    char i = 'a';
    char j = 'b';
    char k = 'c';
    char x = 'd';
    char y = 'e';
    char z = 'f';
    int index = 0;
 #if 0   
    SeqList_Insert(list, &i, 0);
    SeqList_Insert(list, &j, 0);
    SeqList_Insert(list, &k, 0);
    SeqList_Insert(list, &x, 0);
    SeqList_Insert(list, &y, 0);
    SeqList_Insert(list, &z, 0);

    SeqList_Insert_Head(list, &i);
    SeqList_Insert_Head(list, &j);
    SeqList_Insert_Head(list, &k);
    SeqList_Insert_Head(list, &x);
    SeqList_Insert_Head(list, &y);	
  #endif	
    SeqList_Insert_End(list, &i);
    SeqList_Insert_End(list, &j);
    SeqList_Insert_End(list, &k);
    SeqList_Insert_End(list, &x);
    SeqList_Insert_End(list, &y);  
    for(index=0; index<SeqList_Length(list); index++)
    {
        char* p = (char*)SeqList_Get(list, index);
        
        printf("%c\n", *p);
    }
    
    printf("\n");
    
    while( SeqList_Length(list) > 0 )
    {
        char* p = (char*)SeqList_Delete(list, 0);
        
        printf("%c\n", *p);
    }
    printf("\nSeqList is Empty(%d)\n",SeqList_Empty(list));
    SeqList_Destroy(list);
    
    return 0;
}

 

/*大话数据结构版的*/

#include "stdio.h"    

#include "stdlib.h"   
#include "io.h"  
#include "math.h"  
#include "time.h"

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define EXIT 1
#define UNEXIT 0
#define MAXSIZE 20 /* 存储空间初始分配量 */

typedef int Status;          /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int ElemType;        /* ElemType类型根据实际情况而定，这里假设为int */


Status visit(ElemType c)
{
    printf("%d ",c);
    return OK;
}

typedef struct
{
	ElemType data[MAXSIZE];        /* 数组，存储数据元素 */
	int length;                                /* 线性表当前长度 */
}SqList;

/* 初始化顺序线性表 */
Status InitList(SqList *L) 
{ 
    L->length=0;
    return OK;
}

/* 初始条件：顺序线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE */
Status ListEmpty(SqList L)
{ 
	if(L.length==0)
		return TRUE;
	else
		return FALSE;
}

/* 初始条件：顺序线性表L已存在。操作结果：将L重置为空表 */
Status ClearList(SqList *L)
{ 
    L->length=0;
    return OK;
}

/* 初始条件：顺序线性表L已存在。操作结果：返回L中数据元素个数 */
int ListLength(SqList L)
{
	return L.length;
}

/* 初始条件：顺序线性表L已存在，0≤i<listLength(L) */
/* 操作结果：用e返回L中第i个数据元素的值,注意i是指位置，第1个位置的数组是从0开始 */
Status GetElem(SqList L,int pos,ElemType *e)
{
    if(pos>=0 && pos<L.length)
    	*e=L.data[pos];
    return OK;
}

/* 初始条件：顺序线性表L已存在 */
/* 操作结果：返回L中第1个与e满足关系的数据元素的位序。 */
/* 若这样的数据元素不存在，则返回值为0 */
int LocateElem(SqList L,ElemType e)
{
    int i;
    for(i=0;i<L.length;i++)
    {
            if (L.data[i]==e)
                    return EXIT;
    }
    return UNEXIT;
}


/* 初始条件：顺序线性表L已存在,0≤i≤ListLength(L)， */
/* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
Status ListInsert(SqList *L,int pos,ElemType e)
{ 
	int k;
	if(L!= NULL && L->length + 1<=MAXSIZE && pos>=0 && pos<MAXSIZE)
	{
		if(pos>=L->length)
		{
			pos = L->length;
		}
		for(k = L->length-1; k>=pos; k--)
		{
			L->data[k+1] = L->data[k];
		}
		L->data[pos] = e;
		L->length++;
		return OK;
	}
	return ERROR;
}
/* 初始条件：顺序线性表L已存在，0≤i<ListLength(L) */
/* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度? */
Status ListDelete(SqList *L,int pos,ElemType *e) 
{ ;
	int k;
	if(L!= NULL && e!= NULL && pos>=0 && pos<L->length)
	{
		*e = L->data[pos];
		for(k = pos+1; k< L->length; k++)
		{
			L->data[k-1] = L->data[k];
		}
		L->length--;
		return OK;
	}
    return ERROR;
}

/* 初始条件：顺序线性表L已存在 */
/* 操作结果：依次对L的每个数据元素输出 */
Status ListTraverse(SqList L)
{
	int i;
    for(i=0;i<L.length;i++)
        visit(L.data[i]);
    printf("\n");
    return OK;
}

void unionL(SqList *La,SqList Lb)
{
	int La_len,Lb_len,i;
	ElemType e;
	La_len=ListLength(*La);
	Lb_len=ListLength(Lb);
	for (i=0;i<Lb_len;i++)
	{
		GetElem(Lb,i,&e);
		if (!LocateElem(*La,e))
			ListInsert(La,La_len++,e);
	}
}

int main()
{
        
    SqList L;
    ElemType e;
    Status i;
    int j,k;
    i=InitList(&L);
    printf("初始化L后：L.length=%d\n",L.length);
    for(j=1;j<=5;j++)
        i=ListInsert(&L,0,j);
    printf("在L的表头依次插入1～5后：L.data=");
    ListTraverse(L); 

    printf("L.length=%d \n",L.length);
    i=ListEmpty(L);
    printf("L是否空：i=%d(1:是 0:否)\n",i);

    i=ClearList(&L);
    printf("清空L后：L.length=%d\n",L.length);
    i=ListEmpty(L);
    printf("L是否空：i=%d(1:是 0:否)\n",i);

    for(j=1;j<=10;j++)
        ListInsert(&L,j-1,j);
    printf("在L的表尾依次插入1～10后：L.data=");
    ListTraverse(L); 

    printf("L.length=%d \n",L.length);

    ListInsert(&L,0,0);
    printf("在L的表头插入0后：L.data=");
    ListTraverse(L); 
    printf("L.length=%d \n",L.length);

    GetElem(L,5,&e);
    printf("第5个元素的值为：%d\n",e);
    for(j=3;j<=4;j++)
    {
            k=LocateElem(L,j);
            if(k)
                    printf("第%d个元素的值为%d\n",k,j);
            else
                    printf("没有值为%d的元素\n",j);
    }
    

    k=ListLength(L); /* k为表长 */
    for(j=k+1;j>=k;j--)
    {
            i=ListDelete(&L,j,&e); /* 删除第j个数据 */
            if(i==ERROR)
                    printf("删除第%d个数据失败\n",j);
            else
                    printf("删除第%d个的元素值为：%d\n",j,e);
    }
    printf("依次输出L的元素：");
    ListTraverse(L); 

    j=5;
    ListDelete(&L,j,&e); /* 删除第5个数据 */
    printf("删除第%d个的元素值为：%d\n",j,e);

    printf("依次输出L的元素：");
    ListTraverse(L); 

	//构造一个有10个数的Lb
	SqList Lb;
    i=InitList(&Lb);
    for(j=6;j<=15;j++)
            i=ListInsert(&Lb,0,j);

     printf("依次输出Lb的元素：");
    ListTraverse(Lb); 
	
	unionL(&L,Lb);

	printf("依次输出合并了Lb的L的元素：");
    ListTraverse(L); 

    return 0;
}



 

 

 


                

        

        

    

  


    

      

        

            

              
                
                  dream890527
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
线性表的顺序存储

				
			

			

				

					m0_56860190的博客
				

				

					07-10
					
					1230
					
				

			

		

		

			
				
顺序表的定义
用一组地址连续的存储单元依次存储线性表的每个数据元素，这种存储结构称为线性表的顺序存储结构，用这种结构表达是线性表称为顺序表。
顺序表的特点
用数据元素在计算机内物理位置相邻来表示线性表中数据元素之间的逻辑关系。
顺序表的存储位置
顺序表中第 i 个数据元素ai的存储位置：
LOC(ai)=LOC(a1) + ( i - 1 ) x m
其中，LOC(a1)为顺序表的首地址；m为顺序表中一个数据元素占用的存储空间。
顺序表为随机存储结构（读取数据元素所需要的时间与其所在的位置无关）。
顺序存储

			
		

	



                

              
                



	

		

			

				
					
01线性表顺序存储_List

				
			

			

				

					AKK188888881的博客
				

				

					10-05
					
					508
					
				

			

		

		

			
				
#include<stdio.h>

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 20 /* 存储空间初始分配量 */

typedef int Status;          /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int ElemType;        /* ElemType类型根据实际情况而定，这里假设为int */


Stat

			
		

	



                


  
              

                


	

		

			

				
					
顺序存储的线性表

				
			

			

				

					朱胜本的专栏
				

				

					09-01
					
					146
					
				

			

		

		

			
				
/*
 * 顺序存储的线性表
 */
#include &lt;stdio.h&gt;

#define OK 1
#define ERR 0

#define LIST_INIT_SIZE 100
#define LIST_INCREMENT 10
#define ElemType char

typedef struct {
    ElemType *elem;
    int length...

			
		

	





	

		

			

				
					
线性表之顺序存储

				
			

			

				

					qq_48639334的博客
				

				

					07-31
					
					671
					
				

			

		

		

			
				
线性表之顺序存储的C语言实现，包含简单人机交互的功能设计。

			
		

	



		

			
		



	

		

			

				
					
2.C-数据结构-线性表-顺序表源码

				
			

			

				

					08-30
				

			

		

		

			
				
2.C-数据结构-线性表-顺序表源码

			
		

	





	

		

			

				
					
c/c++数据结构-线性表-顺序表

				
			

			

				

					04-26
				

			

		

		

			
				
数据结构实验中线性表的顺序表代码，带有详细注释，小白也能看得懂

			
		

	





	

		

			

				
					
数据结构学习--线性表及其应用--顺序表

				
			

			

				

					06-25
				

			

		

		

			
				
通过这样的实验，学习者能够更好地理解顺序表的特性和基本操作，为后续学习更复杂的数据结构如树、图等打下坚实的基础。同时，对顺序存储结构的熟悉也有助于提升对数组、指针等基础知识的运用能力。在实际编程中，...

			
		

	





	

		

			

				
					
2.C-数据结构-线性表-链表源码

					
最新发布

				
			

			

				

					09-07
				

			

		

		

			
				
2.C-数据结构-线性表-顺序表源码

			
		

	





	

		

			

				
					
线性表的顺序存储 线性表的顺序存储

				
			

			

				

					11-30
				

			

		

		

			
				
线性表的顺序存储，此程序主要实现线性表的顺序存储，有C++语言实现，还是比较轻易看得懂的！

			
		

	





	

		

			

				
					
【数据结构】线性表的顺序存储

				
			

			

				

					DAY I 的成长之路
				

				

					04-24
					
					4174
					
				

			

		

		

			
				
💯线性表是具有相同类型的数据类型的n个数据元素的有限序列，其中n为表长，n0n=0n0时为空表ege.geg这里要注意的是，定义中描述的为数据元素，而非数据项，也就是，存储单元可以是一个结构体，而数据项为里面的成员✨线性表的特点：表中元素的个数为有限个表中元素具有逻辑上的顺序性，表中元素有其先后顺序表中元素都是数据元素，每一个元素都为单个元素表中元素的数据类型都相同，每个元素占相同的内存空间表中元素具有抽象性，即仅讨论元素之间的逻辑关系，而不考虑具体实现方式🔑。

			
		

	





	

		

			

				
					
数据结构（三） — 线性表之顺序存储

				
			

			

				

					WOLF
				

				

					03-18
					
					439
					
				

			

		

		

			
				
1



			
		

	





	

		

			

				
					
顺序表——线性表的顺序存储

				
			

			

				

					weixin_65477256的博客
				

				

					07-27
					
					660
					
				

			

		

		

			
				
线性表中的数据元素在内存中存储方式包含两种存储方式：顺序存储结构：​		所谓的顺序存储结构，指的是在内存中开辟连续存储空间，并将线性表中的元素按照存储位置序号连续存储。此时所构成的线性表称为顺序表。​		类似于C语言程序中的数组，不同于数组的时候，需要保证元素连续存储。链式存储结构：​		所谓的链式存储结构，指的是采用非连续存储空间存储线性表中的所有数据元素，其中每一个数据元素需要存储当前元素的数据内容和后继数据元素存储空间的地址。可以通过数据元素存储空间的地址表示数据元素的逻辑关系。

			
		

	





	

		

			

				
					
线性表顺序存储

				
			

			

				

					lxxxxxl的博客
				

				

					07-15
					
					218
					
				

			

		

		

			
				

时间复杂度效率


O(1) &gt; O(logn) &gt; O(n) &gt; O(nlogn) &gt; O(n^2) &gt; O(n^3) &gt; O(2^n) &gt; O(n!) &gt; O(n^n) 


线性表顺序存储



// 线性表----顺序存储 
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;

#defin...

			
		

	





	

		

			

				
					

				
			

			

				

					
				

			

		

		

			
				

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		
评论 1

	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值