c语言——线性表

C语言线性表是一个储存方式，比较基础的数据结构

希望下面的代码会对大家有所帮助 

#include<stdio.h>
#include<stdlib.h>
#define OK 1
#define ERROR 0
#define OVERFLOW -1
#define List_Size 100  //线性表存储空间的初始化配量
#define ListIncrement 10  //线性表存储空间的分配增量
typedef int ElemType;
typedef struct{
	ElemType *elem;//存放线性表的数组基地址
	int length;//线性表的当前长度
	int listsize;//线性表当前分配的存储容量
}SqList;

int InitList(SqList &L){
  L.elem=new ElemType[List_Size];
  if(!L.elem)exit(OVERFLOW);
  L.length=0;
  L.listsize=List_Size;
  return OK; 
}
void CreateList(SqList &L,int n){//创建顺序表
	int i;
	for(i=0;i<n;i++){
		scanf("%d",&L.elem[i]);
		L.length++;
	}
}
void Deatroy(SqList &L){//销毁顺序表
	delete L.elem;
}

int ListInsert(SqList &L,int i,ElemType x){
	int j;
	ElemType *p;
	if(i<1||i>L.length)return ERROR;//插入位置不合法
	if(L.length>=L.listsize){//当前存储空间已满，增加分配
		p=(ElemType *)realloc(L.elem,(L.listsize+ListIncrement)*sizeof(ElemType));
		if(!p)exit(OVERFLOW);
		L.elem=p;
		L.listsize=L.listsize+ListIncrement;
	}
	for(j=L.length-1;j>=i;j--)L.elem[j+1]=L.elem[j];//插入位置之后的元素依次后移
	L.elem[i]=x;//插入元素
	++L.length;//表长增1
	return OK;
}
int ListDelete(SqList &L,int i){
	int j;
	if(i<1||i>L.length)return ERROR;//删除位置不合法
	for(j=i-1;j<L.length-1;j++)L.elem[j]=L.elem[j+1];//删除位置之后的元素依次前移
	--L.length;//表长增1
	return OK;
}
int LocateElem(SqList L,ElemType x){
	int i=1;
	while(i<=L.length&&L.elem[i-1]!=x)i++;
	if(i<=L.length)return i;
	else return ERROR;
}
void DispList(SqList L){//输出顺序表
	int i;
	for(i=0;i<L.length;i++)
	printf("%d ",L.elem[i]);
	printf("n");
}

void Contrary_sq(SqList La,SqList &Lb){//将顺序表逆置
	int i;
	InitList(Lb);
	Lb.listsize=Lb.length=La.length;
	for(i=0;i<La.length;i++)Lb.elem[i]=La.elem[La.length-1-i];
}
int Insert_Ordersq(SqList &La,ElemType x){
	int i;
    ElemType *p;
	if(La.length>=La.listsize){//当前存储空间已满，增加分配
		p=(ElemType *)realloc(La.elem,(La.listsize+ListIncrement)*sizeof(ElemType));
		if(!p)exit(OVERFLOW);
		La.elem=p;
		La.listsize=La.listsize+ListIncrement;
	}
	for(i=La.length-1;x<La.elem[i]&&i>=0;i--)La.elem[i+1]=La.elem[i];
	La.elem[i+1]=x;//插入元素x
	++La.length;
	return OK;
}
void mergelist_sq(SqList La,SqList Lb,SqList &Lc){//两个有序表的归并
	int i,j,k;
	InitList(Lc);
	if(!Lc.elem)exit(OVERFLOW);
	i=0;j=0;k=0;
	while(i<La.length&&j<Lb.length){
		if(La.elem[i]<=Lb.elem[j]) Lc.elem[k++]=La.elem[i++];
		else Lc.elem[k++]=Lb.elem[j++];
	}
	while(i<La.length)Lc.elem[k++]=La.elem[i++];//将La中剩余元素插入到Lc中
	while(j<Lb.length)Lc.elem[k++]=Lb.elem[j++];//将Lb中剩余元素插入到Lc中
	Lc.length=La.length+Lb.length;
}

