数据结构基本操作代码集合

#include<stdio.h>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<ctype.h>

#include<string>

#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define Elemtype int 

typedef int Status;

//顺序表类型定义
 #define MAXSIZE
 
typedef struct{
  Elemtype *elem;
  int length;
}Sqlist;

//顺序表初始化
Status InitList(Sqlist &L){
  L.elem=new Elemtype[MAXSIZE];
  if(!L.elem){
    exit(OVERFLOW);
  }
  L.length=0;
  return OK;

}

void DestroyList(Sqlist &L){
  if(L.elem)
    delete []L.elem;
}

//judge empty and list.length
bool ListEmpty(Sqlist L){
  return L.length==0;
}

int ListLength(Sqlist L){
  return L.length;
}

//getElem

Status GetElem(SqList L,int i, Elemtype &e){
  if(i<1||i>L.length)
      return ERROR;
     
  e=L.elem[i-1];
  
  return OK;


}

//sqlist search  O(n)

int LocateElem(Sqlist L,Elemtype e){
  for(i=0;i<L.length-1;i++){
    if(L.elem[i-1]==e){
        return i+1;
      }
    return 0;
  }
}
//sqlist insert

Status ListInsert(Sqlist &L,int i,elemtype m){
  if(i<1||i>L.length)
    return ERROR;
   if(i.length==MAXSIZE)
     return ERROR;
   for(int j=L.length-1;j>=j-1;j—-){
     L.elem[j+1]=L.elem[j];
   }
   L.elem[j-1]=e;
   ++L.length;
   return OK;
   
}

//sqlist delete O(n)
Status ListDelete(Sqlist &L,int i){
  if(i<1||i>L.length)
    return ERROR;
   for(int j=i;j<=L.length;j++){
     L.elem[j-1]=L.elem[j];
   }
   L.length-—;
   
   return OK;
}


//define LinkList

typedef struct LNode{
  Elemtype data;
  struct LNode *next;
}LNode,*LinkList;

//init and judge empty linklist
Status InitList(LinkList &L){
  L=new LNode;
  L->next=NULL;
  return OK;
}

bool ListEmpty(LinkList L){
  return L->next==NULL;
}

//delete LinkList

Status DestoryList(LinkList &L){
  LinkList p;
  while(L){
    p=L;
    L=L->next;
    delete p;
  }
  return OK;
}

//get linklist length

int ListLength(LinkList L){
  LinkList p=L->next;
  int len=0;
  while(p){
    len++;
    p=p->next;
  }
  return len;
}


//getelem linklist i
Status GetElem(LinkList L,int i,Elemtype m){
//O(n)
  LinkList p=L->next;
  int j=1;
  while(p&&j<i){
    p=p->next;
    j++;
  }
  if(!p||j>i)
    return ERROR;
    e=p->data;
  return OK;
}

//LinkList search
//the return is the address of the node
LNode *LocateElem(LinkList L,Elemtype m){
  LNode *p=L->next;
  while(p&&p->data!=m)
    p=p->next;
  return p;
}

//LinkList insert
Status ListInsert(LinkList &L,int i,Elemtype e){
  LNode *p=L;
  int j=0;
  while(p&&j<i-1){
    p=p->next;
    j++;
  }
  if(!p||j>i-1)
    return ERROR;
  s=new LNode;
  s->data=e;
  s->next=p->next;
  p->next=s;
  return OK;
}

//linklist delete 

Status LinkListDelete(LinkList &L,int i;Elemtype &e){
  LNode *p=L,*q;
  int j=0;
  while(p&&j<i-1){
    p=p->next;
    j++;
  }
  if(!p->next||j>i-1)
    return ERROR;
    q=p->next;
    p->next=q->next;
    e=p->data;
    free(q);
  
  return OK;
}

//head insert and tail insert 
void CreateList_H(LinkList &L,int n){
  L=new LNode;
  L->next=NULL;
  for(int i=n;i>0;i—-){
    LNode *p=new LNode;
    cin>>p->data;
    p->next=L->next;
    L->next=p;
  }
}

void CreateList_T(LinkList &L,int n){
  LNode *r=L;
  for(int i=0;i<n;i++){
    LNode *p=new LNode;
    cin>>p->data;
    r->next=p;
    r=p;
  }
}

//conect two to one for a loop list
LinkList connect(LinkList *A,LinkList &B){
//presume A and B all none empty
  p=B->next->next;//p save first not head node in B
  delete B->next;//delete B's head node
  B->next=A->next;//let B link to A next which is A head
  A->next=p;//now B's first is p beacause B head is free
  return A=B;
}

