학습 노트 (1) - 상용 데이터 구조 정의:

학습 노트 (1) - 상용 데이터 구조 정의:
선형 표 {순서 표, 단일 체인 표, 정적 단일 체인 표, 양 방향 링크}; 
창고 {순서 창고};
대기 열 {단일 체인 대기 열, 순환 대기 열};
문자열 {긴 순서 문자열, 동적 순서 문자열, 블록 체인 문자열};
배열 {순서 배열};
희소 행렬 {3 원 그룹 순서 표, 행 논리 링크 순서 표, 십자 링크};
일반화 표 {두미 링크, 확장 선형 링크};
이 진 트 리 {순서, 체인, 단서};
나무 {부모 표시, 아이 표시, 아이 형제 표시};
그림 {인접 행렬, 인접 표, 십자 링크, 인접 다 중 표};
*********************************************************************************************************
선형 표 (순서, 동적 분배):

typedef struct {
	ElemType	*elem;			//  
	int		length;			//    
	int		listsize;		//    
}SqList;

SqList L.elem = (ElemType *)malloc(LIST_SIZE * sizeof(ElemType));

선형 표 (단일 링크):

typedef struct	LNode{
	ElemType	data;
	struct LNode	*next;
}LNode,*Link;				// Link        
typedef struct{
	Link		head,tail;
	int		len;
}LinkList;

선형 표 (정적 단일 체인 표):

typedef struct{
	ElemType	data;
	int		cur;		//cur     ，    “  ”
}component,SLinkList[MAXSIZE];

선형 표 (양 방향 링크):

typedef struct DuLNode{
	ElemType	data;
	struct DuLNode	*prior;
	struct DuLNode	*next;
}DuLNode,*DuLinkList;

스 택 (순서):

typedef struct{
	ElemType	*base;
	ElemType	*top;
	int		stacksize;
}SqStack;
SqStack S.base = (ElemType *)malloc(STACK_SIZE * sizeof(ElemType));
S.top = S.base;

대기 열 (단일 체인):

typedef struct QNode{		//         
	ElemType	data;
	struct QNode	*next;
}QNode,*QueuePtr;
typedef struct{
	QueuePtr	front;		//        
	QueuePtr	rear;
}LinkQueue;

대기 열 (순환, 순서):

typedef struct{
	ElemType	*base;
	int		front;		//           “  ”
	int		rear;
}SqQueue;
SqQueue Q.base = (ElemType *)malloc(QUEUE_SIZE * sizeof(ElemType));

문자열 (순서, 길이):

typedef unsigned char SString[MAXSTRLEN + 1];		//a.str[0]    ; b.str[STRLEN] '\0'

문자열:

typedef struct{
	char		*ch;
	int		length;
}HString;
HString T.ch = (char *)malloc(i * sizeof(char));

문자열 (블록 체인):
여러 순서 표 로 구 성 된 링크...

typedef struct Chunk{
	char		ch[CHUNKSIZE];
	struct Chunk	*next;
}Chunk;
typedef	struct{
	Chunk		*head,*tail;
	int		curlen;			//    
}LString;

배열 (순서):

typedef struct{
	ElemType	*base;
	int		dim;			//  
	int		*bounds;		//    ?
	int		*constants;		//      ?
}Array;
Array A.bounds = (int *)malloc(dim * sizeof(int));
A.base = (ElemType *)malloc(eletotal * sizeof(ElemType));
A.constants = (int *)malloc(dim * sizeof(int));

희소 행렬 (삼원 조 순서 표):
0 원 이 아 닌 것 만 기록...

typedef struct{
	int		i,j;
	ElemType	e;
}Triple;					//    
typedef struct{
	Triple		data[MAXSIZE + 1];		// 0     
	int		mu,nu,tu;				//  ，  ， 0  
}TSMatrix;

희소 행렬 (행 논리 링크 순서 표):

typedef struct{
	Triple		data[MAXSIZE + 1];
	int		rpos[MAXRC + 1];		//      0    
	int		mu,nu,tu;
}RLSMatrix;

희소 행렬 (십자 링크):

typedef struct OLNode{
	int		i,j;
	ElemType	e;
	struct OLNode	*right,*down;		// /        
}OLNode,*OLink;
typedef struct{
	OLink		*rhead,*chead;		// /     
	int		mu,nu,tu;
}CrossList;

