数据结构：链表，栈和队列，串，数组和广义表，树和二叉树

原创

浮若于心 2021-11-13 15:46:17 博主文章分类：数据结构 ©著作权

©著作权归作者所有：来自51CTO博客作者浮若于心的原创作品，请联系作者获取转载授权，否则将追究法律责任

第一章：简单描述

时间复杂度的关系：O(1) < O(log2n) < O(n) < O(n * log2n) < O(n^3) < O(2^n) < O(n!)
复杂度越大，执行越慢。
空间复杂度：定义一个数组作为中转量为O(n),定义一个普通变量t,为O(1)。
数据的逻辑结构：线性结构：(线性表，栈，队列，字符串，数组和广义表)
非线性结构：(树，图)
数据的存储结构：顺序结构和链式结构
存储结构是逻辑结构在计算机中的实现。

第二章：链表
线性表的定义：
typedef struct
{
int data[10];
int length; //表长
}list;
c语言申请空间：
头文件为include<malloc.h>
例：list *t;
t = (list*)malloc(sizeof(list));
//释放空间
free(t);
c++申请空间：
例：list *t;
t = new list;
//释放空间
delete t;
申请的空间在堆中的内存。
顺序表的初始化：1 申请空间
2 先判断是否为空，再t->length = -1;，最后返回t。
顺序表插入：1.判断是否超出范围
2.移动表内元素，留空间，再插入。
顺序表的删除：1.判断要删除的是否越界
2.用后面的元素覆盖
查找：直接遍历
单链表的定义：
typedef struct node
{
int data;
struct node *next;
}list,*linklist;
初始化：1.申请空间
2.不为空，则t->next = NULL;,最后返回t。
头插法建表：p = (list*)malloc(sizeof(list));
p->data = x;
p->next = t->next;
t->next = p;
尾插法建表：r = t;
p = (list*)malloc(sizeof(list));
p->data = x;
r->next = p;
r = p;
插入运算：s = (list*)malloc(sizeof(list));
s->data = x;
s->next = p->next;
p->next = s;
在p之前插入：s->next = p;
q->next = s;
删除：p->next = p->next->next;
双向链表结点定义：
typedef struct node
{
int data;
struct node *point,*next;
}node,*list;
指中的结点为：p->point->next == p->next->point == p;
插入：s->data = x;
s->next = p->next;
p->next->point = s;
s->point = p;
p->next = s;
删除：p->next->point = p->point;
p->point->next = p->next;
带头结点的单链表逆置：跟头插法类似。
q->next = h->next;
h->next = NULL;
p = q;
q = q->next;
p->next = h->next;
h->next = p;

第三章：栈和队列
栈：先进后出，跟薯片一样。
插入删除都在栈顶(top)实现，为表尾。
顺序栈定义：
typedef struct
{
int data[10];
int top;
}stack;
stack *s;
s = (stack*)malloc(sizeof(stack));
初始化：s->stop = -1;
判断是否为空：if(top == -1)
入栈：判断是否为栈满if(s->top == 10 - 1)
s->top++;
s->data[s->top] = x;
出栈：if(s->top == -1)return 0;
x = s->data[s->top];
s->top--;
取栈顶：if（s->top == -1) return 0;
x = s->data[s->top];

#include "stdio.h"
#include "malloc.h"
typedef struct 
{
    int data[10];
    int top;
}stack,*link;


int pp(stack *s,int data)
{
    if(s->top == 10 - 1)
    {
        return 0;
    }
    else
    {
        s->top++;
        s->data[s->top] = data;
    }
    return 1;
}

int out(stack *s)
{
    if(s->top == -1) return 0;
    else
    {
        return s->data[s->top--];
     } 
}

int main()
{
    stack *s;
    link l;
    s = (stack*)malloc(sizeof(stack));
    l = (stack*)malloc(sizeof(stack));
    for(int i = 0; i < 5;i++)
    {
        pp(s,i);
        pp(l,i);
    }
    for(int i = 0; i < 5;i++)
    {
        printf("%d %d",out(s),out(l));
    }
    return 0;
}

链栈定义：
typedef struct node{
int data;
struct node *next;
}*stack;

初始化：
void Init(stack T)
{
T = (stack*)malloc(sizeof(stack));
}

判断是否为空
bool Judge(stack T)
{
if(T == NULL)
    {
return true;
    }
else
    {
return false;
    }
}

void plus(stack T,int Value)
{
stack p,s;
p = T;
s = (stack*)malloc(sizeof(stack));
s->data = value;
p->next = s;
p = s;
}

int out(stack T)
{
stack p;
int x = 0;
p = T->next;
T->next = p->next;
x = p->data;
free(p);
return x;
}

