数据结构DS

绪论

• 数据类型：原子、结构、抽象数据类型

• 数据结构（3）：

• 数据对象，数据元素，数据项，

• 复杂度：

线性表

顺序表

• 定义

#静态分配
typedef struct{
    ElemType data[MaxSize];
    int length;
}SqList;

• 分配：（vs链表）

#c初始分配
L.data = (ElemType *)malloc(sizeof(ElemType)*InitSize);
#c++初始分配
L.data = new ElemType(InitSize);

• 插入（≈ 其他操作）：判断（i合法，满）、找到位置插入

链表

• 定义

typedef struct LNOde{
    ElemType data;
    struct LNode *next;       
}LNode,*LinkList;

• 单（双、循环）链表：
• 基操：
  • 初始化链表：头插，尾插

栈和队列

栈

• 定义

#顺序栈
typedef struct{
    Elemtype data[MaxSize];
    int top;			判断-1<=top<=MaxSize
}SqStack;			
#初始化函数
S.top=-1;

#链栈
typedef struct Linknode{	//和链表相似,简直是一模一样
    ElemType data;
    struct Linknode *next;	
}*LiStack

• 操作：均在栈顶
• 应用：括号匹配，表达式求值，递归

队列

• 定义

#顺序存储
typedef struct{
    Elemtype data[MaxSize];
    int front,rear;		空满：font+MaxSize-rear
}SqQueue;
#初始化
Q.rear=Q.front=0;

#链式存储
typedef strcut{
    ELemtype data;
    strcut LinkNode *next;
}LinkNode;
typedef struct{		//链队列需要定义两个节点
    LinkNode *front,*rear;		从front出，从rear入
}LinkQueue;
#初始化
void InitQueue(LinkQueue Q){
    Q.front=Q.rear=(LinkNode *)malloc(sizeof(LinkNode));	//首尾指向同一节点
    Q.front->next=NULL;
}

• 应用：层次遍历，计算机系统

串和数组

• 串的数据元素：字符

• 存储：

#顺序
typedef struct{
    char ch[MaxSize];
    int length;
}SString;

• 基操：

• 模式匹配：暴力，KMP

**矩阵：**对称，三角，三对角，稀疏（三元组，十字链表）

广义表：

树与二叉树

二叉树

• 特殊二叉树：满，完全，二叉排序树，平衡。n₀=n₂+1
• 存储

#顺序
index ---- a的孩子 2a和2a+1
#链式
typedef struct BiTNode{
    Elemtype data;
    struct BiTree *lchild,*rchild;
}BiTNode,*BiTree;

• 先中后遍历：递归实现，非递归（自己建立栈）

#先序：递归 PreOrder InOrder  PostOrder
void PreOrder(BiTree T){
    if(T!=NULL){
        visit(T);
        PreOrder(T->lchild);
        PreOrder(T->rchild);
    }
}

#void InOrder2(BiTree T){
	InitStack(S);BiTress p=T;
	while(p||!IsEmpty(S)){
        if(p){
            Push(S,p);
            p=p->lchild;
        }
        else{
            Pop(S,p);visit(p);
            p=p->rchild;
        }
    }
}

• 层次遍历：利用队列

void LevelOrder(BiTree T){
    InitQueue(Q);BiTree p;
    EnQueue(Q,T);
    while(!IsEmpty(Q)){
        DeQueue(Q,p);
        visit(p);
        if(p->lchild!=NULL) EnQueue(Q,p->lchild);
        if(p->rchild!=NULL) EnQueue(Q,p->rchild);
    }
}

• 有遍历序列构造二叉树
• 线索二叉树：（难，跳过）

#节点存储
typedef struct ThreadNode{
    Elemtype data;
    struct ThreadNode *lchild,*rchild;
    int ltag,rtag;
}ThreadNode,*ThreadTree;
#中序
#二叉树线索化
void InThread(ThreadTree &p,ThreadTree &pre){
    if(p!=NULL){
        InThread(p->lchild,pre);
        if(p->lchild){
            p->lchild=pre;
            p->ltag=1;
        }
        if(p->rchild&&pre!=NULL){
            pre->rchild=p;
            pre->rtag=1;
        }
        pre=p;
        InThread(p->rchild,pre);
    }
}
#建立
void CreateInThread(ThreadTree T){
    if(T!=NULL){
        InThread(T,pre);
        pre->rchild=NULL;
        pre->rtag=1;
    }
}

