//==========================================
// 2-链表的操作
//==========================================
typedef int ElemType;
typedef struct LNode{
struct LNode* next;
ElemType data;
}LNode,*LinkList;
//==2.1链表的插入
Stauts InsertList(LinkList&L,int i,ElemType e)
{
LNode* p,*s;
int j=0;
p = L;
while(p!=NULL&&j<i-1)
{
p=p->next;
j++;
}
if(p==NULL||j>i-1) return ERROR;
else
{
s = (LNode*)malloc(sizeof(LNode));
s.data = e;
s->next = p->next;
p->next = s;
}
return OK;
}
//==2.2链表的删除
Status ListDelete(LinkList&L,int i,Elemtype& e)
{
LNode*p,*s;
p = L;
int j=0;
while(p!=NULL&&j<i-1)
{
p = p->next;
j = j+1;
}
if(p==NULL||j>i-1)
{
return ERROR;
}
else
{
s = p->next;
e = s->data;
p->next = s->next;
free(s);
return OK;
}
}
//==2.3带头结点的空链表
void initLinkList(LinkList& L)
{
L = (LNode*)malloc(sizeof(LNode));
L->next = NULL;
}
//==2.4前插法建立链表
void createListFront(LinkList&L,Elemtype e)
{
LNode *s;
s = (LNode*)malloc(sizeof(LNode));
s->data = e;
s->next = L->next;
L->next = s;
}
//==2.5后插法建立链表
void createListRear(LinkList&L,Elemtype e)
{
LNode *s,*p=L;
s = (LNode*)malloc(sizeof(LNode));
s->data = e;
while(p->next!=NULL)
{
p = p->next;
}
p->next = s;
s->next = NULL;
}
//==2.6两个循环链表(带头节点)合并
LinkList ListCombine(LinkList& L1,LinkList& L2)
{
LNode* p = L1;
while(p->next!=L1) p = p->next;
p->next = L2->next;
p = L2;
while(p->next!=L2) p = p->next;
p->next = L1;
return L1;
}
//==2.7单链表(不带头结点)的倒置
void ListReverse(LinkList& L)
{
LNOde* p=L,*NewL=L;
while(L!=NULL)
{
p=L;
L = L->next;
p->next = NewL->next;//头插法
NewL->next = p;
}
L = NewL;
}
//==========================================
// 3-堆栈队列
//==========================================
typedef int ElemType;
#define STACK_SIZE 100
#define STACK_INC_SIZE 10
//========================3.1顺序栈
//==3.1.1顺序栈的定义
typedef struct Stack
{
ElemType* Base;
ElemType* Top;
int StackSize;
}Stack;
//==3.1.2顺序栈的初始化
Status initStack(Stack& S)
{
S.base = (ElemType*)malloc(size(ElemType)*STACK_SIZE);
if(S.base == NULL)
{
return ERROR;
}
else
{
S.StackSize = STACK_SIZE;
S.top = S.base;
return OK;
}
}
//==3.1.3入栈
Status push(Stack& S,ElemType e)
{
if(!StackFull(S)) //S.top-S.base>=S.StackSize
{
*(S.top++) = e;
return OK;
}
else
{
return ERROR;
}
}
//==3.1.4出栈
Status pop(Stack& S,ElemType& e)
{
if(!StackEmpty(S)) //S.top==S.base
{
e=*(--S.top);
return OK;
}
else
{
return ERROR;
}
}
//========================3.2链式栈
//==3.2.1链式栈的定义
typedef struct StackNode
{
StackNode* next;
ElemType data;
}StackNode;
typedef struct Stack
{
StackNode *top;
}Stack;
//==3.2.2出栈
Status Pop(Stack& S,ElemType& e)
{
if(!StackEmpty(S)) //S.top ==NULL
{
StackNode* PNode;
e = (S.top)->data;
PNode = S.top;
S.top = S.top->next;
free(PNode);
return OK;
}
return ERROR;
}
//==3.2.3入栈
void Push(Stack& S,ElemType e)
{
StackNode* PNode;
Pnode=StackNode*(malloc(sizeof(StackNode)));
Pnode->data = e;
Pnode->next = S.top; //前插法
S.top = Pnode;
return OK;
}
//========================3.3队列
//==3.3.1链队的定义
typedef struct QNode
{
ElemType data;
struct QNode* next;
}QNode;
typedef struct Queue
{
QNode* front;
QNode* rear;
}QUEUE;
//==3.3.2入队列
void EnQueue(Queue& Q,ElemType e)
{
QueueNode* QNodePtr;
QNodePtr=(QueueNode*)malloc(sizeof(QueueNode));
QNodePtr->data = e;
if(QueueEmpty(Q))
{
Q.rear = Q.front = QNodePtr;
}
else
{
Q.rear->next = QNodePtr;
Q.rear = QNodePtr;
}
}
//==3.3.2出队列
Status DeQueue(Queue& Q,ElemType& e)
{
if(EmptyQueue(Q)) //Q.front ==NULL
{
return ERROR;
}
else
{
QueueNode* p = Q.front;
Q.front = Q.front->next;
e = p->data;
free(p);
return OK;
}
}
//==3.3.4循环队列定义
typedef struct CyclQueue
{
ElemType* data;
int front;
int rear;
};
#define QUEUE_MAX_SIZE 100
//==3.3.5循环队列 出队列
Status DeQueue(Queue Q,ElemType& e)
{
if(QueueEmpty(Q)) //Q.front==Q.rear
{
return ERROR;
}
else
{
e = Q.data[Q.front];
Q.front = (Q.front+1)%QUEUE_MAX_SIZE;
return OK;
}
}
//==3.3.6循环队列 入队列
Status EnQueue(Queue Q,ElemType e)
{
if(QueueFull(Q)) //(rear+1)%QUEUE_MAX_SIZE==front
{
return ERROR;
}
else
{
Q.data[Q.rear] = e;
Q.rear = (Q.rear+1)%QUEUE_MAX_SIZE;
return OK;
}
}
//==========================================
// 4.二叉树的操作
//==========================================
//==4.1二叉链表
typedef char ElemType;
typedef struct BiNode
{
struct BiNode* lchild;
struct BiNode* rchild;
ElemType data;
}BiNode,*BiTree;
//==4.1.1先序遍历
void PreOrder(BiTree B,void(*visit)(ElemType& e))
{
if(T)
{
visit(B->data);
PreOrder(B->lchild,visit);
PreOrder(B->rchild,visit);
}
}
//==4.1.2中序遍历
void InOrder(BiTree B,void(*visit)(ElemType& e))
{
if(T)
{
InOrder(B->lchild,visit);
visit(B->data);
InOrder(B->rchild,visit);
}
}
//4.1.3求二叉树的深度
int BiTreeDepth(Bitree B)
{
int lDepth=0,rDepth=0,Depth=0;
if(B)
{
lDepth = BiTreeDepth(B->lchild);
rDepth = BiTreeDepth(B->right);
Depth = 1+(lDepth>rDepth?lDepth:rDepth);
}
else
{
Depth = 0;
}
return Depth;
}
//4.1.4求二叉树的结点数
int BiTreeNodeCount(Bitree B)
{
int lNode=0,rNode=0,Node=0;
if(B)
{
lNode = BiTreeNodeCount(B->lchild);
rNode = BiTreeNodeCount(B->rchild);
Node = lNode+rNode+1;
}
else
{
Node = 0;
}
return Node;
}
//4.1.5求二叉树的叶子节点数
int BiTreeLeafCount(Bitree B)
{
int lLeaf=0,rLeaf=0,Leaf=0;
if(T)
{
lLeaf = BiTreeLeafCount(B->lchild);
rLeaf = BiTreeLeafCount(B->rchild);
Leaf = lLeaf + rLeaf;
if(Leaf==0) Leaf = 1;
}
else
{
Leaf = 0;
}
return Leaf;
}
//4.1.6二叉树的层次遍历
void LayertOrder(Bitree& B)
{
BiNode* p;
InitQueue(Q);
EnQueue(B);
while(EmptyQueue(B))
{
DeQueue(Q,p);
//visit node p here
if(p->lchild) EnQueue(p->lchild);
if(p->rchild) EnQueue(p->rchild);
}
}
//4.1.6删除二叉树
void DelBiTree(Bitree& B)
{
if(B->lchild) DelBiTree(B->lchild);
if(B->rchild) DelBiTree(B->rchild);
free(B);
}
//4.2.1双亲表示法
#define M 100
typedef struct node
{
int parent;
ElemType data;
}PT;
PT tree[M];
//4.2.2孩子链表表示法(数组加链表存储)
typedef struct ListChild
{
int ChildIndex;// 数组中孩子结点在线性表存储中的索引
struct ListChild* next;
}ListChild;
typedef struct ListChildTree
{
ElemType data;
ListChild* FirstChild;
}ListChildTree;
ListChildTree tree[M];
//4.2.3长子兄弟表示法
//各种树转换为二叉树的表示方法
typedef struct ChildSiblingNode
{
struct* ChildSiblingNode firstChild;
struct* ChildSiblingNode NextSibling;
ElemType data;
}ChildSiblingNode;
//==========================================
// 5.图
//==========================================
//==5.1邻接矩阵的定义
typedef char VertexType;
typedef int EdgeType;
#define MAXVEX 100
typedef struct {
VertexType Vertex[MAXVEX];
EdgeType Arc[MAXVEX][MAXVEX];
int NumVertexs;
int NumEdges;
}MGraph;
//==5.2邻接链表,与二叉树中孩子链表表示法类似
typedef struct ListEdge//链表中的类型
{
struct ListEdge* next;
int Adjvex;
}ListEdge;
typedef struct AdjNode//数组中的类型
{
ListEdge* FirstAdj;
VertxType data;
}AdjNode;
typedef struct AdjList
{
AdjNode adjList[MAXVEX];
int NumVertexs;
int NumEdges;
}AdjList;
图的遍历:
1.深度优先遍历(类似于二叉树的前序遍历,纵向遍历)DFS
2.广度优先遍历(类似于二叉树的层序遍历,横向遍历)BFS
3.最小生成树
prim和kruskal算法
prim算法:选小,扩张,不要构成回环,稠密图适用,O(n^2)
kruskal 算法:选小,避圈,稀疏图适用,O(nedge*log(nedge))
4.最短路径
a.迪杰斯拉特算法(单源点最短路径)
b.弗洛伊德算法(所有节点间的最短路径)
5.拓扑排序
a.在有向图中选择一个没有前驱的顶点(入度为0),并输出
b.删除该顶点和从它出发的弧线
c.重复以上步骤,直到全部顶点输出或图中不存在入度为0的顶点(图中有有向环)
6.关键路径
//==========================================
// 6.查找
//==========================================
//==6.1折半查找(迭代法)
int BinarySearch(ElemType V[],int length,,ElemType Value)
{
int left = 0,right = length -1,mid;
while(left<=right)
{
mid = (left+right)/2;
if(V[mid]==Value)
{
return mid;
}
else if(V[mid]>Value)
{
right = mid -1;
}
else
{
left = mid + 1;
}
}
rerurn -1;//未找到
}
//==6.2折半查找(递归法)
int BinarySearch(ElemType V[],int low,int high,int kValue)
{
if(low>high) return -1;
else
{
int mid = (low+high)/2;
if(V[mid]==KValue)
{
return mid;
}
else if(V[mid]>KValue)
{
high = mid -1;
}
else
{
low = mid +1;
}
BinarySearch(V,low,high,KValue);
}
}
//==6.3二叉排序树(二叉查找树)
//f的作用是当找不到kValue时,方便插入节点
Stauts BiTreeSearch(BiTree B,ElemType KValue,BiNode f,BiTree &p)
{
if(!B) //没找到关键字KValue
{
p = f;
return FALSE;
}
else if(KValue == B->data)
{
p = B;
return TRUE;
}
else if(KValue >B->data)
{
return BiTreeSearch(B->rChild,KValue,B,p);
}
else
{
return BiTreeSearch(B->lChild,KValue,B,p);
}
}
//==6.4二叉排序树(动态插入)
Status InsertBinarySearchTre(BiTree& B,int KValue)
{
BiNode* p,s;
if(!BiTreeSearch(B,KValue,NULL,p))//未找到
{
s = (BiNode*)malloc(sizeof(BiNode));
s->data = KValue;
s->lChild = s->rChild = NULL;
if(p==NULL) T = s;
else if(p->data>KValue)
{
p->rChild = s;
}
else
{
p->lChild = s;
}
return TRUE;
}
else
{
return FALSE;
}
}
6.5二叉排序树(查找并动态删除)
//(独)子承父业;双子争位,前驱代之
6.6平衡二叉树(AVL树)
//左右子树都为AVL树,两子树高度差的绝对值不超过1的二叉排序树
//查找,插入,删除的复杂度为log(n)
6.7哈希表(基于计算的查找)
将关键字进行一个运算,结果为它的地址
常见方法:
直接定址法
数字分析法
平方取中法
折叠法
除留余数法
随机数法
冲突处理:由于不同的关键字,经过运算可能是同一个地址(取决于哈希函数的选取)
1.开放定址法
2.链地址法
3.再哈希法
//==========================================
// 7.排序
//==========================================
//==7.1选择排序
void Selectsort(SortType V[], int length)
{
int i, j = 0;
for (int i = 0; i < length; i++)
{
//==未排序的部分的最小值
int min_index=i;
for (j = i+1; j < length; j++)
{
if (V[min_index]>V[j])
{
min_index = j;
}
}
if (V[i] != V[min_index])
Swap(V[i], V[min_index]);//将最小值,加入到已排序的下一个
}
}
//========================插入类排序
//====7.2希尔排序
/*
直接插入算法的改进版,对于n比较大时有优势
*/
void ShellSort(SortType V[], int length)
{
int gap = length / 2;
while (gap!=0)
{
for (int i = gap; i < length; i++)
{
if (V[i] < V[i -gap])
{
int j;
SortType temp = V[i];//index i表示待排序的index
for (j = i - gap; j>=0; j = j - gap)//插入已有顺序的部分,从最后一个有序元素开始
{
if (temp < V[j])
{
V[j + gap] = V[j];
}
else
{
break;
}
}
V[j + gap] = temp;
}
}
gap = gap / 2;
}
}
//====7.3插入排序
void InsertSort(SortType V[], int length)
{
for (int i = 1; i < length; i++)
{
if (V[i] < V[i - 1])//比已排序的部分最后一个小
{
int j;
SortType temp = V[i];
for (j = i - 1; j >= 0; j--)//把该数插入到已排序的部分
{
if (V[j]>temp)
{
//后移
V[j + 1] = V[j];//第一次,覆盖掉未排序的数,
//第二次由于最后一个元素(已排序)已经复制了在待排序的位置
//依次类推,不会有元素损失
}
else
{
break;
}
}
V[j + 1] = temp;
}
}
}
//===7.4归并排序
/*把两个有序列表合并*/
void merge(SortType Initlist[], SortType mergeList[], int index_l, int index_mid, int index_r)
{
int i = index_l, j = index_mid + 1, k = index_l;//把mid当作List1中的元素,List1(Left-mid) List2(mid+1 right)
while (i<=index_mid&&j<=index_r)
{
if (Initlist[i] <= Initlist[j]) mergeList[k++] = Initlist[i++];
else mergeList[k++] = Initlist[j++];
}
while (i <= index_mid) mergeList[k++] = Initlist[i++];
while (j <= index_r) mergeList[k++] = Initlist[j++];
}
/*相邻长度为len的两个有序数组合并*/
/*合并过程中,有3种情况
1.完全合并了
2.过程中单词合并后剩下了,单数
3.最后,剩下了的部分
*/
void mergePass(SortType Initlist[], SortType mergeList[], int s /*两个长度为s数组合并*/, int len /*排序数组总长度*/)
{
int i = 0;
while((len-i-1)>=2*s)//把偶数项全部合并,可能留下奇数项
{
merge(Initlist, mergeList, i, i + s - 1, i + 2 * s - 1);
i = i + 2 * s;
}
if ((len-i-1)>=s)//最后,不足长度s的合并
merge(Initlist, mergeList, i, i + s - 1, len - 1);
else //前面已经合并,把最后剩下的,直接复制加入
{
for (int j = i; j <=len-1 ; j++)
{
mergeList[j] = Initlist[j];
}
}
}
void MergeSort(SortType Initlist[], int length)
{
SortType *tempList = (SortType*)malloc(sizeof(SortType)*length);
int s = 1;
while (s<length)
{
mergePass(Initlist, tempList, s, length);
s *= 2;
mergePass(tempList, Initlist, s, length);
s *= 2;
}
free(tempList);
}
//============交换类排序
//====7.5冒泡排序
void BubbleSort(SortType V[], int length)
{
for (int i = 1; i <length; i++)
{
for (int j = length - 1; j >= i; j--)//每次从最后一个元素开始,直到待排序的位置i
{
if (V[j]<V[j - 1])
{
Swap(V[j], V[j - 1]);
}
}
}
}
//====7.6快速排序
int Partition(SortType V[], int low,int high)
{
SortType pivotkey = V[low];
while (low<high)
{
while (low < high&&V[high] >= pivotkey)high--;
V[low] = V[high];
// Swap(V[low], V[high]);
while (low < high&&V[low] <= pivotkey)low++;
V[high] = V[low];
// Swap(V[low], V[high]);
}
V[low] = pivotkey;
return low;
}
void QuickSort(SortType V[], int low, int high)
{
while (low < high)
{
int keyIndex = Partition(V, low, high);
QuickSort(V, low, keyIndex -1);
low = keyIndex + 1;
//QuickSort(V, keyIndex + 1, high);
}
}