数据结构复习总结

数据结构复习总结

一、线性表

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
;

int matrix

;

}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);

}

}

}