数据结构（一）

文章目录

链表

注意：所有用链表实现的数据结构在使用malloc和free的情况下时间开销都很大
面试的时候使用数组较好

单链表

链表定义

链表定义
* Definition for singly-linked list
struct Node;
typedef struct Node  * PtrToNode; //简化数组指针定义方式
typedef PtrToNode List;           //定义指向结构体Node的指针List 和Position
typedef PtrToNode Position;

struct Node{
ElementType Element ;      //数据域
Position Next ;           //指针域
};

查询

 //检查链表是否为空
int IsEmpty(List L){
return L->Next==NULL;
}

//测试当前节点是否是链表的末尾
int IsLast(List L,Position P){
return P->Next==NULL;
}

//返回某个元素在表中的位置
Position Find(List L,ElementType X){
Position P;   //开辟一个空的节点
P=L->Next;
while(P!=NULL&&P->Element!=X)P=P->Next;//如果指针P指向的节点不为空并且数据域不等于X，查找下一个节点
return P;            // 不考虑没有找到的情况

}

删除

//找到x之前元素的所在位置
Position  FindPrevious(ElementType X,List L){
Position P=L;
while(P->Next !=NULL&&P->Next->Element!=X)P=P->Next;
return P;

}

void Delete(ElementType X,List L){
Position P=FindPrevious(X,L);
if(P->Next!=NULL){
  Position TmpCell;
  TmpCell=P->Next;
  P->Next=TmpCell->Next;
  free(TmpCell);    //注意不能写free(P->Next);
 }
}

插入

//X是要插入元素的取值，P是要插入的位置
void Insert (List L,ElementType X,Position P){
Position TmpCell;
TmpCell=malloc(sizeof(struct Node));
TmpCell->ElementType=X;
TmpCell=P->Next;
P->Next=TmpCell;

}

链表删除

void DeleteList(List L){
Position P,TmpCell;
P=L->Next;
L->Next=NULL;
while(P!=NULL){
TmpCell=P->Next;
free(P);            //释放P之后将不能再调用该指针（即使用P->Next）所以引用一个额外的指针TmpCell
P=TmpCell;

}

}

栈

单链表实现

栈的定义

struct  Node;
typedef struct Node * PtrToNode;
typedef PtrToNode Stack;


struct Node{
ElementType Element;
PtrToNode  Next;   
};

创建一个空栈

Stack  CreateStack(){
Stack S;
S=malloc(sizeof(struct Node));

if(S==NULL)FatalError("out of space!!")  //空间满

S->Next =NULL;    //栈顶指向NULL
return S;

}

push

void Push(ElementType X,Stack S){
PtrToNode TmpCell;
TmpCell=malloc(sizeof(struct Node));
TmpCell->Element=X;
TmpCell->Next=S->Next;
S->Next=TmpCell;
}

pop

//获得栈顶元素
ElementType Top(Stack S){
if(!IsEmpty(S))return S->Next->Element;
else return 0;
}

//取栈顶元素
void Pop(Stack S){
PtrToNode  FirstCell;
if(!IsEmpty(S)return error;

else{
     FirstCell=S->Next; 
     S->Next=FirstCell->Next;
     free(FirstCell);
    }

}

数组实现

栈的定义

struct StackRecord;
typedef struct StackRecord* Stack;
#define EmptyTos (-1)
#define MinStackSize (5)

struct Stack{
int Capacity;  //数组容量
int TopOfStack;   //栈顶
ElementType *Array;  //指向数组头

};

创建一个空栈

//栈顶初始化
void  MakeEmpty(Stack S){
S->TopOfStack=EmptyOs;
}


Stack CreateStack(int MaxElements){
Stack S;

if(MaxElements<MinStackSize)return  Error;

S=malloc(sizeof(struct StackRecord));    //为栈顶指针分配结构体空间

if(S==NULL)Error("out of space!!");

S->Array=malloc(sizeof(ElementType)*MaxElements);  //为数组开辟指定空间大小

if(S->Array==NULL)Error("out of space !!");

S->Capacity=MaxElements;     //确定栈容量

MakeEmpty(S);   //栈顶初始化为-1

return S;      //返回栈顶
}

释放栈

//检验是否为空栈
int IsEmpty(Stack S){
return S->TopOfStack==EmptyOs;
}

void DisposeStack(Stack S){
if(S!=NULL){
free(S->Array);
free(S);
}

}

push

void Push(Stack S,ElementType X){
S->Array[++S->TopOfStack]=X;
}

pop

//返回栈顶元素
ElementType Top(Stack S){

if(!IsEmpty(S))return S->Array[S->TopOfStack];

else Error("Empty Stack!");

return 0;
}

void Pop(Stack S){
if(!IsEmpty(S))S->TopOfStack--;
}

队列

数组实现

队列的定义

struct QueueRecord;
typedef struct QueueRecord *Queue;

#define MinQueueSize(5)

struct QueueRecord
{
    ElementType *Array;   //指向数组头
    int Capacity;   //队列容量
    int  Front;     //队头
    int Rear;       //队尾
    int Size;       //当前大小
    

};

//判断是否为空
int IsEmpty(Queue Q){

return Q->Size==0;

}

创建一个空的队列

void MakeEmpty(Queue Q){
Q->Size =0;
Q->Front =1;
Q->Rear=0;
}

Queue  Create(int MaxElements){

Queue  Q;

if(MaxElements<MinQueueSize)return Error;

Q=malloc (sizeof(struct QueueRecord));    //为队列指针开辟空间

if(Q==NULL)Error("out of  space!!");

Q->Array=malloc(sizeof(ElementType)*MaxElements);

if(Q->Array==NULL)Error("out of space !!");

Q->Capacity=MaxElements;

MakeEmpty(Q);

return Q;



}

入队

//队列满判断
int IsFull(Queue Q){

return Q->Size==Q->Capacity;    //注意如果写Front-Rear==1既可以是空状态，也可以是满状态，所以引入变量Size方便统计当前的元素个数

}

//构成循环队列（数组）,队头（尾）前移操作
static int Succ (int value,Queue Q){
if(++value==Q->Capacity)

value=0;

return value;

}

void  Enqueue(ElementType X,Queue Q){
if(IsFull(Q))Error("Full Queue");

else{
Q->Size++;
Q->Rear=Succ(Q->Rear,Q);    //或者直接写Q->Rear=(Q->Rear+1)%Capacity;
Q->Array[Q->Rear]=X;
}

}

出队


void Dequeue(Queue Q){
Q->size--;
Q->Front=Succ(Q->Front,Q);
}
posted @ 2020-01-16 22:26  zzcxxoo  阅读(129)  评论(0)    收藏  举报