//define double list
typedef struct DuLNode{
  Elemtype data;
  struct DuLNode *next;
  strcut DuLNode *prior;
  
}DuLNode,*DuLLinkList;
//DuLNode insert and delete
Status ListInsert(DuLinkList &L,int i,Elemtype e){
  if(!(p=GetElemtypeP_Dul(L,i)))
    return ERROR;
    s=new DuLNode;
    s->data=e;
    s->prior=p->prior;
    p->prior->next=s;
    s->next=p;
    p->prior=s;
    return OK;
}

Status ListDelete_DuL(DuLinkList &L,int i,Elemtype &e){
  if(!(p=GetElemtype_DuL(L,i)))
    return ERROR;
  e=p->data;
  p->prior->next=p->next;
  p->next->prior=p->prior;
  delete p;
  return OK;
}

//list application
//list merge
void MergeList(List &LA,List &LB){
//O(listlength(LA)*listlength(LB))
  m=listlength(LA);
  n=listlength(LB);
  for(i=1;i<=n;i++){
    GetElem(LB,i,e);
    if(!LocateElem(LA,e))
      ListInsert(LA,++m,e);
  }
}

//sqlist merge
/*
    question describe:there are two sorted list,connect
  and make a new sorted list;
*/

void MergeList_Sq(SqList LA,SqList LB,SqList &LC){
  int *pa,*pb,*pc,*pa_last,*pb_last;
  pa=LA.elem;
  pb=LB.elem;
  LC.length=LA.length+LB.length;
  LC.elem=new int[LC.length];
  pc=LC.elem;
  pa_last=LA.elem+LA.length-1;
  pb_last=LB.elem+LB.length-1;
  while(pa<=pa_last&&pb<=pb_last){
    if(*pa<=*pb)
      *pc++=*pa++;
    else
      *pc++=*pb++;
  }
  while(pa<=pa_last)
    *pc++=*pa++;
  while(pb<=pb_last)
    *pc++=*pb++;
}

/*
  new list from own node and release one node
*/
void MergeList_L(LinkList &LA,LinkList &LB){
  LinkList pa,pb,pc;
  pa=LA->next;
  pb=LB->next;
  LC=LA;
  pc=LC;
  while(pa && pb)
    if(pa->data<=pb->data){
      pc->next=pa;
      pc=pa;
      pa=pa-next;
    }else{
      pc->next=pb;
      pc=pb;
      pb=pb->next;
    }
  pc->next=pa?pa:pb;
  delete LB;
}  

//单链表存储多项式
typedef struct PNode{
  float coef;
  int expn;
  struct PNode *next;
}PNode,*Polynomial;

void CreatePolyn(Polynomial &P,int n){
  p=new PNode;
  P->next=NULL;
  for(int i=1;i<=n;i++){
    s=new PNode;
    cin>>s.coef>>s.expn;
    pre=P;
    q=P->next;
    while(q&&q->expn<s->expn){
      pre=q;
      q=q->next;
    }
    s->next=q;
    pre->next=s;
  }
}

void AddPolyn(Polynomial &pa,Polynomial &pb){
  float sum;
  Polynomial p1,p2,p3,r;
  p1=pa->next;
  p2=pb->next;
  p3=pa;
  while(p1&&p2){
    if(p1->expn==p2->expn){ //指数相等的情况
      sum=p1->coef+p2->coef;//系数相加
      if(sum!=0){//系数不为零，全部加到p1后让p3继承。
        p1->coef=sum;
        p3->next=p1;
        p1=p1->next;
        r=p2;
        p2=p2->next;
        delete r;
      }else{//系数为0，删除两个节点，让他们指向下一个节点。
        r=p1;
        p1=p1->next;
        delete r;
        r=p2;
        p2=p2->next;
        delete r;
      }
    }else if(p1->expn<p2->expn){//p1系数小，让p1向后寻找相同项
      p1=p1->next;
    }else{
      p3->next=p2;
      p3=p2;
      p2=p2->next;
    }
    
  }
  p3->next=p1?p1,p2;
  delete pb;
}

//define sqstuck
#define MAXSIZE 100
typedef struct{
	SElemtype *base;
	SElemtype *top;
	int stacksize;
}Sqstack;

//initial stack
Status InitStack(Sqstack &S){
	S.base=new SElemtype[MAXSIZE];
	if(!S.base)exit(OVERFLOW);
	S.top=S.base;
	S.stacksize=MAXSIZE;
	return OK;
}

//push sqstack
Status Push(Sqstack &S,SElemtype e){
	if(S.top-S.base==MAXSIZE)
		return ERROR;
	*(S.top)=e;
	S.top++;
	return OK;
}

//get top and pop
Status SqStack_Pop(Sqstack &S,SElemtype &e){
	if(S.top==S.base)
		return ERROR;
	e=*(S.top--);
	return OK;
}

