线性表的顺序表示(C语言实现)

本文涉及的产品
网络型负载均衡 NLB,每月750个小时 15LCU
传统型负载均衡 CLB,每月750个小时 15LCU
应用型负载均衡 ALB,每月750个小时 15LCU
简介: #include#include #define ERROR 0#define OK 1#define EQUAL 1#define OVERFLOW -1#define LIST_INIT_SIZE 100#define LISTINCREMENT 10 struct STU{  char n...

#include<stdio.h>
#include<malloc.h>

#define ERROR 0
#define OK 1
#define EQUAL 1
#define OVERFLOW -1
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10

struct STU{
  char name[20];
  char stuno[10];
  int age;
  int score;
}stu[50];
typedef struct STU ElemType;

struct LIST
{
  ElemType *elem;
  int Length;
  int listsize;
};

typedef struct LIST List;

/*构造一个空的线性表L*/

int init(List *L)
{
  L->elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));
  if(!L->elem) exit(OVERFLOW);
  L->Length=0;
  L->listsize=LIST_INIT_SIZE;
  return OK;
}/*init */

/*返回L中数据元素的个数*/

int ListLength(List *L)
{
  return L->Length;
}

/*若线性表L存在,1<=i<=L.Length,用e返回L中第i个元素*/
void GetElem(List L,int i,ElemType *e)
{
  *e=L.elem[i];
}

int EqualList(ElemType *e1,ElemType *e2)
{
  if (strcmp(e1->name,e2->name)==0)
    return 1;
  else
    return 0;
}

/*判断元素的大小,通过元素的name字段*/

int Less_EqualList(ElemType *e1,ElemType *e2)
{
  if (strcmp(e1->name,e2->name)<=0)
    return 1;
  else
    return 0;
}

/*若cur_e是L的元素,且不是第一个,则用pre_e返回它的前驱*/

int PriorElem(List *La,ElemType cur_e,ElemType *pre_e)
{
  int i;            
  i=LocateElem(La,cur_e,EQUAL);
  {
     if (i>=1)
     {
       *pre_e=La->elem[i-1];  /*»òдΪLa->elem[i-1]*/
       return OK;
     } 
     else
     {
       return ERROR;
     }
  }
}

/*若cur_e是L的元素,且不是最后一个,则用next_e返回它的后继元素*/

int NextElem(List *La,ElemType cur_e,ElemType *next_e)
{
  int i;         
  if (LocateElem(La,cur_e,i))
  {
     if (i<=La->Length-1)
     {
       *next_e=(*La).elem[i+1];
       return OK;
     } 
     else
     {
       return ERROR;
     }
  }
}

/*返回线性表L中第一个与e满足关系type的位序*/

int LocateElem(List *La,ElemType e,int type)
{
  int i;
  switch (type)
    {
      case EQUAL:
 for(i=0;i<La->Length;i++)
   if(EqualList(&La->elem[i],&e))
     return i;
 break;
      default:
 break;
    }
  return 0;
}

/*从线性表L中删除第i个元素,并且删除的元素赋给e*/

int DeleteElem(List *L,int i,ElemType e)
{
  ElemType *p,*q; 
  if ((i<1) || (i>L->Length)) return ERROR;
  p=&L->elem[i-1];
  e=*p;
  q=L->elem+L->Length-1;  /* Also Write: q=&L->elem[0]+L->Length-1;*/
  for (++p;p<=q;++p)
    *(p-1)=*p;
  --L->Length;
  return OK; 
}

/*清空线性表L*/

void ClearList(List *L)
{
     L->Length=0;
}

/*销毁线性表L*/

int DestroyList(List *L)
{
    int i;
    for (i=0;i<=L->Length-1;i++)
      free(&L->elem[i]);
    L->Length=0;
}   

/*合并线性表La,Lb到Lc*/

void MergeList(List *La,List *Lb,List *Lc)
{
  ElemType *pa,*pb,*pc,*pa_last,*pb_last;
  pa=La->elem;pb=Lb->elem;
  Lc->listsize = Lc->Length = La->Length + Lb->Length;
  pc = Lc->elem = (ElemType *)malloc(Lc->listsize * sizeof(ElemType));
  if(!Lc->elem)   exit(OVERFLOW);
  pa_last = La->elem + La->Length - 1;
  pb_last = Lb->elem + Lb->Length - 1;
  while(pa<=pa_last && pb<=pb_last)
    {
      if(Less_EqualList(pa,pb))   *pc++=*pa++;
      else *pc++=*pb++;
    }
  while(pa<=pa_last) *pc++=*pa++;
  while(pb<=pb_last) *pc++=*pb++;
}

/*将所有在线性表Lb中但不早La中的数据元素插入到La中*/

void UnionList(List *La, List *Lb)
{
  int La_len,Lb_len;
  int 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,EQUAL))
 ListInsert(La,++La_len,e);
    }

}

/*打印线性表L*/

int printlist(List L)
{
  int i;
  printf("name       stuno        age     score\n");
  for(i=0;i<L.Length;i++)
      printf("%-10s %s\t%d\t%d\n",  L.elem[i].name,  L.elem[i].stuno,
   L.elem[i].age,  L.elem[i].score);
  printf("\n");
}

/*将元素e插入线性表L的第i个元素中*/

int ListInsert(List *L,int i,struct STU e)
{
  struct STU *p,*q;
  if (i<1||i>L->Length+1) return ERROR;
  q=&(L->elem[i-1]);
  for(p=&L->elem[L->Length-1];p>=q;--p)
    *(p+1)=*p;
  *q=e;
  ++L->Length;
  return OK;
}/*ListInsert Before i */


