顺序表_顺序表c语言 - CSDN
顺序表 订阅
顺序表是在计算机内存中以数组的形式保存的线性表,线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中,即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系,采用顺序存储结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。 [1] 展开全文
顺序表是在计算机内存中以数组的形式保存的线性表,线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中,即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系,采用顺序存储结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。 [1]
信息
结    构
存储结构
外文名
Contiguous List
中文名
顺序表
形    式
数组
顺序表简介
将表中元素一个接一个的存入一组连续的存储单元中,这种存储结构是顺序结构。采用顺序存储结构的线性表简称为“ 顺序表”。顺序表的存储特点是:只要确定了起始位置,表中任一元素的地址都通过下列公式得到:LOC(ai)=LOC(a1)+(i-1)*L  1≤i≤n 其中,L是元素占用存储单元的长度。顺序表的结构定义:#define maxlen 50 //定义顺序表中元素个数最多有几个 typedef struct{elementtype data[maxlen]; //elementtype是元素的类型 依具体情况而定int listlen; //便于时刻了解顺序表里元素的个数}seqlist; //顺序表的名称 不妨为seqlist声明顺序表类型变量:seqlist L,L1;如顺序表的每个结点占用len个内存单元,用location (ki)表示顺序表中第i个结点ki所占内存空间的第1个单元的地址。则有如下的关系:location (ki+1) = location (ki) +lenlocation (ki) = location(k1) + (i-1)len存储结构要体现数据的逻辑结构,顺序表的存储结构中,内存中物理地址相邻的结点一定具有顺序表中的逻辑关系。 [2] 
收起全文
精华内容
参与话题
  • 【数据结构】顺序表

    千次阅读 多人点赞 2019-01-17 19:23:40
    顺序表示一种最为简单的线性结构,可以分为两种,一种是静态顺序表,一种是动态顺序表 1)静态顺序表 所谓静态顺序表是指一旦定义了该表,其大小始终固定不变,函数调用时,静态顺序表在函数栈上开辟空间,我们熟悉...

    顺序表示一种最为简单的线性结构,可以分为两种,一种是静态顺序表,一种是动态顺序表
    1)静态顺序表

    所谓静态顺序表是指一旦定义了该表,其大小始终固定不变,函数调用时,静态顺序表在函数栈上开辟空间,我们熟悉的数组就是一种静态顺序表

    e.g

      #definde MAXSIZE 100
      ElemType Sqlist[MAXSIZE];
      int len;
    
    

    2)动态顺序表

    所谓动态顺序表是一种更为灵活的顺序表,它创建在内存的动态存储区,也就是创建在堆内存,因此其长度是可以变化的

    e.g

    #define MAXSIZE 10
    #define INCREMENTSIZE 10
    typedef struct{
    	ElemType *elem;
    	int length;
    	int listsize;
    	int incrementsize;
    }Sqlist;
    
    1. 向顺序表中插入第i个位置插入元素
    //向顺序表第i个位置插入元素 
    int InsertElem(Sqlist *L,int i, int item){
    	//向顺序表L第i个位置插入元素item 
    	int *base, *intserPtr, *p;
    	//非法插入 
    	if(i < 1 || i > L->length+1){
    		return 0;
    	}	
    	
    	if(L->length >= L->listsize){
    		//重新追加空间 
    		base = (int*)realloc(L->elem,(L->incrementsize+L->listsize)*sizeof(int));
    		if(base == NULL) return 0;
    		//更新内存基地址 
    		L->elem = base;
    		L->listsize += L->incrementsize;
    	}
    	//插入的位置 
    	intserPtr = &(L->elem[i-1]);
    	//将i-1后的元素顺序后移一个元素的位置 
    	for(p = &(L->elem[L->length-1]); p >= intserPtr; p--){
    		*(p+1) = *p;
    	}	
    	
    	*intserPtr = item;
    	L->length++;
    	return 1;
    }
    
    1. 编程实现顺序表的逆置
    //顺序表的逆置
    void reverseSqlist(Sqlist *L){
    	int buf;
    	int low = 0;
    	int high = L->length-1;
    	
    	while(low < high){
    		buf = L->elem[low];
    		L->elem[low] = L->elem[high];
    		L->elem[high] = buf;	
    		low++;
    		high--;	
    	}	
    }
    
    1. 编程实现删除顺序表中的重复元素
    //删除顺序表的重复元素 
    void purge(Sqlist * L){
    	int i,j;
    	for(i = 0;i < L->length;i++){
    		if(L->elem[i] != FLAG){
    			for(j = i+1;j < L->length; j++){
    				if(L->elem[j] == L->elem[i]){
    					L->elem[j] = FLAG;
    				}
    			}
    		}
    	}
    
    	for(i = 0;L->elem[i] != FLAG; i++);
    	for(j = i+1;j < L->length;){
    		if(L->elem[j] != FLAG){
    			L->elem[i++] = L->elem[j++];
    		
    		}else{
    			j++;
    		}
    	}
    	L->length = i;
    } 
    
    1. 顺序表元素两两绝对值的最小值

    有一个整数数组,求出两两绝对值的最小值,要求:只要求出最小值即可,不需要求出是哪两个数

    //顺序表元素两两之差绝对值的最小值
    int getMinDifference(Sqlist *L){
    	int Min = 100;
    	for(int rank = 0;rank < L->length; rank++)
    		for(int row = rank +1;row < L->length;row++){
    		    int buf = abs(L->elem[row] - L->elem[rank]);
    			if( buf < Min){
    				Min = buf; 
    			}  
    		}
    	return Min;
    } 
    
    1. 重新排列使得顺序表左边为奇数,右边为偶数

    要求:空间复杂度为O(1),时间复杂度为O(n)

    //重新排列使得顺序表左边为奇数,右边为偶数
    int reArrange(Sqlist *L){
    	int low = 0,high = L->length;
    
    	while(true){
    		while(L->elem[low] % 2 != 0 ) {
    		low++;			
    		}
    		while(L->elem[high] % 2 == 0) {
    			high--;			
    		}
    		if(low < high){
    			int temp = L->elem[low];
    			L->elem[low] = L->elem[high];
    			L->elem[high] = temp;
    			low++;
    			high--;
    		}else{
    			return 1;
    		}
    
    	}
    	return 1;
    } 
    
    1. 重新排列使得顺序表左边为奇数,右边为偶数且不改变原数据在顺序表中的先后顺序
    int ReArrange(Sqlist *L){
    	int i,j;
    	//找到第一个偶数 
    	for( i = 0;i < L->length;i++) {
    		if(L->elem[i] % 2 == 0) break;
    	} 
    	for(int j = i + 1;j < L->length; j++){
    		if(L->elem[j] % 2 != 0){
    			int temp = L->elem[j];
    			for(int k = j;k > i;k--){
    				L->elem[k] = L->elem[k-1]; 
    			}
    			L->elem[i] = temp;
    			i++;
    		}
    	}
    	return 1;
    } 
    
    

    C/C++完整代码

    #include<iostream>
    #include<stdio.h>
    #include<stdlib.h>
    #include<assert.h>
    using namespace std;
    #define MAXSIZE 10
    #define INCREMENTSIZE 10
    #define FLAG -1
    typedef struct{
    	int *elem;
    	int length;
    	int listsize;
    	int incrementsize;
    }Sqlist;
    //创建空顺序表 
    int Init(Sqlist *L){
    	
    	L->listsize = MAXSIZE;
    	L->incrementsize = INCREMENTSIZE;
    	L->elem = (int *)malloc(sizeof(int)*L->listsize);	
    	L->length = 0;
    	
    }
    //打印顺序表 
    int Print(Sqlist *L){
    	if(L->length == 0){
            printf("NULL\n");
        }
        
        for(int i = 0; i < L->length; i++){
            printf("%d  ", L->elem[i]);
        }
         printf("\n\n");
    
    }
    //向顺序表第i个位置插入元素 
    int InsertElem(Sqlist *L,int i, int item){
    	//向顺序表L第i个位置插入元素item 
    	int *base, *intserPtr, *p;
    	//非法插入 
    	if(i < 1 || i > L->length+1){
    		return 0;
    	}	
    	
    	if(L->length >= L->listsize){
    		//重新追加空间 
    		base = (int*)realloc(L->elem,(L->incrementsize+L->listsize)*sizeof(int));
    		if(base == NULL) return 0;
    		//更新内存基地址 
    		L->elem = base;
    		L->listsize += L->incrementsize;
    	}
    	//插入的位置 
    	intserPtr = &(L->elem[i-1]);
    	//将i-1后的元素顺序后移一个元素的位置 
    	for(p = &(L->elem[L->length-1]); p >= intserPtr; p--){
    		*(p+1) = *p;
    	}	
    	
    	*intserPtr = item;
    	L->length++;
    	return 1;
    }
    //顺序表的逆置
    void reverseSqlist(Sqlist *L){
    	int buf;
    	int low = 0;
    	int high = L->length-1;
    	
    	while(low < high){
    		buf = L->elem[low];
    		L->elem[low] = L->elem[high];
    		L->elem[high] = buf;	
    		low++;
    		high--;	
    	}	
    }
    //顺序表的删除操作
    int DelElem(Sqlist *L,int index){
    	if(index < 0 || index > L->length) return 0;
    	for(int i = 0;i < L->length-1; i++){
    		if(i == index){
    			L->elem[i] = L->elem[i+1]; 
    		}
    	}
    	L->length--;
    	return 1;
    } 
    //删除顺序表的重复元素 
    void purge(Sqlist * L){
    	int i,j;
    	for(i = 0;i < L->length;i++){
    		if(L->elem[i] != FLAG){
    			for(j = i+1;j < L->length; j++){
    				if(L->elem[j] == L->elem[i]){
    					L->elem[j] = FLAG;
    				}
    			}
    		}
    	}
    
    	for(i = 0;L->elem[i] != FLAG; i++);
    	for(j = i+1;j < L->length;){
    		if(L->elem[j] != FLAG){
    			L->elem[i++] = L->elem[j++];
    		
    		}else{
    			j++;
    		}
    	}
    	L->length = i;
    } 
    //顺序表元素两两之差绝对值的最小值
    int getMinDifference(Sqlist *L){
    	int Min = 100;
    	for(int rank = 0;rank < L->length; rank++)
    		for(int row = rank +1;row < L->length;row++){
    		    int buf = abs(L->elem[row] - L->elem[rank]);
    			if( buf < Min){
    				Min = buf; 
    			}  
    		}
    	return Min;
    } 
    //重新排列使得顺序表左边为奇数,右边为偶数
    int reArrange(Sqlist *L){
    	int low = 0,high = L->length;
    
    	while(true){
    		while(L->elem[low] % 2 != 0 ) {
    		low++;			
    		}
    		while(L->elem[high] % 2 == 0) {
    			high--;			
    		}
    		if(low < high){
    			int temp = L->elem[low];
    			L->elem[low] = L->elem[high];
    			L->elem[high] = temp;
    			low++;
    			high--;
    		}else{
    			return 1;
    		}
    
    	}
    	return 1;
    } 
    //重新排列使得顺序表左边为奇数,右边为偶数且不改变数据在顺序表中的先后顺序
    int ReArrange(Sqlist *L){
    	int i,j;
    	//找到第一个偶数 
    	for( i = 0;i < L->length;i++) {
    		if(L->elem[i] % 2 == 0) break;
    	} 
    	for(int j = i + 1;j < L->length; j++){
    		if(L->elem[j] % 2 != 0){
    			int temp = L->elem[j];
    			for(int k = j;k > i;k--){
    				L->elem[k] = L->elem[k-1]; 
    			}
    			L->elem[i] = temp;
    			i++;
    		}
    	}
    	return 1;
    } 
    
    //Test
    int main() {
    	Sqlist *L = new Sqlist;	
    	Sqlist *Q = new Sqlist;
    	//创建顺序表 
    	Init(L); 
    	Init(Q); 
    	//初始化顺序表 
    	for(int i = 1; i <= 15; i++){
    		if(i % 2 == 0) {
    		 InsertElem(L,i,i);
    		}else{
    			InsertElem(L,i,5);
    		}
    	}
    	
    	for(int i = 1; i <= 10; i++){	
    		 InsertElem(Q,i,i);	
    	}
    	
    	//打印顺序表 
    	printf("顺序表:\n");
    	Print(L);
    	
    	//顺序表的逆置
    	reverseSqlist(L); 
    	
    	//打印逆置后的顺序表
    	printf("逆置后的顺序表:\n");  
    	Print(L);
    	
    	//删除重复元素
    	purge(L);
    	//打印删除重复元素后的顺序表
    	printf("删除重复元素后的顺序表:\n");  
    	Print(L);
    	
    	printf("顺序表元素两两之差绝对值的最小值:"); 
    	cout<<getMinDifference(L)<<endl<<endl;
    	
    	//重新排列使得顺序表左边为奇数,右边为偶数
    	/*reArrange(Q);
    	printf("重新排列使得顺序表左边为奇数,右边为偶数:\n");  
    	Print(Q);*/
    	//重新排列使得顺序表左边为奇数,右边为偶数且不改变数据在顺序表中的先后顺序
    	printf("重新排列使得顺序表左边为奇数,右边为偶数且不改变数据在顺序表中的先后顺序:\n"); 
    	Print(Q);
    	ReArrange(Q); 
    	Print(Q);
    	cout<<"动态顺序表的长度:"<<L->length<<endl;
    	cout<<"动态顺序表所占的空间大小:"<<L->listsize<<endl; 
    	delete L;
    	delete Q; 
    	return 0;
    }
    
    展开全文
  • 数据结构:顺序表的基本操作

    万次阅读 多人点赞 2018-05-04 12:01:53
    顺序表的线性存储示意图 C语言定义线性表的顺序存储结构 线性表的顺序存储  线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素,使得线性表在逻辑结构上相邻的元素存储在连续...

    线性表的顺序存储

           线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素,使得线性表在逻辑结构上相邻的元素存储在连续的物理存储单元中,即:通过数据元素物理存储的连续性来反应元素之间逻辑上的相邻关系。采用顺序存储结构存储的线性表通常简称为顺序表。
           顺序存储的线性表的特点:
    ◆ 线性表的逻辑顺序与物理顺序一致;
    ◆ 数据元素之间的关系是以元素在计算机内“物理位置相邻”来体现。


    顺序表的线性存储示意图

    这里写图片描述
           假设线性表中有n个元素,每个元素占k个存储单元,第一个元素的地址为Loc(a1),则第i个元素的地址Loc(ai):

           Loc(ai) = Loc(a1) + (i-1) * k;
    其中Loc(a1)称为基地址。


    C语言定义线性表的顺序存储结构
    #define ListSize 100      //线性表的最大长度
    typedef int DataType;
    
    typedef struct
    {
        DataType data[ListSize];   //用数组存储线性表中的元素
        DataType length;           //顺序表中元素的个数
    }SeqList, *PSeqList;
    

           DataType是数据元素类型,可以根据需要定义,可以使用SeqList定义数据表类型变量,使用*PSeqList定义数据表指针变量;


    顺序表的基本操作

    (1) 顺序表的初始化

           顺序表的初始化就是把顺序表 初始化为空的顺序表;只需把顺序表的长度length置为0即可;

    void InitList(PSeqList L)
    {
        if (L == NULL)
        {
            return;
        }
        L->length = 0;
    }

    (2)求顺序表的长度

           顺序表的长度就是就顺序表中的元素的个数,由于在插入和删除操作中都有对数据表的长度进行修改,所以求表长只需返回length的值即可;

    int LengthList(PSeqList L)
    {
        if (L == NULL)
        {
            return 0;
        }
        return L->length;
    }

    (3)按序号查找
           查找顺序表中第i个元素的值(按序号查找),如果找到,将将该元素值赋给e。查找第i个元素的值时,首先要判断查找的序号是否合法,如果合法,返回第i个元素对应的值。

    int GetData(PSeqList L, int i)
    {
        if (L->length < 1 || (L->length > LengthList(L)))
        {
            return 0;
        }
        //数据元素的序号从1开始,数组下表从0开始,第i个元素对应的数组下标为i-1;
        return L->data[i - 1];
    }

    (4)插入操作
           在数据表的第i个位置插入元素,在顺序表的第i个位置插入元素e,首先将顺序表第i个位置的元素依次向后移动一个位置,然后将元素e插入第i个位置,移动元素要从后往前移动元素,即:先移动最后一个元素,在移动倒数第二个元素,依次类推;插入元素之前要判断插入的位置是否合法,顺序表是否已满,在插入元素之后要将表长L->length++;

    int InsList(PSeqList L, int i, DataType e)
    {
    
        //判断插入位置是否合法
        if (i < 1 || L->length >(LengthList(L) + 1))
        {
            printf("插入位置不合法!\n");
            return 0;
        }
        //判断顺序表是否已满
        else if (L->length >= ListSize)
        {
            printf("顺序表已满,不能插入!\n");
            return 0;
        }
        else
        {
            for (k = i; k <= L->length; k--)
            {
                L->data[k + 1] = L->data[k];
            }
            L->data[i - 1] = e;
            L->length++;   //数据表的长度加1
            return 1;
        }
        return 0;
    }

    (5) 删除操作

           删除表中的第i个元素e,删除数据表中的第i个元素,需要将表中第i个元素之后的元素依次向前移动一位,将前面的元素覆盖掉。移动元素时要想将第i+1个元素移动到第i个位置,在将第i+2个元素移动i+1的位置,直到将最后一个元素移动到它的前一个位置,进行删除操作之前要判断顺序表是否为空,删除元素之后,将表长L->length--;

    int DelList(PSeqList L, DataType i, DataType* e)
    {
        if (L->length < 1)
        {
            printf("表为空!\n");
            return  0;
        }
        *e = L->data[i - 1];
        for (k = i; k < L->length; k++)
        {
            L->data[k - 1] = L->data[k];
        }
        L->length--;
        return *e;
    }
    

    (6)按内容查找

           查找数据元素e在表中的位置,可以从表头开始一直遍历表中元素,如果找到与要查找元素e相等的元素,则返回元素在表中的位置,数组下标从0开始,则元素在表中对应的位置序号值应为对应数组下标加1,没有找到则返回0;

    int Locate(PSeqList L, DataType e)
    {
        for (k = 0; k < L->length; k++)
        {
            if (L->data[k] == e)
            {
                //k为e对应的数组下标,在表中对应序号应为k+1
                return k + 1;
            }
        }
        return 0;
    }
    

    (7)头插

           头插,即在表头插入元素e,在表头插入元素,需要将表中的元素依次后移一位,然后将要插入的元素e赋给数字的首元素,执行插入操作后将表长L->length++;需要注意的是移动元素要从顺序表的最后一个元素开始移动,如果从第1个元素开始移动,会使得第1个元素的值覆盖第2个元素的值,然后把第二个元素后移则会使第2个元素的值(原来第1个元素值)覆盖第3个元素的值,依次类推,最后出插入元素外,其余元素值均为原顺序表中第一个元素的值。

    void PushFront(PSeqList L, DataType e)
    {
        if (L->length == ListSize)
        {
            printf("顺序表已满,不能插入!\n");
        }
        //将表中元素依次后移一位
        for (k = L->length; k > 0; k--)
        {
            L->data[k] = L->data[k - 1];
        }
        //插入元素
        L->data[0] = e;
        L->length++;
    }

    (8)头删

           删除顺序表中的第一个元素,只要将顺序表中的元素从第2个开始,依次向前移动1位,覆盖原来顺序表中元素对应位置的前一个值,在删除元素之前要判断顺序表是否为空,删除顺序表元素之后将顺序表长度L->length--;

    void PopFront(PSeqList L)
    {
        if (EmptyList(L))
        {
            printf("顺序表为空\n");
        }
        for (k = 1; k <= L->length - 1; k++)
        {
            L->data[k - 1] = L->data[k];
        }
        L->length--;
    }

    (9)尾插

           在顺序表表尾插入元素e,L->data[L->length] = e;将元素e的值赋给顺序表中最后一个元素的下一个元素;尾插操作,需要判断顺序表是否已满,尾插后将顺序表长度L->length++;

    void PushBack(PSeqList L, DataType e)
    {
        if (L->length == ListSize)
        {
            printf("顺序表已满,不能插入!\n");
        }
        L->data[L->length] = e;
        L->length++;
    }

    (10) 尾删

           删除表尾元素,只需将顺序表的长度减1,类似于出栈操作,栈顶指针top –。

    void PopBack(PSeqList L)
    {
        if (EmptyList(L))
        {
            printf("表为空!\n");
        }
        L->length--;
    
    }

    (11) 清空顺序表

           清空顺序表就是将表中的元素删除。删除表中的元素只需将表的长度置为0。

    void ClearList(PSeqList L)
    {
        L->length = 0;
    }

    (12)判断表是否为空

           如果顺序表的长度为0,则顺序表为空,返回1,否则,返回0;

    int EmptyList(PSeqList L)
    {
        if (L->length == 0)
        {
            return 1;
        }
        return 0;
    }

    (13)打印表中元素

           依次打印顺序表中的元素,如果顺序表为空则输出提示。

    void PrintList(PSeqList L)
    {
        if (EmptyList(L))
        {
            printf("表为空!\n");
            return;
        }
        for (k = 0; k < L->length; k++)
        {
            printf("%-3d", L->data[k]);
        }
        printf("\n");
    }
    顺序表的基础操作完整代码

    SeqList.h数据结构的定义和基本操作函数声明

    #pragma once
    
    #define ListSize 100      //线性表的最大长度
    typedef int DataType;
    
    typedef struct
    {
        DataType data[ListSize];   //用数组存储线性表中的元素
        DataType length;           //顺序表的长度
    }SeqList, *PSeqList;
    
    void InitList(PSeqList L);  //顺序表的初始化操作
    int LengthList(PSeqList L); //求顺序表的长度
    int GetData(PSeqList L, int i); //返回数据表中第i个元素的值
    int InsList(PSeqList L, int i, DataType e);   //在顺序表的第i个位置插入元素
    int DelList(PSeqList L, DataType i, DataType* e); //删除顺序表L的第i个数据元素
    int Locate(PSeqList L, DataType e); //查找数据元素e在表中的位置
    void PushFront(PSeqList L, DataType e); //头插,在表头插入元素e
    void PopFront(PSeqList L);    //头删,删除表中的第一个元素
    void PushBack(PSeqList L, DataType e);  //尾插,在表尾插入元素e
    void PopBack(PSeqList L); //尾删,删除表尾元素
    void ClearList(PSeqList L);  //清空顺序表
    int EmptyList(PSeqList L);   //判断顺序表是否为空
    void PrintList(PSeqList L);  //打印表中元素
    

    SeqList.c 函数的具体实现

    #include <stdio.h>
    #include "SeqList.h"
    
    int k = 0;  //全局变量,用于作部分操作的循环变量
    //初始化顺序表
    void InitList(PSeqList L)
    {
        if (L == NULL)
        {
            return;
        }
        L->length = 0;
    }
    
    //求顺序表的长度
    
    int LengthList(PSeqList L)
    {
        if (L == NULL)
        {
            return 0;
        }
        return L->length;
    }
    
    //返回数据表中第i个元素的值
    int GetData(PSeqList L, int i)
    {
        if (L->length < 1 || (L->length > LengthList(L)))
        {
            return 0;
        }
        //数据元素的序号从1开始,数组下表从0开始,第i个元素对应的数组下标为i-1;
        return L->data[i - 1];
    }
    
    //在L中第i个位置,插入新的数据元素e
    
    int InsList(PSeqList L, int i, DataType e)
    {
    
        //判断插入位置是否合法
        if (i < 1 || L->length >(LengthList(L) + 1))
        {
            printf("插入位置不合法!\n");
            return 0;
        }
        //判断顺序表是否已满
        else if (L->length >= ListSize)
        {
            printf("顺序表已满,不能插入!\n");
            return 0;
        }
        else
        {
            for (k = i; k <= L->length; k--)
            {
                L->data[k + 1] = L->data[k];
            }
            L->data[i - 1] = e;
            L->length++;   //数据表的长度加1
            return 1;
        }
        return 0;
    }
    
    //删除L的第i个数据元素
    
    int DelList(PSeqList L, DataType i, DataType* e)
    {
        if (L->length < 1)
        {
            printf("表为空!\n");
            return  0;
        }
        *e = L->data[i - 1];
        for (k = i; k < L->length; k++)
        {
            L->data[k - 1] = L->data[k];
        }
        L->length--;
        return *e;
    }
    
    //查找e在表中的位置
    
    int Locate(PSeqList L, DataType e)
    {
        for (k = 0; k < L->length; k++)
        {
            if (L->data[k] == e)
            {
                //k为e对应的数组下标,在表中对应序号应为k+1
                return k + 1;
            }
        }
        return 0;
    }
    
    //头插,在表头插入元素e
    
    void PushFront(PSeqList L, DataType e)
    {
        if (L->length == ListSize)
        {
            printf("顺序表已满,不能插入!\n");
        }
        //将表中元素依次后移一位
        for (k = L->length; k > 0; k--)
        {
            L->data[k] = L->data[k - 1];
        }
        //插入元素
        L->data[0] = e;
        L->length++;
    }
    
    //头删,删除顺序表中的第一个元素,把顺序表中的元素依次往前移动一位
    
    void PopFront(PSeqList L)
    {
        if (EmptyList(L))
        {
            printf("顺序表为空,不能插入!\n");
        }
        for (k = 1; k <= L->length - 1; k++)
        {
            L->data[k - 1] = L->data[k];
        }
        L->length--;
    }
    
    //尾插
    void PushBack(PSeqList L, DataType e)
    {
        if (L->length == ListSize)
        {
            printf("顺序表已满,不能插入!\n");
        }
        L->data[L->length] = e;
        L->length++;
    }
    
    
    //尾删
    void PopBack(PSeqList L)
    {
        if (EmptyList(L))
        {
            printf("表为空!\n");
        }
        L->length--;
    
    }
    
    //清空顺序表
    void ClearList(PSeqList L)
    {
        L->length = 0;
    }
    
    //判断表是否为空
    
    int EmptyList(PSeqList L)
    {
        if (L->length == 0)
        {
            return 1;
        }
        return 0;
    }
    
    //打印表中元素
    
    void PrintList(PSeqList L)
    {
        if (EmptyList(L))
        {
            printf("表为空!\n");
            return;
        }
        for (k = 0; k < L->length; k++)
        {
            printf("%-3d", L->data[k]);
        }
        printf("\n");
    }

    mian.c函数的简单测试代码

    #include <stdio.h>
    #include <Windows.h>
    #include "SeqList.h"
    
    int main()
    {
        SeqList L;
        DataType data;
        //初始化顺序表
        InitList(&L);
        //在表中插入元素
        printf("依次在表中插入元素(1,2,3,4,5):\n");
        InsList(&L, 1, 1);
        InsList(&L, 2, 2);
        InsList(&L, 3, 3);
        InsList(&L, 4, 4);
        InsList(&L, 5, 5);
    
        //打印表中元素
        printf("表中元素有:\n");
        PrintList(&L);
        //头插
        printf("在表头依次插入元素,6,7:\n");
        PushFront(&L, 6);
        PushFront(&L, 7);
        //尾插
        printf("在表尾依次插入元素,8,9:\n");
        PushBack(&L, 8);
        PushBack(&L, 9);
        printf("表中元素有:\n");
        PrintList(&L);
        //头删
        printf("头删一个元素:\n");
        PopFront(&L);
        //尾删
        printf("尾删一个元素:\n");
        PopBack(&L);
        //输出表中第4个元素值
        PrintList(&L);
        printf("表中第4个元素值为:\n%d\n",GetData(&L, 4));
        //查找表中第 i个元素的位置
        printf("元素2在表中的位置为:\n");
        printf("%d\n",Locate(&L, 2));
        //删除表中第2个元素对应的值
        printf("删除表中第2个元素:%d\n", DelList(&L, 2, &data));
        printf("顺序表的长度为:%d\n", LengthList(&L));
        printf("表中元素为:\n");
        PrintList(&L);
        //printf("删除的元素值为:%d\n", data);
        //清空顺序表
        ClearList(&L);
        PrintList(&L);
        system("pause");
        return 0;
    }
    展开全文
  • (1)初始化顺序表L (2)从标准输入(键盘)逐个数据输入a,b,c,d,e元素 ,建立顺序表 (3)输出顺序表L (4)输出顺序表L的长度 (5)判断顺序表L是否为空 (6)输出顺序表L的第3个元素 (7)输出元素a的位置...
  • 顺序表实例(全)

    千次阅读 2017-08-12 14:14:40
    线性表的初始化,增加,插入,删除等功能的实例 工程一共包含4个文件 1. Entity.h :声明线性表的元素的类型。可以是基本数据类型也可以是结构体 2. SeqList.h :定义线性表结构体,声明全局的宏定义,... 3.... 4....

    顺序表的初始化,增加,插入,删除等功能的实例

    工程一共包含4个文件
    1. Entity.h :声明线性表的元素的类型。可以是基本数据类型也可以是结构体
    2. SeqList.h :定义线性表结构体,声明全局的宏定义,函数的声明
    3. SeqList.c :具体的函数实现
    4. main.c : 测试文件

    参考博客文章: http://www.cnblogs.com/laojie4321/archive/2012/03/30/2425015.html
    参考博客文章: http://blog.163.com/jiaoruijun07@126/blog/static/68943278201042064246409/

    Entity.h

        typedef struct{
            char key[15];   //结点的关键字
            char name[20];
            int age;
        } DATA; //定义结点类型 可定义为简单类型或者结构体
    

    SeqList.h

        /*
            头文件:数据结构的定义和操作原型
    
        */
        #include <stdio.h>
        #include <string.h>
        #include "Entity.h"
        #define MAXSIZE 100 //定义线性表最大长度
    
        typedef struct {
            DATA ListData[MAXSIZE + 1]; //保存顺序表的数组(真正的数据从下标为1的位置开始)
            int ListLen;                //顺序表结点个数(已存结点);默认为0,表示没有数据
        } SeqListType;
    
        void SeqListInit(SeqListType *SL);                      //初始化顺序表
        int SeqListLength(SeqListType *SL);                     // 返回顺序表的元素数量
        int SeqListAdd(SeqListType *SL, DATA data);             // 向顺序表中添加元素
        int SeqListInsert(SeqListType *SL, int n, DATA data);   // 向顺序表中插入元素
        int SeqListDelete(SeqListType *SL, int n);              // 删除顺序表中的数据
        DATA *SeqListFindByNum(SeqListType *SL, int n);         // 根据序号返回元素
        int SeqListFindByCont(SeqListType *SL, char *key);      // 按关键字查找
        int SeqListAll(SeqListType *SL);                        // 遍历顺序表
    

    SeqList.c

        /*函数文件:具体的函数实现代码*/
    
        #include "SeqList.h"
    
        /* 初始化顺序表 */
        void SeqListInit(SeqListType *SL){
            SL->ListLen = 0;
        }
    
        /* 返回顺序表元素数量 */
        int SeqListLength(SeqListType *SL){
            return (SL->ListLen);
        }
    
        /* 添加元素到顺序表尾 */
        int SeqListAdd(SeqListType *SL, DATA data){
            if(SL->ListLen  >= MAXSIZE){ // 顺序表已满
                printf("顺序表已经满了 不能再添加");
                return 0; //返回失败
            }
    
            SL->ListData[++SL->ListLen] = data; // 把数据插入到下标为(ListLen+1)的位置
    
            return 1;//返回成功
        }
    
        /* 插入元素到顺序表指定位置 */
        int SeqListInsert(SeqListType *SL, int n, DATA data){
            int i;
    
            if(SL->ListLen  >= MAXSIZE){ // 顺序表已满
                printf("顺序表已经满了 不能再插入\n");
                return 0;
            }
    
            if(n < 1 || n > SL->ListLen){
                printf("要插入的位置错误\n");
                return 0;
            }
    
            for(i = SL->ListLen; i>=n; i--){ //移动要插入数据的后面的数据
                SL->ListData[i+1] = SL->ListData[i];
            }
            SL->ListData[n] = data;     //插入数据
            SL->ListLen++;              //数据个数加一
    
            return 1;
        }
    
        int SeqListDelete(SeqListType *SL, int n){
            int i;
            if(n < 1 || n > SL->ListLen+1){
                printf("结点错误 不能删除\n");
                return 0;
            }
    
            for(i=n; i<SL->ListLen; i++){   //移动要删除数据的后面的数据
                SL->ListData[i] = SL->ListData[i + 1];
            }
            SL->ListLen--;
    
            return 1;
        }
    
        DATA *SeqListFindByNum(SeqListType *SL, int n){
            if(n < 1 || n > SL->ListLen+1){
                printf("序号错误 获取失败");
                return NULL;
            }
    
            return &(SL->ListData[n]); // 返回指针增加通用性
        }
    
        int SeqListFindByCont(SeqListType *SL, char *key){
    
            int i;
            for(i = 0; i <= SL->ListLen; i++){
                if(strcmp(SL->ListData[i].key, key) == 0){
                    return i;
                }
            }
    
            return 0; //遍历没有找到
        }
    

    main.c

    /* 测试文件:调用测试函数*/
    #include <stdio.h>
    #include "SeqList.h"
    
    /*遍历顺序表中结点*/
    int SeqListAll(SeqListType *SL){
        int i;
        for(i = 0; i <= SL->ListLen; i++){
            //输出中第一个是0, 即下标为0的位置的存储的数据
            printf("(%s %s %d) \n", SL->ListData[i].key, SL->ListData[i].name, SL->ListData[i].age);
        }
    
        return 0;
    }
    
    int main(void){
        int i, k;
        SeqListType SL;         //定义顺序表变量
        DATA data, *data1;      //定义结点保存数据类型变量和指针变量
        char key[15];           //保存关键字
    
        SeqListInit(&SL);       //初始化数据表
    
        do{
            printf("请输入学号 姓名 年龄: ");
            fflush(stdin);      //清空输入缓冲区
            scanf("%s %s %d", &data.key, &data.name, &data.age);
            if(data.age){       //年龄不是0 退出循环
                if(!SeqListAdd(&SL, data)){//添加元素到顺序表
                    break;      //当添加失败 退出循环
                }
            }else{              //当年龄为0 退出循环
                break;
            }
        }while(1);
    
        printf("顺序表为: \n");
        SeqListAll(&SL);
    
        while(1){
            fflush(stdin);
            printf("\n\n输入操作\n1.获取结点位置元素\t2.内容查询\t3.添加\t4.插入\t5.删除\t6.求长度\t7.遍历\t8.退出\n:");
            scanf("%d", &k);
            if(k == 8){
                break;
            }
            switch(k){
                case 1:
                    printf("输入元素位置:");
                    scanf("%d", &i);
                    data1 = SeqListFindByNum(&SL, i);
                    printf("元素为:(%s %s %d) \n", data1->key, data1->name, data1->age);
                    break;
                case 2:
                    printf("输入元素key(学号):");
                    scanf("%s", &key);
                    i = SeqListFindByCont(&SL, key);
                    if(i == 0){
                        printf("没有找到对应元素!");
                        break;
                    }
                    data1 = SeqListFindByNum(&SL, i);
                    printf("位置为: %d ,元素为:(%s %s %d) \n", i, data1->key, data1->name, data1->age);
                    break;
                case 3:
                    printf("输入元素内容:");
                    scanf("%s %s %d", &data.key, &data.name, &data.age);
                    SeqListAdd(&SL, data);
                    break;
                case 4:
                    printf("输入位置和元素内容:");
                    scanf("%d %s %s %d", &i, &data.key, &data.name, &data.age);
                    SeqListInsert(&SL, i, data);
                    break;
                case 5:
                    printf("输入要删除的位置:");
                    scanf("%d", &i);
                    SeqListDelete(&SL, i);
                    break;
                case 6:
                    printf("-----%d------\n", SeqListLength(&SL));
                    break;
                case 7:
                    SeqListAll(&SL);
                     break;
            }
        }
    
        return 0;
    }
    

    个人博客 欢迎来访: http://ay2626.me

    展开全文
  • 顺序表的实现

    千次阅读 多人点赞 2019-03-23 22:02:51
    要求编写一个程序,实现顺序表的建立,插入,删除,查找,操作。 效果: 代码: #include<iostream> #define MAXSIZE 10 using namespace std; typedef struct {//顺序表存储结构 int *elem; int ...
    	
    要求编写一个程序,实现顺序表的建立,插入,删除,查找,操作。
    
    效果:
    

    在这里插入图片描述
    代码:

    #include<iostream>
    #include<memory.h>
    
    #define MAXSIZE 10
    using namespace std;
    
    typedef struct {//顺序表存储结构
    	int *elem;
    	int length;
    }SqList;
    
    bool List_Init(SqList &L)
    {//(1)构造一个空线性表
    	L.elem = new int[MAXSIZE];
    	memset(L.elem, 0, sizeof(L));
    	if (!L.elem)
    	{
    		return false;
    	}
    	L.length = 0;//空表长度设置为0
    	return true;
    }
    
    bool List_Insert(SqList &L, int i, int e)
    {//(2)线性表的插入
    	if (i<1 || i>L.length + 1)
    	{//插入位置不合法
    		return false;
    	}
    	if (L.length >= MAXSIZE)
    	{//顺序表空间已满
    		return false;
    	}
    	for (int j = L.length-1;j >= i-1;j--)
    	{
    		L.elem[j+1] = L.elem[j];
    	}
    	L.elem[i - 1] = e;
    	L.length++;
    	return true;
    }
    
    bool GetElem(SqList L, int i, int &e)
    {//(3)取元素
    	if (i<1 || i>L.length)
    	{
    		cout << "访问位置不合法"<<endl;
    		return false;
    	}
    	e = L.elem[i - 1];
    	return true;
    }
    
    bool Delete_List(SqList &L, int i)
    {//(4)删除(根据下标删除)
    	if (i<1 || i>L.length)
    	{
    		cout<<"输入下标不合法"<<endl;
    		return false;
    	}
    	else
    	{
    		for (int j = i;j < L.length;j++)
    		{
    			L.elem[j - 1] = L.elem[j];
    		}
    		L.length--;
    		cout << "删除成功!" << endl;
    	}
    	return true;
    }
    
    int LocateElem(SqList L, int e)
    {//(5)查找
    	for (int i = 0;i < L.length;i++)
    	{
    		if (L.elem[i] == e)
    		{
    			return i + 1;
    		}
    	}
    	return 0;
    }
    
    int main()
    {
    	cout << "====================" << endl << "(1).构造一个空线性表:" << endl<<endl;
    	SqList L;
    	if (!List_Init(L))
    	{
    		cout << "(Failure)空链表创建失败!" << endl<<endl;
    	}
    	else
    	{
    	cout << "(Success)空链表创建成功!" <<endl<<endl;;
    
    
    	cout << "====================" << endl << "(2).自定义一个顺序表:" << endl << endl;
    	int n, e1;
    	cout << "输入顺序表长度n:";cin >> n;
    	cout << "请依次输入n个值(以空格分隔):";
    	for (int i = 1;i <= n;i++)
    	{
    		cin >> e1;
    		List_Insert(L, i, e1);
    	}
    	cout << "当前顺序表为:";
    	for (int i = 1;i <= L.length;i++)
    	{
    		int tem;
    		GetElem(L, i, tem);
    		cout << tem << " ";
    	}
    	cout << endl;
    
    
    	cout << "====================" << endl << "(3).插入:" << endl << endl;
    	int i, e2, temp;
    	cout << "请输入插入位置:";
    	cin >> i;
    	cout << "请输入插入值:";
    	cin >> e2;
    	temp = List_Insert(L, i, e2);
    	if (temp)
    	{
    		cout << "插入成功!" << endl;
    	}
    	else if (!temp)
    	{
    		cout << "插入失败!\n";
    		if (temp == false)
    		{
    
    			cout << "顺序表空间已满" << endl;
    		}
    		else
    		{
    			cout << "插入位置不合法" << endl;
    		}
    	 }
    	cout << "当前顺序表为:";
    	for (int i = 1;i <= L.length;i++)
    	{
    		int e;
    		GetElem(L, i, e);
    		cout << e << " ";
    	}
    	cout << endl;
    
    	cout << "====================" << endl << "(4).删除:" << endl << endl;
    	int l;
    	cout << "请输入要删除元素的位置:";cin >> l;
    	Delete_List(L, l);
    	
    	cout << "当前顺序表为:";
    	for(int i=1;i<=L.length;i++)
    	{
    		int e;
    		GetElem(L, i, e);
    		cout << e << " ";
    	 }
    	cout << endl;
    
    	cout << "====================" << endl << "(5).查找:" << endl << endl;
    	cout << "请输入要查找的值:";
    	int e3;
    	cin >> e3;
    	temp = LocateElem(L, e3);
    	if (!temp)
    	{
    		cout << "(Sorry)顺序表中没有这个值"<<endl;
    	}
    	else
    	{
    		cout << "查找成功,元素位置为:"<<temp << endl<<endl;
    	}
    
    	delete[]L.elem;
    	cout << "====================" << endl<<"(Over)链表已释放!" << endl << endl;
    	}
    	system("pause");
    	return 0;
    }
    
    展开全文
  • 顺序表

    2020-10-17 12:19:54
    动态顺序表: //动态顺序表 #include<stdio.h> #include<stdlib.h> #define LIST_SIZE 100 //顺序表存储空间的初始分配量 typedef int ElementType; typedef struct SqList* List; struct SqList{ ...
  • 顺序表的基本操作

    万次阅读 多人点赞 2019-06-30 23:24:27
    顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构,一般情况下采用数组存储;即通过数据元素物理存储的连续性来反应元素之间逻辑上的相邻关系。 采用顺序存储结构存储的线性表通常简称为顺序表。 二...
  • 什么是顺序表

    千次阅读 2019-08-26 10:42:46
    顺序表 在程序中,经常需要将一组(通常是同为某个类型的)数据元素作为整体管理和使用,需要创建这种元素组,用变量记录它们,传进传出函数等。一组数据中包含的元素个数可能发生变化(可以增加或删除元素)。 对于...
  • 顺序表操作详解

    千次阅读 2016-03-23 12:34:41
    顺序表定义 :顺序表 是线性表的顺序储存结构 ,顺序表就是将线性表中的数据元素按照线性顺序存储到指定位置开始的、一块连续的存储空间中。 顺序表的#include #include #define MAX 100 //data数组所能存储的最大...
  • 顺序表和链表存储的优缺点

    万次阅读 2015-08-07 11:31:06
    顺序表和链表存储的优缺点 1.顺序表存储  原理:顺序表存储是将数据元素放到一块连续的内存存储空间,存取效率高,速度快。但是不可以动态增加长度  优点:存取速度高效,通过下标来直接存储  缺点:1.插入和...
  • C语言实现顺序表的创建与增删改查操作

    万次阅读 多人点赞 2019-10-28 23:31:44
    C语言实现顺序表的创建与增删改查操作 一、编写源程序SqListDemo.c /* 线性表的顺序存储实现 */ #include<stdio.h> #include<stdlib.h> #include<string.h> // 定义符号常量 #define LIST_...
  • 顺序表va中的数据元素递增有序。试写一算法,将x插入到顺序表的适当位置上,以保持该表的有序性 先建立一个待插入的结点,然后依次与与链表中的各结点的数据域比较大小,找到插入该结点的位置,最后插入该结点。
  • 顺序表 线性表 数组的区别

    万次阅读 多人点赞 2014-07-15 12:36:55
    数组就是相同数据类型的元素按一定顺序排列的集合。 一句话:就是物理上存储在一组联系的地址上。也称为数据结构中的物理结构。 线性表中数据元素之间的关系是一对一的关系,即除了第一个和最后一个数据元素...
  • 算法背景有时候,可能会遇到这样的:整个中的元素未必有序,但若划分为若干块后,每一块中的所有元素均小于(或大于)其后面块中的所有元素。我们称这种为分块有序。对于分块有序的查找首先,我们需要先建立一...
  • 数据结构(一)——顺序表(C语言实现)

    万次阅读 多人点赞 2016-09-30 18:00:32
    顺序表的简单实现
  • #include #include #include using namespace std; typedef int ElemType; typedef int Status; #define OK 1 #define ERROR 0 #define OVERFLOW -2 #define LIST_INIT_SIZE 100 #define LISTINCREMENT 10 ElemTy
  • 线性表之顺序表与单链表的区别及优缺点

    万次阅读 多人点赞 2017-10-09 09:35:49
    这里比较的是基于C语言实现的顺序表与单链表,与其他语言的实现可能会有差异,但我相信语言是相通的,它们的实现机制应该也差不多。 1、What 什么是顺序表和单链表 ①顺序表顺序表是在计算机内存中以数组的...
  • 顺序表的建立 基本输入输出

    万次阅读 多人点赞 2017-11-24 17:18:51
    输入数据的个数n 输入n个数 然后输出  input  5 1 2 3 4 5 output 1 2 3 4 5 以下是代码: #include #include #define list_size 10000 #define listincreasement 10000 typedef int element;...t
  • 数据结构-顺序表的初始化

    万次阅读 多人点赞 2014-11-30 01:23:03
    //顺序表的初始化 #include #include // #define OK 1; #define OVERFLOW -2 #define MAXSIZE 100//顺序表可能达到的最大长度  typedef int Status;//Status是函数的类型,其值是函数结果状态代码,如OK等 typedef...
  • C语言创建顺序表并插入元素 详细注释

    千次阅读 多人点赞 2018-04-22 18:03:22
    顺序表是用一组地址连续的存储单元依次存储数据元素的数据结构。顺序表是线性表的一种,线性表是最常用且最简单的一种数据结构,一个线性表是 n 个数据元素的有限序列。我们使用 c 语言来创建顺序表并插入元素。IDE ...
1 2 3 4 5 ... 20
收藏数 1,150,336
精华内容 460,134
关键字:

顺序表