陈姥姥数据结构笔记（堆栈，线性表）

一.线性表(数组实现）

#include<stdio.h>
#define MAXSIZE n//此时的n为具体的一个数，由于时多形数据类型，所以在此写成了n。 

typedef struct LNode*list;//注意此时typedef之后的 list 再次定义时为一个指针。 
struct LNode{
	ElementType Data[MAXSIZE];//注意变量在命名时首字母大写，定义宏时通常字母全部大写 。
	int Last;//此时的ElementType为多形数据类型（polymorphic data type） 
};
struct LNode L;//定义一个结构体
List ptrL;//因为定义的为一个指针所以在这里用了指针的缩写来标志定义的是一个指针 ptr为pointer的缩写。 


int main ()
{
	
	
   	
    return 0;
}

	//建立空的线性表
	List MakeEmpty()
	{
		List PtrL;
		PtrL = (List)malloc(sizeof(struct LNode)) ;
		PtrL -> Last = -1;//Last表示在这个数组中储存元素的最后一个下标。 
		return PtrL;
	}
	
	//查找（按数值查找） 
	int Find (List *PtrL,ElementType X)
	{
		int i=0;
		while(PtrL->Data[i]!=X && i<=Ptr->Last){//一定要注意检查边界。 
			i++;
		}
		if(i<=Ptr->Last){
			return i;
		}else return -1;
	}
	
	//插入（第i（1<=i<=n+1）个位置上插入一个值为X的新元素） 
	void Insert(List *PtrL, ElementType X,int i)
	{
		if(PtrL->Last=MAXSIZE-1){//边界检查很常见也很重要 
			printf("表满！");
			return 0; 
		}
		if(i>PtrL->Last+2||i<1){//插入位置是否正常。 
			printf("插入位置出现异常！");
			return 0; 
		}
		int j,temp;
		for (j=PtrL->Last ; j>=i-1; j--){
			//temp=PtrL->Data[j]; PtrL->Data[j]=PtrL->Data[j+1]; PtrL->Data[j+1]=temp;完全可以不用交换；直接依次向后赋值即可。
			PtrL->Data[j+1]=PtrL->Data[j]; 
		}
		PtrL->Data[i-1]=X;
		PtrL->Last++;//注意Last时刻指向最后一个元素下标； 
		return 0;
	}
	
	//删除（删除表的第i（1<=i<=n）个位置上的元素）
	void Delete(List *PtrL, int i)
	{
		if(PtrL->Last<i-1||i<1){
			printf("删除位置出现异常"); 
			return 0;
		}
		int j;
		for (j=i-1;j<PtrL->Last; j++){
			PtrL->Data[j]=PtrL->Data[j+1];
		}
		return 0;
	} 

二. 线性表（链表）

#include<stdio.h>
typedef struct LNode *List;
struct LNode{
	ElementType Data;
	List Next;
};
struct Lnode L;
List PtrL;


int main ()
{
	return 0;
}

//求表长
int Length (List PtrL)
{
	List p=PtrL;//在此时定义一个新的指针是一个好习惯 
	int i=0;
	while(List->Next!=NULL){
		p=p->Next;
		i++;
	}
	return i;
 } 
 
 //查找
 //按序号查找
 List FindKth(List PtrL,int K)
 {
 	List p=PtrL;
 	int j=1;//此处表明p的当前指向为第一个 
 	while (p->Next!=NULL&&j<K){//注重对代码的理解 
 		j++;
 		p=p->Next;
	 }
	 if(p->Next!=NULL)
	 return p;
	 else return NULL;//注意此时只能return  NULL因为返回类型为List。 
 }
 //按值查找
 List FindValue( List PtrL, ElementType X)
 {
 	List p=PtrL;
 	while (p->Data!=X&&p->Next!=NULL){//链表不空，没找到，一共两个条件 
 		p=p->Next;
	 }
	 return p;
  } 
  
  
  //插入（在第i-1（1<=i<=n+1）个结点后插入一个值为X的新结点）插入第i个位置。
  List Insert(List PtrL,int i,ElementType X)
  {
  	List p,s;
  	if(i==1){
  		p=(List)malloc(sizeof(struct LNode));
  		p->Next=PtrL;
  		p->Data=X;
  		return p;
	  }
	p = FindKth( PtrL,i-1);
	if(p){
		s=(List)malloc(sizeof(struct LNode));
		s->Data=X;
		s->Next=p->Next;
		P->Next = s;
		return PtrL;
	}else{
		printf ("参数出错");
		return NULL; 
	}
   } 
   
   //删除链表的第i（1<=i<=n)个位置上的结点
   List Delete (int i, List PtrL)
{
	List p,s;
	if(i==1){
		s=PtrL;
		if(s!=NULL){//一定要特殊考虑第一个结点 
			PtrL=PtrL->Next;
			free (s);
			return PtrL;
		}else return NULL;
	}
	p=FindKth (PtrL,i-1);
	if(p==NULL){
		printf("第%d个结点不存在",i-1); return NULL;
	}else if(p->Next=NULL){//容易忘记检查p->Next是否为空。 
		printf("第%d个结点不存在",i); return NULL;
	}
	s=p->Next;
	p->Next=s->Next;
	free(s);
	return PtrL;
 } 

三. 广义表

1. 广义表时线性表的推广
2. 对于线性表而言，n个元素都是基本的单元素。
3. 广义表中，这些元素不仅可以是单元素也可以是另一个广义表。

会遇到如下问题：对于一个域来讲他是一个单元素还是广义表？
就要用到union，同时设一个标记来表示它到底是data还是sublist。

四. 多重链表
概念：多重链表中结点的指针域有多个。表中的结点可能同时隶属于多个链。

五. 后缀表达式求值：从左向右扫描，逐个处理运算数和运算符。实际上遵循的是堆栈原理。

六.堆栈

#include<stdio.h>
#define MaxSize n//写上具体数值 
typedef struct SNode *Stack;//同样定义的是指针,S代表stack 
struct SNode{
	ElementType Data[MaxSize];
	int Top;//栈顶的下标 
}; 
 
 
//入栈
void Push(Stack PtrS, ElementType Item)
{
	if(PtrS->Top==MaxSize-1){
		printf("栈满");
	}else {
		PtrS->Data[++(PtrS->Top)]=Item;//注意自加的位置
	}
	return 0;
 } 
 
 //出栈
 ElementType  Pop(Stack PtrS )
 {
 	ElementType a;
 	if(PrtS->Top==0){
 		printf ("堆栈空");
		 return ERROR;//ERROR 表示标志错误 
	 }else 
	 return (PtrS->Data[(PtrS->Top)--]);//注意自减的位置 
 }
 
 // 堆栈的链式储存
 //需要注意的是如果用链表实现他的top在链表的头上
 typedef struct SNode *Stack;
 struct SNode{
 	ElementType Data;
 	struct SNode *Next ;
 }; 
 
 //创建一个空的堆栈 
 //需要注意的是堆栈的建立保留了头结点
 Stack CreateStack()
 {
 	Stack S;
 	S = (Stack)malloc(sizeof (struct SNode));
 	S->Next=NULL;
 	return S;
 }
 
 //检查堆栈是否为空
 //若为空返回整数1，否则返回整数0；此时就可以考虑到条件表达式
 int IsEmpty (Stack S)
 {
 	return (S->Next==NULL);
  } 
 
 //插入结点
 void Push (ElementType item ,Stack S)
 {
 	Stack Tmp=(Stack)malloc(sizeof (struct SNode));
 	Tmp->Data=item;
 	Tmp->Next=S->Next;
 	S->Next=Tmp;
  } 
 
 //pop操作
 ElementType Pop(Stack S)
 {
 	Stack FirstCell;
 	ElementType TopElem
 	if(IsEmpty){
 		printf("堆栈空");
		 return NUll; 
	 }else {
	 	FirstCell = S->Next;
	 	S->Next=FirstCell->Next;
	 	FirstCell->Data=TopElem;
	 	free (FirstCell);
	 	return TopElem;
	 }
	 
  }