数据结构算法合集

while (p && j<i) { p = p->next; ++j; }
// 顺指针向后查找，直到 p 指向第 i 个元素
// 或 p 为空
if ( !p || j>i )
return ERROR;
// 第 i 个元素不存在
e = p->data;
// 取得第 i 个元素
return OK;
} // GetElem_L
销毁栈 ClearStack(&L)：
void ClearStack(ListStack *&L) { ListStack *p=L->next; while (p!=NULL) { free(L); L=p; p=p->next; }
求栈的长度 StackLength(L)：
int StackLength(ListStack *L) { int i=0; ListStack *p; p=L->next; while (p!=NULL) { i++;p=p->next; } return(i); }
中序遍历递归算法：
void InOrder(BTree BT) {
if (BT) {
InOrder(BT->Lchild); Visit(BT); InOrder(BT->Rchild); } }
后序遍历递归算法：
void PostOrder(BTree BT) {
if (BT)
பைடு நூலகம்
{ PostOrder(BT->Lchild); PostOrder(BT->Rchild); Visit(BT); };
数据结构算法合集
顺序表中插入一个数：
Status ListInsert_sq(SqList &l,int i,elemtype x) { if (i<0||i>l.length) return(ERROR); if(l.length==MAXSIZE) return(OVERFLOW); for(j=l.length;j>=i;j--)
判断栈是否为空 StackEmpty(L)：
int StackEmpty(ListStack *L) { return(L->next==NULL); }
进栈 Push(&L,e)：
void Push(ListStack *&L,ElemType e) { ListStack *p; p=(ListStack *)malloc(sizeof(ListStack)); p->data=e; p->next=L->next; /*插入*p 结点作为第一个数据结点*/ L->next=p; }
}
printf(“%c\n”,p->data);
//别忘记输出尾结点数据
单链表的修改(或读取)：
Status GetElem_L(LinkList L, int i, ElemType &e) {
// L 是带头结点的链表的头指针，以 e 返回第 i 个元素
p = L->next; j = 1; // p 指向第一个结点，j 为计数器
出栈 Pop(&L,&e)：
int Pop(ListStack *&L,ElemType &e) { ListStack *p; if (L->next==NULL) return 0; /*栈空的情况*/ p=L->next; /*p 指向第一个数据结点*/ e=p->data; L->next=p->next; free(p); return 1; }在栈不为空的条件下,将头结点后继数据结点的数据域赋给 e,然后将其删
//构造左子树
BT->rchild =PreCreate_BT( );
//构造右子树
return BT;
}
计算叶子节点数目：
void Leaf(BTree BT, int &count) {
if (!BT) return; Leaf(BT->Lchild, count); //计算左子树的叶子结点个数 if (BT->Lchild==NULL&&BT->Rchild==NULL) count++; Leaf(BT->Rchild, count); //计算右子树的叶子结点个数 }
//一般需要 3 个指针变量
int n ;
// 数据元素的个数
int m=sizeof(Lnode);
/*结构类型定义好之后，每个变量的长度就固定了，
m 求一次即可*/
void build()
//字母链表的生成。要一个一个慢慢链入
{ int i;
head=(LinkList)malloc(m);
//m=sizeof(Lnode) 前面已求出
move ( x , 1 , z ) ;
//将编号为 1 的盘子从 x 柱移到 z 柱 else
{ //将 n -1 个 编号从上到下为 1…n-1 的盘子从 x 柱，借助 y 柱移到 z 柱 Hanoi ( n-1 , x , z , y ) ;
move ( x , n, z) ; //将编号为 n 的盘子从 x 柱移到 z 柱 //将 n -1 个 编号从上到下为 1…n-1 的盘子从 y 柱，借助 x 柱移到 z 柱
单链表的插入：
Status ListInsert(LinkList &L, int i, ElemType e) //L 为带头结点的单链表的头指针，本算法
// 在链表中第 i 个结点之前插入新的元素 e { p=L->next; j=1; while(p&&j<i-1){p=p->next; ++j;} // 寻找第 i-1 个结点 if(!p||j>i-1)return ERROR; //i 大于表长或者小于 1 s=(LinkList)malloc(sizeof(Lnode)); s->data=e; s->next=p->next; p->next=s; return OK;}
{ ListStack *p=L->next; while (p!=NULL) { printf("%c ",p->data);
p=p->next; } printf("\n"); }
Hanoi :
Void Hanoi ( int n, char x, char y, char z ) { //将 n 个 编号从上到下为 1…n 的盘子从 x 柱，借助 y 柱移到 z 柱 if ( n = = 1 )
Hanoi ( n-1 , y , x , z ); }} //Hanoi move(x,n,z) {printf(“%i. Move disk %i from %c to %c \n”,++c,n,x,z);//c 为初值为 0 的全局变量，对搬动次数 }
先序遍历二叉树算法
void PreOrder(BTree BT) { if (BT) { Visit(BT); PreOrder(BT->Lchild); PreOrder(BT->Rchild); } }
除。
取栈顶元素 GetTop(L) ：
int GetTop(ListStack *L,ElemType &e) { if (L->next==NULL) return 0;
/*栈空的情况*/ e=L->next->data; return 1; }
显示栈中元素 DispStack(L)：
从第一个数据结点开始扫描单链表,并输出当前访问结点的数据域值 void DispStack(ListStack *L)
//将 pa 、pb 结点按大小依次插入 C 中
{ if(pa->data<=pb->data)
{pc->next=pa; pc=pa; pa=pa->next;}
else {pc->next=pb; pc=pb; pb=pb->next}
}
pc->next = pa?pa:pb ; //插入剩余段
L.elem[j-1]=L.elem[j]; L.length--; }
单链表的建立和输出：
#include<stdio.h>
#include<stdlib.h>
typedef struct list{char data; struct list*next;}
Lnode, *LinkList;
Lnode *p,*q,*head;
进栈：
void push(seqstack *s，ElemType x) { if (stackfull(s)) error(“stack overflow”); s–>data[s–>top++]=x; }
退栈：
void pop(seqstack *s,ElemType *x) { if(stackempty(s)) error(“stack underflow”); s–>top--; *x=s–>data[top]; }
两个链表的归并：
Void MergeList_L(LinkList &La,LinkList &Lb,LinkList &Lc)
{ //按值排序的单链表 LA,LB，归并为 LC 后也按值排序
pa=La-->next; pb=Lb-->next; Lc=pc=La； //初始化