数据结构
一、线性表
A.顺序表
数据结构设计
typedef struct
{
DATATYPE buf[MAX];
int n;
}SEQLIST;
1.插入元素(seq)
seq->buf[seq->n] = data;
2.按位置插入(seq,post,data)
mov_n = seq->n + 1 - post + 1
for(i = seq->n; mov_n > 0; i --,mov_n --)
{
seq->buf[i+1] = seq->buf[i]
}
seq->buf[post-1] = data;
3.删除一个指定的元素(seq,key)
for(i = 0,j = 0;i <= seq->n ;i ++)
{
if(seq->buf[i] != key)
seq->buf[j++] = seq->buf[i];
}
seq->n = j - 1;
B.链表
数据结构的设计
typedef struct node
{
DATATYPE data;
struct node *next;
}LINKLIST;
1.创建
a.分配头结点(head)
b.head->next = NULL;
c.return head;
2.头插法
struct node *temp;
temp = (struct node *)malloc(sizeof(struct node));
temp->data = data;
temp->next = head->next;
head->next = temp;
3.尾插法
思想:遍历到链表的尾部
struct node *p = head;
while(p->next != NULL) p = p->next;
p->next = temp;
temp->next = NULL;
//1 4 6 7
4.按序插入
struct node *p = head;
while(p->next != NULL && p->next->data < data) p = p->next;
temp->next = p->next;
p->next = temp;
//1 2 4 8 9
5.删除一个指定的元素
struct node *p = head;
while(p->next != NULL && p->next->data != data) p = p->next;
temp = p->next;
p->next = temp->next;
free(temp);
6.逆置一个链表
struct node *p = head;
struct node *q = p ->next;
struct node *current;
current = q->next;
q->next = NULL;
while(current)
{
p = current->next;
current->next = head->next;
head->next = current;
current = p;
}
7.链表的遍历
struct node * p = head->next;
while(p)
{
printf("%d ",p->data);
p = p->next;
}
C.顺序栈
数据结构设计
typedef struct
{
DATATYPE buf[MAX];
int top;//记录栈顶元素的位置
}STACK;
1.create_empty_stack()
{
STACK *s;
s = malloc();
s->top = -1;
}
2.push_stack(STACK *s,DATATYPE data)
{
a.判满
b.s->top ++;
s->buf[s->top] = data;
}
3.DATATYPE pop_stack(STACK *)
{
a.判空
data = s->buf[s->top];
s->top --;
b.return data;
}
D.链式栈
数据结构设计
struct node
{
DATATYPE data;
struct node *next;
};
typedef struct
{
struct node *top;
int n;
}STACK;
1.create_empty_stack()
STACK *s = (STACK *)malloc(sizeof(STACK));
s->top = NULL;
s->n = 0;
2.push_stack(STACK *s,DATATYPE data)
{
struct node *temp;
temp = malloc();
temp->data = data;
temp->next = s->top;
s->top = temp;
s->n ++;
return 0;
}
判空
is_empty_stack
{
//return s->top == NULL ? 1 : 0;
return s->n == 0 ? 1 : 0;
}
3.DATAYPE pop_stack(STACK *s)
{
struct node *temp;
DATATYPE data;
temp = s->top;
data = temp->data;
s->top = temp->next;
free(temp);
s->n --;
return data;
}
E.队列
循环队列数据结构设计
typedef struct
{
DATATYPE buf[MAX];
int front;
int rear;
}QUEUE;
规定
队空:q->front == q->rear;
队满:(q->rear + 1) % MAX == q->front;
1.create_queue
q = malloc();
q->front = q->rear = 0;
2.入队
a.判满
q->buf[q->rear] = data;
b.
q->rear = (q->rear + 1) % MAX;
3.出队
a.判空
b.
data = q->buf[q->front];
q->front = (q->front + 1) % MAX;
return data;
链式队列
数据结构设计
struct node
{
DATATYPE data;
struct node *next;
}
typedef struct
{
struct node *front;
struct node *rear;
}QUEUE;
1.create_empty_queue()
a.分配链表的头
head = (struct node *)malloc(sizeof(struct node));
head->next = NULL;
b.分配队列的头
q = (QUEUE *)malloc(sizeof(QUEUE));
q->front = q->rear = head;
return q;
2.EnterQueue()
temp = (struct node *)malloc(sizeof(struct node));
temp->data = data;
q->rear->next = temp;
q->rear = temp;
temp->next = NULL;
3.DeleteQueue()
a.判空
b.struct node *temp;
temp = q->front;
q->front = temp->next;
free(temp);
return q->front->data;
二、非线性表
A.树(二叉树)
数据结构设计
typedef struct TreeNode
{
DATATYPE data;
struct TreeNode *lchild;
struct TreeNode *rchild;
}BITREE;
1.创建完全二叉树
BITREE *create_binary_tree(int n)
{
BITREE *root;
root = space_node(1);
push_stack(s,root);
while(!is_empty_stack(s))
{
tree = pop_stack(s);
if(2 * tree->data <= n)
{
tree->lchild = space_node(2 * tree->data);
push_stack(tree->lchild);
}
if(2 * tree->data + 1 <= n)
{
tree->rchild = space_node(2 * tree->data + 1);
push_stack(tree->rchild);
}
}
return root;
}
//n = 1
BITREE *_create_binary_tree(int n)
{
BITREE *root;
root = space_node(n);
if(2 * root->data <= N)
root->lchid = _create_bianry_tree(2 * root->data);
if(2 * root->data + 1<= N)
root->rchid = _create_bianry_tree(2 * root->data + 1);
return root;
}
2.遍历二叉树
a.前序遍历
PreOrder(BITREE *tree)
{
if(tree == NULL)
return;
printf("%d ",tree->data);
PreOrder(tree->lchild);
PreOrder(tree->rchild);
}
b.层次遍历
NoOder(BITREE *tree)
{
q = create_empty_queue();
EnterQueue(q,tree);
while(!is_empty_queue(q))
{
tree = DeleteQueue(q);
printf("%d",tree->data);
if(tree->lchild != NULL)
{
EnterQueue(q,tree->lchild);
}
if(tree->rchild != NULL)
{
EnterQueue(q,tree->rchild);
}
}
}
B.图
1.存储
a.邻接矩阵
typedef struct
{
vtype v[N];
int matrix[N][N];
}Graph
b.链接表
typedef struct node
{
vtype v;
struct node *next;
}LINKGRAPH;
2.遍历
a.深度遍历
DFS(Graph * G,int v)
{
visited[v] = 1;
printf("V%d",v);
u = FirstAdj(G,v);
while(u >= 0)
{
if(!visited[u])
DFS(G,u);
u = NextAdj(G,u,v);
}
}
b.广度遍历
BFS(Graph *G,int v)
{
visited[v] = 1;
EnterQueue(G,v);
while(!is_empty_queue(q))
{
v = DelelteQueue(q);
printf("V%d ",v);
u = FirstAdj(G,v);
while(u >= 0)
{
if(!visited[u])
{
visited[u] = 1;
EnterQueue(q,u);
}
u = NextAdj(G,u,v);
}
}
}
ps:
1设结点data域为整数，求链表中相邻两结点data之和为最大的第一结点的指针。
LINKLIST * Adjmax(LINKLIST *l)
{
LINKLIST *p,*q,*s;
int
p = l->next;
s = p;
if(NULL == p)
{
return s;
}
q = p->next;
if(NULL == q)
{
return s;
}
sumf = p->data + q->data;
while(NULL != q->next)
{
p = q;
q = q->next;
sumr = p->data + q->data;
if(sumf < sumr)
{
s = p;
sumf = sumr;
}
}
return s;
}
