数据结构与算法 （1） - 线性表

线性表

数组存储（顺序存储）

#ifndef  __ARRAYLIST_H
#define  __ARRAYLIST_H

typedef int  ElemType ;
struct  ArrayList {
  ElemType *Data;
  int size;
  int MaxSize;
};
typedef struct ArrayList *  List;

void InitList(List PtrL,int size);
void ClearList(List PtrL);
int Insert(List PtrL,int position,ElemType X);
int Delete(List PtrL,int position);
#endif




#include "ArrayList.h"
#include "stdio.h"
#include "stdlib.h"
void InitList(List PtrL,int size)
{
  if(size<1)
  {
    printf("Size Error");
    return ;

  } 
 ElemType * X=(ElemType *)(malloc(size*sizeof( ElemType)));
if(!X)
 {
printf("Malloc Error");
}
  PtrL->Data=X;
  PtrL->MaxSize=size;
  PtrL->size=0;
}
void ClearList(List PtrL)
{
  if(PtrL->Data !=NULL)
  {
    free(PtrL->Data);
    PtrL->Data=NULL;
   PtrL->size=PtrL->MaxSize=0; 
  }
}
 int Insert(List PtrL,int position,ElemType X)
{
  int i;
if(position<1||position>PtrL->size+1)  
{
  printf("Position Error");
  return 0; 
}
if(PtrL->size>=PtrL->MaxSize)
{
  printf("So small to save");
  return 0; 
}
for(i=PtrL->size-1;i>=position-1;i--)
{
  PtrL->Data[i+1]=PtrL->Data[i];
}
PtrL->Data[position-1]=X;
PtrL->size++;
 return 1; 
}
int Delete(List PtrL,int position)
{
  int j;
if(position<1||position>PtrL->size)  
{
  printf("Position Error");
  return 0; 
}
for(j=position-1;j<=PtrL->size-1;j++)
{
  PtrL->Data[j]=PtrL->Data[j+1];
}
PtrL->size--;
return  1;
}

insert函数

for(i=PtrL->size-1;i>=position-1;i–)//从最后一个往后依次移一个 ，防止从前面往后移破环数据
{
PtrL->Data[i+1]=PtrL->Data[i];
}
PtrL->Data[position-1]=X;
PtrL->size++;

delete函数

for(j=position-1;j<=PtrL->size-1;j++)//从被删除的后一个往前移 覆盖之前的数据
{
PtrL->Data[j]=PtrL->Data[j+1];
}

链式存储

单（双）向链表

#ifndef  __CHAINLIST_H
#define  __CHAINLIST_H
#include  <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#define  ENABLECIRCLE   1   //decide   if we need  circle
struct  Node;
typedef  struct Node  * PtrNode;
typedef  int  ElemType;
struct  Node  {
  ElemType  Elem;
  PtrNode  Next;
};
int  ListSize;

PtrNode  InitchainList();
int IsEmpty(PtrNode L);
PtrNode  Find(ElemType X,PtrNode L);
int Delete(ElemType  X,PtrNode L);
PtrNode  FindPervious(ElemType X,PtrNode L);
int Insert(ElemType X,PtrNode L,int theIndex);
void  DeleteList(PtrNode L);

#endif








#include  "chainList.h"


PtrNode  InitchainList()
{
  PtrNode   L;
   L=malloc(sizeof(struct Node ));
   if(!L)
   {
     printf("malloc error");
   }
   if(ENABLECIRCLE)
   {
   L->Next=L;
   }
   else
   {
   L->Next=NULL; //create a chainList  and init
   }
   ListSize++;
   return   L;  //must as return value   to create  chainList  

}

int IsEmpty(PtrNode L)
{
  if(ENABLECIRCLE)
  {
  return  L->Next ==L; 
  }
  else
  {
  return  L->Next ==NULL;
  }  
}

PtrNode  Find(ElemType X,PtrNode L)
{
  PtrNode  NowPos ;
  NowPos =L->Next;
  if(ENABLECIRCLE)
  {
  while(NowPos !=L&&NowPos->Elem!=X)//when find it or  in the end  
    NowPos=NowPos->Next;
  }
  else 
  {
  while(NowPos !=NULL&&NowPos->Elem!=X)//when find it or  in the end  
    NowPos=NowPos->Next;
  }
   return  NowPos;
}

int Delete(ElemType  X,PtrNode L)
{
  PtrNode NowPos ,temp;
  NowPos=FindPervious(X,L);
  if(ENABLECIRCLE)
  {
  if(NowPos->Next!=L)
  {
    temp=NowPos->Next;//when  delete a member   ,should  save   it  at first  ,after that you can delete it
    NowPos->Next=temp->Next;
    free(temp);
    ListSize--;
    return 1;
  }
  return 0;
  }
  else
  {
  if(NowPos->Next!=NULL)
  {
    temp=NowPos->Next;//when  delete a member   ,should  save   it  at first  ,after that you can delete it
    NowPos->Next=temp->Next;
    free(temp);
    ListSize--;
    return 1;
  }
  return 0;
  }
}