int main(){
	SqList L,La,Lb,Lc;
	int i=4;
	ElemType x=100;    	
	InitList(L);   //建空表
	CreateList(L,5);   //创建表
	ListInsert(L,i,x);
	DispList(L);

	ListDelete(L,i);
	DispList(L);

	printf("%dn",LocateElem(L,x));

	Contrary_sq(L,Lb);
	DispList(Lb);

	InitList(La);
	CreateList(La,5);
	x=4;
	Insert_Ordersq(La,x);
	DispList(La);

	InitList(La);
	CreateList(La,5);
	DispList(La);

	InitList(Lb);
	CreateList(Lb,3);
	DispList(Lb);

	mergelist_sq(La,Lb,Lc);
	DispList(Lc);
	
return 0;
}


双向链表

# include <stdlib.h>
# include <stdio.h>
# define  OK 1
# define  OVERFLOW -1
# define  ERROR 0
typedef int ElemType;/
typedef struct DuLNode {
	ElemType  data; // 数据域
	struct DuLNode  *prior; //指向前驱的指针域
	struct DuLNode  *next; //指向后继的指针域
}DuLNode,*DuLinkList;
void LinkListInit(DuLinkList &L){
	L=new DuLNode;
	if(!L)exit(OVERFLOW);
	L->next=L->prior=NULL;
}
DuLNode *GetElem_L(DuLinkList L,int i){//在带头结点的双向链表L中查找第i个结点，找到返回该结点，否则返回空
	DuLNode *p;
	p=L->next;
	int j=1;  //p指向第一个结点，j为计数器
	while(p!=L&&j<i){p=p->next; ++j;}  //顺指针向后查找，直到p指向第i个元素或p为空
	if(j==i)return p;  //第i个元素存在
	else  return NULL; //第i个元素不存在
}

int ListInsert_L(DuLinkList &L,int i,ElemType x){//在双向链表L中第i个位置之前插入元素x
	DuLNode *p,*s;
	p=GetElem_L(L,i-1);
	if(!p)return ERROR;
	s=new DuLNode; //生成新结点
	s->data=x; 
	if(p->next){
		p->next->prior=s;
		s->next=p->next;
		s->next->prior=p;   
		p->next=s; 		
	}
	else{//插入在L尾部的处理
		s->next=p->next;
		p->next=s;
		s->prior=p;
	}
	return OK;
}
int ListDelete_L(DuLinkList &L,int i){
	DuLNode *p,*q;
	p=GetElem_L(L,i-1);
	if(!p)return ERROR;  //删除位置不合理
	if(p->next->next){
		q=p->next;
		q->next->prior=p;
		p->next=q->next;  //删除并释放结点
		
	}
	else{//删除尾部结点
		q=p->next;
		p->next=NULL;
		q->prior=NULL;
		
	}
	delete q;
	return OK;
}
void CreateList_L(DuLinkList &L,int n) {//逆序输入n个数据元素，建立带头结点的双向链表
	DuLNode *p;	
	LinkListInit(L); //建立空表
	for(int i=n; i>0; --i){
		p=new DuLNode;//新增结点
		scanf("%d",&p->data);  //输入元素值
		p->next=L->next;
		p->prior=L;
		L->next=p;
	}
}
void DispList_L(DuLinkList L) {
	DuLNode *p;	
	for(p=L->next;p;p=p->next)printf("%d ",p->data);
	printf("n");
}
//void CreateList_L(DuLinkList &L,int n){
//	DuLNode *p,*r;
//	LinkListInit(L); //建立空表
//	r=L;  //r始终指向表尾结点
//	for(int i=1; i<=n; i++){
//		p=new DuLNode;
//		scanf("%d",&p->data);  //输入元素值
//		r->next=p;  //插入到表尾
//		r=p;
//	}
//	r->next=NULL;
//}

int main(){
	DuLinkList L;	
	DuLNode *p;
	CreateList_L(L,5);
	DispList_L(L);
//	p=GetElem_L(L,3);
//	if(p!=NULL)printf("%dn",p->data);
	ListInsert_L(L,6,10);
	DispList_L(L);
	ListDelete_L(L,6);
	DispList_L(L);
	return 0;
}

最后

以上就是健康红牛为你收集整理的c语言——线性表的全部内容，希望文章能够帮你解决c语言——线性表所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。