队列：
先进先出，破盒子薯片。
插入在队尾，删除在队头。
链队列的定义：
typedef struct node{
int data;
struct node *next;
}node,*qnode;
typedef struct{
qnode font,rear;
}link;
初始化：q->font = q->rear = new link;
if(q->font != NULL)
q->font->next = NULL;
return 0;
入队：p->data = x;
p->next NULL;
q->rear->next = p;
q->rear = p;
出队：p = q->font->next;
q->font->next = p->next;
x = p->data;
delete p;
判断是否为空：if(q->font == q->rear)return 0;
循环队列：
typedef struct
{
int data[10];
int font;
int rear;
}se;
初始化：
q->font = q->rear = 0;
队满条件：(rear + 1)%max == font;
队空条件：rear == font;
入队：q->data[q->rear] = x;
q->rear = (q->rear + 1)%max;
出队：x = q->data[q->font];
q->font = (q->font + 1)%max;

#include "stdio.h"
#include "malloc.h"

typedef struct
{
    int data[10];
    int font;
    int rear;
}se;

int pp(se *q,int x)
{
    int max = 10;
    if((q->rear + 1)%max == q->font)
    return 0;
    else
    {
        q->data[q->rear] = x;
        q->rear = (q->rear + 1)%max;    
    }
}

int out(se *q)
{
    int x = 0;
    int max = 10;
    if(q->rear == q->font)
    return 0;
    else
    {
        x = q->data[q->font];
      q->font = (q->font + 1)%max;
      return x;
    }
}


int main()
{
    se *q;
    q = (se*)malloc(sizeof(se));
    q->font = q->rear = 0;
    for(int i = 0;i < 5;i++)
    {
        pp(q,i);
    }
    for(int i = 0;i < 5;i++)
    {
        printf("%d",out(q));    
    }
    return 0;
}

第四章：串
串的定义：
typedef struct{
char ch[10];
int len;
}string;
c语言中用'\0'来表示串的结束。
建立串：
gets(s->ch);
删除串：
1.判断是否超出范围。
2.遍历加覆盖。
3.结尾加上'\0'。
插入串：
1.判断插入位置是否在串中间
2.找到位置，后面一段移动。
3，插入
4.修改串长，并添加结束符'\0'。
串的操作基本跟顺序表的类似，进行别的操作时可以类似顺序表来思考。

第五章：数组和广义表
三元数组定义：
typedef struct{
int i,j;//非零元素的行和列。
int v;//非零元素
}trp;
typedef struct
{
trp data[10];//三元组表的存储空间
int row,col,count;//行数，列数，非零元素个数
}tsm;
三元数组的转置：
1.将row和col互换。
2.将i和j互换。
3.按优先次序排列(从大到小)。
广义表：
长度：最外层括号中元素的个数。
例：((b,a),((b)),a) 长度为3。
深度：数括号层数。
例：((d),a,(p,(s,(o)))) 深度为4。
每个元素都有直接前驱和直接后继。
表头可能为原子，可能为列表，表尾一定为列表。
头尾表示法的存储形式：
typedef enum{ATOM,LIST}elemtag;
typedef struct LSNode{
elemtag tag;
union
{
char atom;
struct{
struct LSNode *hp,*tp;
}ptr;
};
}*list;
孩子兄弟表示法的存储形式：
typedef enum{ATOM,LIST}elemtag;
typedef struct LSNode{
elemtag tag;
union
{
char atom;
struct LSNode *hp;
};
struct LSNode *tp;
}*list1;
求长度：递归：1 + listlength(l->ptr.tp);

第六章：树和二叉树

该节点子树的个数为该节点的度。
树的度为所有结点度最大的度。
树中所有结点的最大层次称为树的深度或高度。
一个非空二叉树的叶子最多为n0 = n2 + 1;n2为度为2的结点
第i层最多有2^(i - 1)个结点。
深度为k的二叉树，最多有2^k - 1个结点。
具有n个结点的完全二叉树深度为(log2n) + 1个结点。
i为1，则为根结点，i > 1则双亲结点的序号为i/2。
2i > n,则结点i无左孩子，2i <= n,则左孩子为2i。
2i + 1 > n,则无右孩子，2i + 1 <= n 则右孩子的序号为2i + 1个结点。

二叉树的顺序存储结构：
typedef int tree[10];
tree bt;
二叉树的链式存储：
typedef struct node{
struct node *lchild,rchild;
int data;
}tree,*bitree;
先序遍历：
void preorder(bitree bt)
{
if(bt != NULL)
{
printf("%d",bt->data);
preorder(bt->lchild);
preorder(bt->rchild);
}
}
中序和后序类似。
先：根左右
中：左根右
后：左右根
先序遍历建立二叉树：
t = new tree;
t->data = ch;
creatbitree(t->lchild);
creatbitree(t->rchild);//递归
输出叶子结点：
if(t->lchild == NULL && t->rchild == NULL)//判断无子结点
printf("%d",t->data)
pre(t->lchild);
pre(t->rchild);
统计叶子结点个数：
if(t->child == NULL && t->rchild == NULL)return 1;
else
{
m = per(t->child);
n = per(t->rchild);
return m + n;
}
计算二叉树高度：
m = hight(t->lchild);
n = hight(t->rchild);
if(m > n)return m + 1;
else return n + 1;