main()
{
  struct STU e,t,*k;
  List La,Lb,Lc,*L;
  int i;

  printf("\n\n-------------------List Demo is running...----------------\n\n");
  printf("First is InsertList function.\n");
  init(&La);

  strcpy(e.name,"stu1");
  strcpy(e.stuno,"100001");
  e.age=80;
  e.score=1000;
  ListInsert(&La,1,e);
  strcpy(e.name,"stu3");
  strcpy(e.stuno,"100002");
  e.age=80;
  e.score=1000;
  ListInsert(&La,2,e);

  printlist(La);
  printf("List A length now is  %d.\n\n",La.Length);
  getch();

  strcpy(e.name,"stu5");
  strcpy(e.stuno,"100003");
  e.age=80;
  e.score=1000;
  ListInsert(&La,3,e);

  printlist(La);
  printf("List A length now is  %d.\n\n",La.Length);
  getch();

  strcpy(t.name,"stu5");
  strcpy(t.stuno,"100003");
  t.age=80;
  t.score=1000;
  L=&La;
  i=LocateElem(L,t,EQUAL);
  printf("The position of t is %d\n",i);
 
  PriorElem(L,t,k);
  printf("The prior name is %s\n",k->stuno);
  getch();
 
  DeleteElem(&La,2,e);
  printlist(La);
  getch();
 
  DestroyList(&La);
  printlist(La);
  getch();
  init(&Lb);
  strcpy(e.name,"stu2");
  strcpy(e.stuno,"100001");
  e.age=80;
  e.score=1000;
  ListInsert(&Lb,1,e);
  strcpy(e.name,"stu4");
  strcpy(e.stuno,"100002");
  e.age=80;
  e.score=1000;
  ListInsert(&Lb,2,e);

  strcpy(e.name,"stu6");
  strcpy(e.stuno,"100001");
  e.age=80;
  e.score=1000;
  ListInsert(&Lb,3,e);

  printlist(Lb);
  printf("List B length now is  %d.\n\n",Lb.Length);
  getch();

  MergeList(&La,&Lb,&Lc);
  printlist(Lc);
  getch();

  printf("Second is UnionList function.\n");
  printf("Now union List A and List B.....\n");
  UnionList(&La,&Lb);
  printlist(La);
  printf("List A length now is  %d.\n\n",La.Length);
  getch();
  printf("\n\n\n\n\n\nWelcome to visit http://zmofun.heha.net !\n\n\n\n\n\n\n");
  getch();
}

本文来自CSDN博客,转载请标明出处:http://blog.csdn.net/djcsch2001/archive/2009/03/05/3961065.aspx

相关实践学习
SLB负载均衡实践
本场景通过使用阿里云负载均衡 SLB 以及对负载均衡 SLB 后端服务器 ECS 的权重进行修改,快速解决服务器响应速度慢的问题
负载均衡入门与产品使用指南
负载均衡(Server Load Balancer)是对多台云服务器进行流量分发的负载均衡服务,可以通过流量分发扩展应用系统对外的服务能力,通过消除单点故障提升应用系统的可用性。 本课程主要介绍负载均衡的相关技术以及阿里云负载均衡产品的使用方法。
相关文章
|
8月前
|
存储 C语言
C语言线性表的链式表示和实现讲解
C语言线性表的链式表示和实现讲解
48 0
数据结构入门(C语言版)线性表中顺序表介绍及接口实现(下)
在顺序表中,头插相对于尾插来说就不是那么简单了,这里主要是让顺序表整体向后移动,再在头部插入数据。
|
8月前
|
存储 C语言 索引
C语言线性表的顺序表示和实现讲解
C语言线性表的顺序表示和实现讲解
41 0
|
C语言
造轮子之-C语言实现ArrayList
造轮子之-C语言实现ArrayList
|
存储 C语言
数据结构 C语言 2.1 线性表抽象数据类型 2.2 小议顺序表
数据结构 C语言 2.1 线性表抽象数据类型 2.2 小议顺序表
55 0
|
存储 缓存
数据结构入门(C语言版)线性表带头双向循环链表接口实现(下)
这里的查找就是使用一个while循环遍历链表找到某节点的data符合要查找的值
数据结构入门(C语言版)线性表带头双向循环链表接口实现(上)
第一步当然是先使用malloc函数申请内存空间,然后就是两个指针的建立,尾部指针指向头结点头部,头部指针指向头结点尾部,返回带头结点,头结点初始化完成。
|
存储 程序员 C语言
数据结构入门(C语言版)线性表中链表介绍及无头单向非循环链表接口实现
概念: 线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素。因此,为了表示每个数据元素与其直接后继数据元素之间的逻辑关系,对数据元素来说,除了存储其本身的信息之外,还需存储一个指示其直接后继的信息(即直接后继的存储位置)。
|
存储 机器学习/深度学习 算法
数据结构入门(C语言版)线性表中顺序表介绍及接口实现(上)
不论在程序员的工作上,还是在学习或是考研上,数据结构都是一门非常重要且值得我们一直研究探索的学科,可以说数据结构和算法就是编程的核心。OK,接下来我们来到数据结构的入门第一步就是学习线性表,接下来由作者来详细介绍数据结构第一章线性表。
|
存储 C语言
线性表之顺序表(C语言实现)
线性表之顺序表(C语言实现)
138 0

热门文章

最新文章