• 中序线索二叉树遍历：第一个节点，最后一个节点（代码，第一开始就不懂了）

二叉排序树（BST）：

• 二叉排序树的查找算法：while
• 二叉排序树的插入：

int BST_Insert(BiTree &T,KeyType k){
    if(T==NULL){
        T=(BiTree)malloc(sizeof(BSTNode));
        T->data=k;
        T->lchild=T->rchild=NULL;
        return true;
    }else if(k==T->key){
        return false;
    }else if(k>T->key){
        return BST_Insert(T->rchild,k);
    }else if(k<T->key){
        return BST_Insert(T->lchild,k);
    }
}

• 二叉排序树的构造：

void Create_BST(BiTree &T,Keytype str[],int n){
    T=NULL;
    int i=0;
    while(i<n){
        BST_Insert(T,str[i]);
        i++;
    }
}

平衡二叉树：

• 原则
• 平衡旋转：

哈夫曼树：

树、森林

• 双亲表示法，孩子表示法，孩子兄弟表示法

#双亲表示
typedef struct{
    Elemtype data;
    int parent;
}PTNode;			//定义节点
typedef struct{
    PTNode nodes[MaxSize];
    int n; //节点数目
}PTree;				//定义树


#孩子兄弟表示
typedef struct CSNode{
    Elemtype data;
    struct CSNode *firstchild,*nextsibling;
}CSNode,*CSTree;

• 树、森林与二叉树的转换：

图

arc\vertex\ DAG(Directed Acyclic Graph)

存储：邻接矩阵法，邻接表法，十字链表vs邻接多重表，

#邻接表法
typedef struct ArcNode{
	int adjvex;
	struct ArcNode *next;
	//可以存边的权值
}ArcNode;
typedef struct VNode{
	Vertextype data;
	ArcNode *first;
}VNode,AdjList[MaxVertexNum];
typedef struct{
	AdjList vertices;
	int vexnum,arcnum;
}ALGraph;

图的遍历

• 广度优先

#伪代码
bool visited[MaxSize];
void BFSTraverse(Graph G){
    for(i=0;i<G.vexnum;++i) visited[i]=false;
    InitQueue(Q);
    for(i=0;i<G.vexnum;++i){
        if(!visited[i]) BFS(G,i);
    }
}
void BFS(Graph G,int v){
    visit(v);
    visted[v]=true;
    EnQueue(Q,v);
    while(!IsEmpty(Q)){
        DeQueue(Q,v);
        for(w=FirstNeightbor(G,v);w>=0;w=NextNeightbor(G,v,w)){
            if(!visited[w]){	//改为深度优先的话，只需要if结构体为DFS(G,w)
                visit(w);
                visited[w]=true;
                EnQueue(Q,w);
            }
        }
    }
}

• 深度优先

图的应用

• 最小生成树：prim，kruskal
• 最短路径：Dijkstra，Floyd
• 拓扑排序AOV(vertex)
• 关键路径AOE(edge)

查找

线性查找

• 顺序查找，折半查找，分块查找

#折半查找
int Binary_Search(SeqList L,Elemtype key){
    int low=0,high=L.length-1,mid;
    while(low<=high){
        mid=(low+high)/2;
        if(L.elem[mid]==key)	return mid;
        else if(L.elem[mid]>key) high=mid-1;
        else low=mid+1;
    }
    return -1;
}

B树和B+树

• B树（定义）：查找，插入，删除（3）
• B+树（定义）：

散列表

• 哈希函数：
• 冲突解决：
  • 开放地址：线性探测，平方探测，再散列，伪随机序列
  • 拉链法：

排序

• 插入：直接插入，折半插入，希尔排序（不稳）

• 交换：冒泡，快排（不稳）

• 选择：简单选择（不稳），堆排序（不稳）

• 归并，基数（低位->高位）

• 外部：多路归并排序

• 外排：多路归并

• 败者树：

不懂

代码

• 线索二叉树
• 邻接表图
• 快排