线性表
1.顺序表
linetable_array.h
#include <stdio.h>
#define max 100
#define ElemType int
struct List {
ElemType elements[max];
int last;
};
typedef int position;
//L.elements[p]
//L.last
void Insert(ElemType x, position p, List &L) {
position q;
if (L.last >= max - 1)
printf("The table is full.\n");
else if ((p > L.last + 1) || (p < 1))
printf("The position is illegal.\n");
else {
for (q = L.last; q >= p; --q) {
L.elements[q + 1] = L.elements[q];
L.elements[p] = x;
L.last++;
}
}
}
void Delete(position p, List &L) {
position q;
if (p > L.last || p < 1)
printf("The position is illegal.\n");
else {
L.last--;
for (q = p; q <= L.last; q++) {
L.elements[q] = L.elements[q + 1];
}
}
}
position Locate(ElemType x, List &L) {
position q;
for (q = 1; q <= L.last; q++) {
if (L.elements[q] == x)
return q;
}
return L.last + 1;
}
ElemType Retrieve(position p, List &L) {
if (p > L.last)
printf("The position is illegal.\n");
else
return L.elements[p];
}
ElemType Previous(position p, List &L){
if (p <= 1 || p > L.last + 1)
printf("The position is illegal.\n");
else
return p - 1;
}
ElemType Next(position p, List &L) {
if (p < 1 || p >= L.last + 1)
printf("The position is illegal.\n");
else
return p + 1;
}
position MakeNull(List &L){
L.last = 0;
return L.last + 1;
}
position First(List L){
if (L.last > 0)
return 1;
else
printf("The table is empty.\n");
}
position End(List L){
return L.last + 1;
}
2.链表
linetable_linktable.h
#include <stdio.h>
#include <stdlib.h>
#define ElemType int
struct celltype {
ElemType data;
struct celltype *next;
}link;
typedef struct celltype *List, *position;
void Insert(ElemType x, position p) {
position q;
q = (List)malloc(sizeof(link));
q->data = x;
q->next = p->next;
p->next = q;
}
void Delete(position p) {
position q;
if (p->next != NULL) {
q = p->next;
p->next = q->next;
free(q);
}
}
position Locate(ElemType x, List *L) {
List p;
p = L;
while (p->next != NULL) {
if (p->next->data == x)
return p;
p = p->next;
}
return p;
}
ElemType Retrieve(position p) {
return p->next->data;
}
position Previous(position p, List *L) {
position q;
if (p == L)
printf("The position is illegal.\n");
else {
q = L;
while (q->next != p) {
q = q->next;
}
return q;
}
}
position Next(position p) {
if (p->next == NULL)
printf("The position is illegal.\n");
else
return p->next;
}
position MakeNull(List L) {
L = (List)malloc(sizeof(link));
L->next = NULL;
return L;
}
position First(List L) {
return L;
}
position End(List L) {
position q;
q = L;
while (q->next != NULL)
q = q->next;
return q;
}
3.静态链表
static_linklist.h
#define max 100
#define ElemType int
typedef struct{
ElemType data;
int next;
}space;
typedef int position;
void Initialize(position *L, space s[], position *avail) {
for (int j = 0; j <= max - 1; ++j)
s[j].next = j + 1;
*avail = 0;
*L = 0;
}
position GetNode(position avail, space s[]) {
position p = s[avail].next;
s[avail].next = s[p].next;
return p;
}
void FreeNode(position p, space s[], position avail) {
s[p].next = s[avail].next;
s[avail].next = p;
}
void Insert(ElemType x, position p, space s[], position avail) {
position q = GetNode(avail, s);
s[q].data = x;
s[q].next = s[p].next;
s[p].next = q;
}
void Delete(position p, space s[], position avail) {
position q;
if (s[p].next != -1) {
q = s[p].next;
s[p].next = s[q].next;
FreeNode(q, s, avail);
}
}
position Locate(space s[], position L, position avail, ElemType x) {
if (L == avail)
return -1;
if (s[L].next == -1 && s[L].data == x)
return L;
else if (s[L].next == -1)
return -1;
do{
if (s[s[L].next].data == x)
return L;
L = s[L].next;
if (L == -1)
break;
} while (L != -1);
return -1;
}
4.双向链表
doubledir_link.h
#include <stdlib.h>
#include <stdio.h>
#define ElemType int
struct dcelltype {
ElemType data;
struct dcelltype *next, *prior;
}; /* 结点类型 */ /* 表和位置的类型 */
typedef struct dcelltype *DLIST, *position;
void Insert(ElemType x, position p, DLIST *L) {
DLIST s = (dcelltype *)malloc(sizeof(dcelltype));
s->data = x;
s->prior = p;
s->next = p->next;
p->next->prior = s;
p->next = s;
}
void Delete(position p, DLIST &L) {
if (p->prior != NULL)
p->prior->next = p->next;
if (p->next != NULL)
p->next->prior = p->prior;
free(p);
}
5.单向环形链表
roundlink.h
#include <stdio.h>
#include <stdlib.h>
#define ElemType int
typedef struct {
ElemType data;
struct celltype *next;
}link;
typedef link *List, *position;
List LInsert(ElemType x,link *R) {
List p;
p = (List)malloc(sizeof(link));
p->data = x;
if (R == NULL) {
p->next = p;
R = p;
}
else {
p->next = R->next;
R->next = p;
}
return p;
}
void RInsert(ElemType x, link *R) {
List q = LInsert(x, R);
R = R->next;
return q;
}
void Ldelete(link *R){
List p;
if (R == NULL)
printf("Error.\n");
else {
p = R->next;
R->next = p->next;
if (p == R)
R = NULL;
free(p);
}
}
栈
1.数组栈
stack.h
#define maxlength 1000
typedef char Element;//定义基础类型
typedef struct STACK {
int top;
Element ele[maxlength];
}STA;
bool empty(STA s) {//判断非空与否
return s.top == -1;
}
void makenull(STA *s) {//置栈为空
s->top = -1;
}
Element top(STA s) {//返回栈顶元素
if (empty(s)) {
return NULL;//栈为空返回为空
}
return s.ele[s.top];
}
Element pop(STA *s) {//弹出栈顶元素并且返回栈顶元素
Element ch = s->ele[s->top];
if (s->top < 0) {
makenull(s);//栈为空则置空并返回空
return NULL;
}
else {
s->top--;//出栈,返回原来栈顶元素
return ch;
}
}
void push(STA *s, Element x) {//压栈
s->ele[++s->top] = x;
}
2.链栈
stacklink.h
#include <stdlib.h>
#define ElemType int
struct node {
ElemType data;
struct node *next;
};
typedef struct node *STACK;
STACK MakeNull() {
STACK s;
s=(node *)malloc(sizeof(node));
s->next = NULL;
return s;
}
bool Empty(STACK stk) {
if (stk->next)
return false;
else
return true;
}
void Push(ElemType elm, STACK stk) {
STACK s;
s = (node *)malloc(sizeof(node));
s->data = elm;
s->next = stk->next;
stk->next = s;
}
void Pop(STACK stk) {
STACK s;
if (stk->next) {
s = stk->next;
stk->next = s->next;
free(s);
}
}
ElemType Top(STACK stk) {
if (stk->next)
return stk->next->data;
else
return NULL;
}
队列
1.数组队列
queue.h
#include <stdlib.h>
#include <stdio.h>
#define ElemType char
#define MaxSize 1000
struct QUEUE {
ElemType data[MaxSize];
int front;
int rear;
};
void MakeNull(QUEUE *Q) {
Q->front = MaxSize - 1;
Q->rear = MaxSize - 1;
}
bool Empty(QUEUE Q) {
if (Q.rear == Q.front)
return true;
else
return false;
}
ElemType Front(QUEUE Q) {
if (Empty(Q))
return NULL;
else {
return Q.data[(Q.front + 1) % MaxSize];
}
}
void EnQueue(ElemType x, QUEUE *Q) {
if ((Q->rear + 1) % MaxSize == Q->front)
printf("The queue is full.\n");
else {
Q->rear = (Q->rear + 1) % MaxSize;
Q->data[Q->rear] = x;
}
}
void DeQueue(QUEUE *Q) {
if (Empty(*Q))
printf("The queue is empty.\n");
else
Q->front = (Q->front + 1) % MaxSize;
}
2.链式队列
queuelink.h
#include <stdlib.h>
#include <stdio.h>
#define ElemType int
struct celltype {
ElemType data;
struct celltype *next;
};
struct QUEUE {
struct celltype *front;
struct celltype *rear;
};
void MAKENULL(QUEUE *Q) {
Q->front = (celltype *)malloc(sizeof(celltype));
Q->front->next = NULL;
Q->rear = Q->front;
}
bool EMPTY(QUEUE Q) {
if (Q.front == Q.rear)
return true ;
else
return false;
}
ElemType FRONT(QUEUE Q) {
if (Q.front->next)
return Q.front->next->data;
}
void EnQueue(ElemType x, QUEUE *Q) {
struct celltype* q = (celltype *)malloc(sizeof(celltype));
q->data = x;
q->next = NULL;
Q->rear->next = q;
Q->rear = q;
}
void DeQueue(QUEUE *Q) {
if (Q->rear == Q->front)
printf("The queue is empty.\n");
celltype *p = Q->front->next;
Q->front->next=p->next;
if (p->next==NULL)
Q->rear=Q->front;
free(p);
}
稀疏矩阵
三元组
#define max 100
struct three {
int row, col;//行 列
int data;
};
typedef struct reararr {
three a[max];
int m, n, x;//行,列,非零元个数
}M;
压缩存储(十字链表)
#define ElemType int
struct celltype {
int row; //存储非零元素的行号
int col; //存储非零元素的列号
ElemType item;//存储非零元素的值
struct celltype right;//指针域,指向同一行中的下一个三元组
struct celltype down;//指针域,指向同一列中的下一个三元组
};
广义表
struct listnode {
struct listnode *link;//连下一个
bool tag;//是否有广义表在里面
union {
char data;//数据
struct listnode *dlink;//连到里面的广义表
};
};
typedef listnode *listpointer;
bool Equal(listpointer S, listpointer T) {
bool x, y;
y = false;
if ((S == NULL) && (T == NULL))
y = true;
else if ((S != NULL) && (T != NULL)) {
if (S->tag == T->tag) {
if (!S->tag) {
if (S->data == T->data)
x = true;
else
x = false;
}
else
x = Equal(S->dlink, T->dlink);
if (x)
y = Equal(S->link, T->link);
}
}
return y;
}
ADT
栈的ADT
逻辑结构
ADT
Stack
栈:是一种特殊的线性表,数据元素之间的关系是线性关系,其插入,删除只能在表的一端进行(从0开始的一端为头),另一端固定不动。
Data
栈中元素具有相同类型(为char)及后进先出的特性
Operation
makenull
前置:栈存在
功能:清空栈,将栈置空
push
前置:栈存在
功能:将元素入栈
pop
前置:栈存在
功能:将栈顶元素出栈并删除,返回被删元素
top
前置:栈存在
功能:读取栈顶元素
empty
功能:判断栈是否为空,返回1,否则返回0
存储结构
采用的栈stack的为顺序存储结构——顺序栈,即把逻辑上相邻的节点存储在物理位置上相邻的存储单元中,结点之间的逻辑关系由存储单元的邻接关系来体现。代码中将该栈设置为数组实现,内部ele[]数组存储stack内容,相邻元素存储在相邻数组。具体代码如下:
将地址高端设为栈底,栈顶为地址低端
#define maxlength 1000
typedef char Element;//定义基础类型
typedef struct STACK {
int top;
Element ele[maxlength];
}STA;
判断栈是否为空
bool empty(STA s) {//判断非空与否
return s.top == -1;
}
将栈置空
void makenull(STA *s) {//置栈为空
s->top = -1;
}
返回栈顶元素
Element top(STA s) {//返回栈顶元素
if (empty(s)) {
return NULL;//栈为空返回为空
}
return s.ele[s.top];
}
弹出栈顶元素并且返回
Element pop(STA *s) {//弹出栈顶元素并且返回栈顶元素
Element ch = s->ele[s->top];
if (s->top < 0) {
makenull(s);//栈为空则置空并返回空
return NULL;
}
else {
s->top--;//出栈,返回原来栈顶元素
return ch;
}
}
压栈
void push(STA *s, Element x) {//压栈
s->ele[++s->top] = x;
}
队列的ADT
逻辑结构
ADT
Queue
队列:是一种特殊的线性表,数据元素之间的关系是线性关系,其一端插入,删除只能在表的另一端进行。
Data
队列中元素具有相同类型(为char)及先进先出的特性
Operation
q_makenull
清空队列,将队列置空
q_empty
判断队列是否为空
front
返回队首元素
enqueue
将元素入队尾
dequeue
将队首元素出队
存储结构
采用的队列queue为顺序存储结构——顺序栈,即把逻辑上相邻的节点存储在物理位置上相邻的存储单元中,结点之间的逻辑关系由存储单元的邻接关系来体现。代码中将该栈设置为数组实现,相邻元素存储在相邻数组。具体代码如下:
#define ElemType char
#define MaxSize 1000
struct QUEUE {
ElemType data[MaxSize];
int front;
int rear;
};
将队列置空
void MakeNull(QUEUE *Q) {
Q->front = MaxSize - 1;
Q->rear = MaxSize - 1;
}
判断队列是否为空
bool Empty(QUEUE Q) {
if (Q.rear == Q.front)
return true;
else
return false;
}
获得队首元素
ElemType Front(QUEUE Q) {
if (Empty(Q))
return NULL;
else {
return Q.data[(Q.front + 1) % MaxSize];
}
}
将元素入队
void EnQueue(ElemType x, QUEUE *Q) {
if ((Q->rear + 1) % MaxSize == Q->front)
printf("The queue is full.\n");
else {
Q->rear = (Q->rear + 1) % MaxSize;
Q->data[Q->rear] = x;
}
}
将队首元素出队
void DeQueue(QUEUE *Q) {
if (Empty(*Q))
printf("The queue is empty.\n");
else
Q->front = (Q->front + 1) % MaxSize;
}