数据结构代码块

1 栈-[应用]（定义栈，初始化栈，判空，入栈，出栈）

1.1 顺序栈

栈的顺序存储类型

#define MaxSize 50
typedef struct{
	Elemtype data[MaxSize];
	int top;//栈顶指针
}SqStack；

初始化栈

void InitStack(SqStack &S){
	S.top=-1;
}

判断栈是否为空

bool StackEmpty(SqStack S){
	if(S.top==-1)
		return true;
	else 
		return false;
}

入栈

bool Push(SqStack &S,ElemType x){
	if(S.top==MaxSize-1)
		return false;
	S.data[++S.top]=x;
	return true;
}

出栈

bool Pop(SqStack &S,ElemType &x){
	if(S.top==-1)
		return false;
	x=S.data[S.top--];
	return true;
}

读栈顶元素

bool GetTop(SqStack S,ElemType &x){
	if(S.top==-1)
		return false;
	x=S.data[S.top];
	return true;
}

1.2 链栈（单链，栈顶在链头）

定义栈结点

typedef struct SNode{
	ElemType data;
	struct SNode *next;
}SNode *LiStack; 

初始化栈

bool InitStack(LiStack &S){
	S=(SNode*)malloc(sizeof(SNode));//分配一个头结点
	S->next=NULL;
	return true;
}

判断栈是否为空

bool StackEmpty(LiStack S){
	if(S->next==NULL)
		return true;
	else 
		return false;
}

入栈（头插法）

bool Push(LiStack &S,ElemType x;){
	SNode P=(SNode*)malloc(sizeof(SNode));//新分配一个结点
	P->data=x;
	P->next=S->next;
	S->next=P->next;
	return true;
}

出栈，（先进后出）

bool Pop(LiStack &S,ElemType &x){
	if(S->next==NULL) return false;//栈为空，也可以if(StackEmpty(S)) return false;
	SNode *P=S->next;//栈不空，链头结点出栈
	x=P->data;
	S->next=P->next;
	free(P);
	return true;
}

2 队列-[应用]（定义，出队，入队，判空，判满）

2.1 顺序存储队列

队列的顺序存储类型

#define MaxSize 50
typedef struct{
	ElmeType data[MaxSize];
	int front,rear;//队头指针和队尾指针
}SqQueue

初始化

void InitQueue(SqQueue &Q){
	Q.front=Q.rear=0;//初始化队头和队尾指针
}

判队空

bool QueueEmpty(SqQueue Q){
	if(Q.front==Q.rear)
		return true;
	else 
		return false;
}

入队

bool EnQueue(SqQueue &Q,ElemType x){
	if((Q.rear+1)%MaxSize==Q.front)
		return false;//队满
	Q.data[Q.rear]=x;
	Q.rear=(Q.rear+1)%MaxSize;//队尾指针加一取模
	return true;
}

出队

bool DeQueue(SqQueue &Q,ElemType &x){
	if(Q.rear==Q.front)
		 return false;//队空报错
	x=Q.data[Q.front];
	Q.front=(Q.front+1)%MaxSize;//队头指针加一
	return true;
}

2.2队列的链式存储结构

队列的链式存储类型

//链式队列结点
typedef struct LinkNode{
	ElemType data;
	struct LinkNode *next;
}LinkNode;

//链式队列
typedef struct{
	LinkNode *front,*rear;//队列的队头和队尾指针
}LinkQueue；

初始化

void InitQueue(LinkQueue &Q){
	Q.front=(LinkNode *)malloc(sizeof(LinkNode));//建立头结点
	Q.front=NULL;//初始为空
}

判队空

bool QueueEmpty(LinkQueue Q){
	if(Q.front==NULL)
		return true;
	else
		return false;
}

入队

bool EnQueue(LinkQueue &Q,ElemType x){
	LinkNode *s=(LinkNode *)malloc(sizeof(LinkNode));
	s->data=x;
	s->next=NULL;//插入到链尾
	Q.rear->next=s;
	Q.rear=s;
	return true；
}

出队

bool DeQueue(LinkQueue &Q,ElemType &x){
	if(Q.front->next==NULL)//Q.front==Q.rear
		return false;
	LinkNode *p=Q.front->next;
	x=p->data;
	Q.front->next=p->next;//删除头结点指向的指针；
	if(Q.rear==p){
		Q.rear=Q.front;
	}
	free(p);
	return true;	
}

3 数组-[算法]

3.1快速排序

void Qsort(int A[],L,R){//数组A保存数据，L，R是边界
	if(L>=R)
		return;//当区间元素个数<=1时，退出
	int pivot,i=L,j=R;
	pivot=A[L];//pivot,枢轴（基准）
	while（i<j）{
		while(i<j&&A[j]>=pivot)
			j--;
		while(i<j&&A[i]<=pivot)
			i++;
		if(i<j)
			Swap(A[i],A[j]);		
	}	
	Swap(pivot,A[i]);
	Qsort(A,L,i-1);//递归处理左区间
	Qsort(A,i+1,R);//递归处理右区间
}

空间效率，时间效率

3.2 归并排序

ElemType *B=(ElemType *)malloc((n+1)sizeof(ElemType));//辅助数组B
void Merge(ElemType A[], int low,int mid,int high){//表的两端A[low，mid]，A[mid+1,high]各自有序，将它们合并成一个有序表
	for (int k=low;k<=high;k++)
		B[k]=A[K];//将A中的所有元素复制到B
	for(int i=low,j=mid+1,k=i;i<=mid&&j<=high;k++){
		if(B[i]<=B[j])
			A[k]=B[i++];
		else
			A[k]=B[j++];
	}
	while(i<=mid) A[k++]=B[i++];//第一个表未检测完，复制
	while(j<=high) A[k++]=B[j++];//第二个表未检测完，复制
	//两个while只会执行一个
}
//合并子表
void MergeSort(ElemType A[],int low,int high){
	if(low<high){
		int mid=(low+high)/2;
		//从中间划分两个子序列
		MergeSort(A,low,mid);//MergeSort(ElemType A[],int low,int mid);
		//对左侧子序列进行递归排序
		MergeSort(A,mid+1,high);//MergeSort(ElemType A[],int mid+1,int high);
		//对左侧子序列进行递归排序
		merge(A,low,mid,high);
		//归并
	}
}

3.3排序拓展

3.4 折半查找

折半查找又称二分查找，它仅适用于有序的顺序表

int Binary_Search(SeqList L,ElemType key){
	int low=0,high=L.TableLen-1,mid;
	while(mid<=high){
		mid=(low+high)/2;
		if(L.elem[mid]==key)
			return mid;//查找成功返回所在位置
		else if(L.elem[mid]>key)
			high=mid-1;//从前半部分继续查找
		else
			low=mid+1;//从后半部分继续查找
	}
	return -1;//查找失败，返回-1
}