광의 표 (머리 꼬리 링크):

typedef enum	{ATOM,LIST}ElemTag;
typedef struct GLNode{
	ElemTag		tag;
	union{
		AtomType		atom;
		struct{struct GLNode	*hp,*tp;}ptr;		//ptr       ，ptr.hp/ptr.tp        
	};
}*GList;								//              

일반화 표 (확장 선형 링크):

typedef enum	{ATOM,LIST}ElemTag;
typedef struct GLNode{
	ElemTag		tag;
	union{
		AtomType	atom;
		struct GLNode	*hp;
	};
	struct GLNode	*tp;			//       
}*GList;								//          

이 진 트 리 (순서):

typedef ElemType	SqBiTree[MAX_SIZE];		//      

이 진 트 리 (체인 식):

typedef struct BiTNode{
	ElemType		data;
	struct BiTNode		*lchild,*rchild;
}BiTNode,*BiTree;

두 갈래 나무 (단서):
잎 노드 에 사용 되 지 않 는 지침 을 후계 로...

typedef	enum	PointerTag{Link,Thread};
typedef struct BiThrNode{
	ElemType		data;
	struct BiThrNode	*lchild,*rchild;
	PointerTag		LTag,RTag;
}BiThrNode,*BiThrTree;

나무 (부모, 순서):

typedef struct PTNode{
	ElemType	data;
	int		parent;
}PTNode;
typedef struct{
	PTNode		nodes[MAX_SIZE];
	int		r,n;		//    ，   
}PTree;

나무 (아이 링크):

typedef struct CTNode{
	int		child;
	struct CTNode	*next;
}*ChildPtr;
typedef struct{
	ElemType	data;
	ChildPtr	firstchild;
}CTBox;
typedef struct{
	CTBox		nodes[MAX_SIZE];
	int		n,r;
}CTree;

트 리 (이 진 링크):

typedef struct CSNode{
	ElemType		data;
	struct CSNode		*firstchild,*nextsibling;
}CSNode,*CSTree;

Huffman 나무:

typedef struct{
	unsigned int	weight;
	unsigned int	parent,lchild,rchild;
}HTNode,*HuffmanTree;			//      
typedef char ** HuffmanCode;	//      

그림 (인접 행렬):

typedef enum	{DG,DN,UDG,UDN}GraphKind;		//   ，   ，   ，   
typedef struct ArcCeil{
	VRType		adj;		//       
	InfoType	*info;
}ArcCeil,AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];	//         
typedef struct{
	VertexType	vexs[MAX_VERTEX_SIZE];			//  
	AdjMatrix	arcs;
	int		vexnum,arcnum;					//  ，  
	GraphKind	kind;
}MGraph;

그림 (인접 표):

typedef struct ArcNode{
	int			adjvex;				//          
	struct ArcNode		*nextarc;
	InfoType		*info
}ArcNode;
typedef struct VNode{
	VertexType		data;
	ArcNode			*firstarc;
}VNode,AdjList[MAX_VERTEX_NUM];			//           
typedef struct{
	AdjList			vertices;
	int			vexnum,arcnum;
	int			kind;
}ALGraph;

방향 그래프 (십자 링크) 가 있 습 니 다.

typedef struct ArcBox{
	int			tailvex,headvex;			//      
	struct ArcBox		*hlink,*tlink;				//  /   
	InfoType		*info;
}ArcBox;
typedef struct VexNode{
	VertexType		data;
	ArcBox			*firstin,*firstout;			//    ，    
}VexNode;
typedef struct{
	VerNode			xlist[MAX_VERTEX_SIZE];
	int			vexnum.arcnum;
}OLGraph;

그림 (다 중 표 인접):
십자 링크 와 거의 같은...

typedef enum	{unvisited,visited}VisitIf;
typedef struct EBox{
	VisitIf			mark;
	int			ivex,jvex;
	struct EBox		*ilink,*jlink;
	Infotype		*info;
}EBox;
typedef struct VexBox{
	VertexType		data;
	EBox			*firstedge;
}VexBox;
typedef struct{
	VexBox			adjmulist[MAX_VERTEX_SIZE];
	int			vexnum,arcnum;
}AMLGraph;