Status GetTop(Sqstack S,SElemtype e){
	if(S.base==S.top)
		return ERROR;
	e=*(S.top-1);//***
	return OK;
}

//judge empty and delete stack
bool StackEmpty_Sq(Sqstack S){
	return S.top==S.base;
	
}

void DestroyStack(Sqstack &S){
	if(S.base){
		delete []S.base;
		S.stacksize=0;
		S.base=S.top=NULL;
	}
}

//linkstack 
typedef struct StackNode{
	SElemtype data;
	struct StackNode *next;
}StackNode,*LinkStack;

LinkStack S;

//init linkstack
Status InitLinkStack(LinkStack &S){
	S=NULL;
	return OK;
}

//push linkstack
Status Push(LinkStack &S,SElemtype e){
	p=new LinkStack;
	p->data=e;
	p->next=S;
	S=p;
	return OK;
}
//getpop
Status GetPop(LinkStack S,SElemtype e){
	if(S==NULL)
		return ERROR;
	e=S->data;
	return OK;
}

//pop
Status LinkStack_Pop(LinkList &S,SElemtype &e){
	if(S==NULL)
		return ERROR;
	e=S->data;
	p=S;
	S=p->next;
	delete p;
	return OK;
	
}

//judge empty and destroy
Status StackEmpty_Link(LinkStack S){
	return S==NULL;
}

void Destroy(LinkStack &S){
	while(S){
		LinkStack p=S;
		S=S->next;
		delete p;
	}
}

//application of stack

/*
	number system conversion
*/
int index,n,digits[40]
while(scanf("%d",&n)!=EOF){
	index=-1;
	while(n){
		digits[++index]=n%2;
		n/=2;
	}
	while(index>=0)
		printf("%d",digits[index--]);
	printf("\n");
}

/*
	10->8
*/
void Conversion(int N){
	InitStack(S);
	while(N){
		Push(S,N%8);
		N=N/8;
	}
	while(StackEmpty_Link(S)){
		LinkStack_Pop(S,e);
		cout<<e;
	}
	DestroyStack(S);
	
}
//recursion qp->2
void Conversion_re(int N){
	if(N){
		Conversion(N/2);
		cout<<N%2;
	}
}

//queue
//define sqqueue
typedef struct{
	QElemtype *base;
	int front;
	int rear;
}SqQueue;

//init queue and isempty
Status InitSqQueue(SqQueue &Q){
	Q.base=new QElemtype[MAXSIZE];
	if(Q.base)
		exit(OVERFLOW);
	Q.front=Q.rear=0;
	return OK;
}

bool Queue_IsEmpty(SqQueue Q){
	return Q.front==Q.rear;
}

//enqueue and dequeue
Status EnQueue(SqQueue &Q,QElemtype e){
	if((Q.rear+1)%MASIZE==front)
		return ERROR;
	Q.base[rear]=e;
	Q.rear=(Q.rear+1)%MAXSIZE;
	return Ok;
}

Stauts DeQueue(SqQueue &Q,QElemtype &e){
	if(Q.front==Q.rear)
		return ERROR;
	e=Q.base[front];
	Q.front=(Q.front+1)%MAXSIZE;
	return OK;
}

//queue length and destroy
int Queue_length(SqQueue Q){
	return (Q.rear-Q.front+MASIZE)%MAXSIZE;
}

void Destroy_SqQueue(SqQueue &Q){
	if(Q.base)
		delete []Q.base;
	Q.base=NULL;
	Q.front=Q.rear=0;
	
}

//linkQueue
typedef struct QNode{
	QElemtype data;
	struct QNode *next;
}QNode,*Queueptr;

typedef struct{
	Queueptr front;
	Queueptr rear;
}LinkQueue;

//init queue and isempty queue

Status InitLinkQueue(LinkQueue &Q){
	Q.front=Q.rear=new QNode;
	Q.front->next=NULL;
	return OK;
}

Status QueueEmpty(LinkQueue Q){
	return Q.front==Q.rear;
}

//linkqueue enqueue and dequeue
Status EnLinkQueue(LinkQueue &Q,QElemtype e){
	p=new QNode;
	p->data=e;
	p->next=NULL;
	Q.rear->next=p;
	Q.rear=p;
	return OK;
}
//the front is link to before one of the fist data(***)
Status DeLinkQueue(LinkQueue &Q,QElemtype &e){
	if(Q.rear==Q.front)
		return ERROR;
	p=Q.front->next;
	e=p->data;
	Q.front->next=p->next;//***
	if(Q.rear==p)
		Q.rear=Q.front;
	delete p;
	return OK;

}

//destroy linkqueue
Status DestroyLinkQueue(LinkQueue &Q){
	while(Q.front){
		Q.rear=Q.front->next;
		delete Q.front;
		Q.front=Q.rear;
	}
	return OK;b
		
}