PtrNode  FindPervious(ElemType X,PtrNode L)
{
  PtrNode  Perv;
  Perv=L;
  if(ENABLECIRCLE)
  {
  while(Perv->Next!=L&&Perv->Next->Elem!=X)
    Perv=Perv->Next;
  }
  else
  {
  while(Perv->Next!=NULL&&Perv->Next->Elem!=X)
    Perv=Perv->Next;
  }
  return  Perv;
 
}
int Insert(ElemType X,PtrNode L,int theIndex)
{
  PtrNode  temp ,NowPos;
  NowPos=L;
  if(theIndex<=0||theIndex>ListSize)//Let the Position  current
  {
    printf("The Position  Error!");
    return 0;
  }
  temp=malloc(sizeof(struct Node));
   if(!temp)
   {
     printf("malloc error");
   }
  if(theIndex==1)
  {
      temp->Elem=X;
      temp->Next=L->Next;
      L->Next=temp;
  }
  else
  {
  for(int i=0;i<theIndex-1;i++)  
  {
  NowPos=NowPos->Next;  //find  the previous  member   
  }
  temp->Next=NowPos->Next;
  NowPos->Next=temp;
  temp->Elem=X;
  }
  ListSize++;
  return 1;
}

void   DeleteList(PtrNode L)
{
  PtrNode  temp ,NowPos;
  NowPos=L->Next;
  if(ENABLECIRCLE)
  {
  while(NowPos!=L)
  {
  temp =NowPos->Next;
  free(NowPos);
  NowPos=temp; 
  }
  ListSize=0;
  }
  else
  {
  while(NowPos!=NULL)
  {
  temp =NowPos->Next;
  free(NowPos);
  NowPos=temp; 
  }
  ListSize=0;
  }
 
}

双向循环链表

#ifndef   __DOUBLECHAINLIST_H
#define   __DOUBLECHAINLIST_H
#include  <stdio.h>
#include <stdlib.h>
#include <stddef.h>
typedef  int ElemType;

struct  dNode  ;
typedef  struct dNode * PtrdNode;
struct  dNode  {
PtrdNode  next;
PtrdNode  perv;
ElemType  data;
};
int ListSize;
PtrdNode InitList();
int ClearList(PtrdNode L );
int IsEmpty(PtrdNode L);
int Insert(PtrdNode L,ElemType X,int Index);
int Delete(PtrdNode L,int Index);
PtrdNode GetPosition(PtrdNode L,int Index);
ElemType   IndexOf(int Index,PtrdNode L);
int  Find(ElemType  X,PtrdNode L,int order);
#endif







#include "doublechainList.h"

PtrdNode InitList()
{
  PtrdNode L=malloc(sizeof( struct dNode));
  if(!L)
  {
    printf("malloc error");
    return NULL;
  }
  L->next=L->perv=L;
  ListSize++;
  return L;
}
int ClearList(PtrdNode L )
{
  PtrdNode temp,NowPos=L->next;
  while(NowPos!=L)
  {
    temp =NowPos->next;
    free(NowPos);
    NowPos=temp;
    ListSize=0;
  }
  return 1;
}
int IsEmpty(PtrdNode L)
{
  if(L->next==L&&L->perv==L)
    return 1;
  else 
    return 0;
}
PtrdNode GetPosition(PtrdNode L,int Index)
{
  int j;
  PtrdNode temp=L;
  for(j=1;j<=Index;j++)
    temp=temp->next;
  return temp;
}
int Insert(PtrdNode L,ElemType X,int Index)
{
  PtrdNode temp,NowPos=L;
  if(Index<1||Index>ListSize)
  {
    printf("Position Error!");
    return 0;
  }
  temp=malloc(sizeof(struct dNode));
  NowPos=GetPosition(L,Index-1);
  temp->data=X;
  temp->perv=NowPos;
  temp->next=NowPos->next;
  NowPos->next->perv=temp;
  NowPos->next=temp;
  ListSize++;
  return 1;
}
int Delete(PtrdNode L,int Index)
{
  PtrdNode  NowPos;
  if(Index<1||Index>ListSize)
  {
    printf("Position Error!");
    return 0;
  }
  NowPos=GetPosition(L,Index);
  NowPos->perv->next=NowPos->next;
  NowPos->next->perv=NowPos->perv;
  free(NowPos);
  ListSize--;
  return 1;
}

ElemType   IndexOf(int Index,PtrdNode L)
{
  PtrdNode  NowPos;
  if(Index<1||Index>ListSize)
  {
    printf("position error");
    return 0;
  }
  NowPos=GetPosition(L,Index);
  return NowPos->data;
}
int  Find(ElemType  X,PtrdNode L,int order)
{
  int Index=0;
  PtrdNode  NowPos;
  if(order)
    NowPos=L->next;
  else
    NowPos=L->perv;
  while(NowPos!=L&&NowPos->data!=X)
  {
    if(order)
      NowPos=NowPos->next;
    else
      NowPos=NowPos->perv;
    Index++;
  }  
  if(NowPos==L)
    return -1;
  else
    return Index+1;
}