2 //设计将两个递增有序带头结点链表合并为一个有序递减的链表。
3 //1,2,3,4,5
4 //2,5,9,10
5 void MergeList(LinkList &La,LinkList &Lb)
6 {
7 LNode *r,*pa=La->next,pb=Lb->next;
8 La->next=null;//将结果链表La初始化
9 while(pa&&pb)
10 {
11 if(pa->data<=pb->data){
12 r=pa->next;
13 pa->next=La->next;//前插入法,所有新插入的结点都在
14 La->next=pa;
15 pa=r;
16 }
17 else
18 {
19 r=pb->next;
20 pb->next=La->next;
21 La->next=pb;
22 pb=r;
23 }
24 }
25 if(pa){
26 pb=pa;
27 }
28 while(pb)
29 {
30 r=pb->next;
31 pb->next=La->next;
32 La->next=pb;
33 pb=r;
34 }
35 free(Lb);
36 }
37
38
39 //BFS广度优先遍历
40 bool visited[max_vertex];
41 void BFSTraverse(Graph G)
42 {
43 for(i=0;i<G.vexnum;i++){
44 visited[i]=false;
45 }
46 InitQueue(Q);
47 for(i=0;i<vexnum;i++){
48 if(!visited[i])
49 BFS(G,i);
50 }
51 }
52 void BFS(Graph G,int v){
53 visit(v);
54 visited[v]=true;
55 EnQueue(Q,v);
56 while(!isEmpty(Q))
57 {
58 DeQueue(Q,v);
59 for(w=FirstNeighbor(G,v);w>=0;w=NextNeighBor(G,v,w)){
60 //检测所有邻结点
61 if(!visited[w]){
62 visit(w);
63 visited[w]=true;
64 EnQueue(Q,w);
65 }
66 }
67 }
68 }
69
70 //单链表递增输出各结点的数据元素，并释放存储空间
71 void Min_Delete(LinkList head){
72 LinkNode *pre_min,*pre;//pre_min指向最小
73 LinkNode *r;
74 while(head->next){
75 pre_min=head;
76 pre=head->next;
77 while(pre->next){
78 if(pre->next->data>pre_min->next->data){
79 pre_min=pre;
80 }
81 }
82 r=pre_min->next;
83 pre_min->next=pre_min->next->next;
84 free(r);
85 }
86 free(head);
87 }
88
89 //二叉树的前中后序递归算法
90
91 void PreOrder(Btree BT){
92 if(BT != NULL){
93 cout<<BT->data<<endl;
94 PreOrder(BT->lchild);
95 PreOrder(BT->rchild);
96 }
97 }
98 //中序遍历
99 /*
100 void InOrder(Btree BT) {
101 if (BT != NULL) {
102 InOrder(BT->lchild);
103 cout << BT->data << endl;
104 InOrder(BT->rchild);
105 }
106 }
107 */
108
109 //后序遍历
110 /*
111 void PostOrder(Btree BT) {
112 if (BT != NULL) {
113 PostOrder(BT->lchild);
114 PostOrder(BT->rchild);
115 cout << BT->data << endl;
116 }
117 }
118 */
119
120
121 void PreOrderNoRecur(Btree root){
122 stack<Btree> S;
123 while(root!=NULL||!S.empty()){
124 while(root!=NULL)
125 {
126 cout<< root->data<<endl;
127 S.push(root);
128 root=root->lchild;
129 }
130 }
131 if(!S.empty()){
132 root=S.top();
133 S.pop();
134 root=root->rchild;
135 }
136 }
137
138
139 //中序遍历非递归算法
140 /*
141 void InOrderNoRecur(Btree root) {
142 stack<Btree> S;
143 while (root != NULL || !S.empty()) {
144 while (root != NULL) {
145 S.push(root);
146 root = root->lchild;
147 }
148
149 if (!S.empty()) {
150 root = S.top();
151 cout << root->data << endl;
152 S.pop();
153 root = root->rchild;
154 }
155 }
156 }
157 */
158
//创建新的结构体list，包含Btree和int，来帮助实现后序非递归算法
typedef struct list {
Btree ptr;
int flag;
}List;
159 //后序遍历非递归算法
160 void PostOrderNoRecur(Btree root) {
161 stack<List> newS;
162 while (root != NULL || !newS.empty()) {
163 while (root != NULL) {
164 List element;
165 element.ptr = root;
166 element.flag = 1;
167 newS.push(element);
168 root = root->lchild;
169 }
170 while (!newS.empty() && newS.top().flag == 2) {
171 cout << newS.top().ptr->data << endl;
172 newS.pop();
173 }
174 if (!newS.empty()) {
175 newS.top().flag = 2;
176 root = newS.top().ptr->rchild;
177 }
178 }
179 }
180
181
182 //设计一个算法将二叉树的叶结点按从左到右的顺序连成一个单链表，表头指针head。
183 //叶结点的右指针域来存放单链表指针
184 LinkList head;
185 LinkNode *pre=NULL;
186 LinkList InOrder（BiTree bt)
187 {
188 if(bt){
189 InOrder(bt->lchild);//中序遍历左子树
190 if(bt->lchild=NULL&&bt->rchild=NULL){ //叶结点
191 if(pre==NULL){ //处理第一个叶结点
192 head->next=bt;
193 }
194 else{
195 pre->right=bt;
196 }
197 pre=bt;
198 }
199 else{
200 InOrder(bt->rchild);//中序遍历右子树
201 }
202 if(pre){
203 pre->rchild=NULL;//设置链表尾
204 }
205 return head;
206 }
207 }
208
209 //编写一个利用广度优先搜索算法求解单源最短路径功能
210 void BFS_MIN_Distance(Grapsh G,int u){
211 for(i=0;i<G.vexnul;i++){
212 d[i]=oo;//从u到i结点的最短路径，w不存在
213
214 }
215 visited[u]=true;
216 d[u]=0;
217 EnQueue(Q,u);
218 while(!isEmpty(Q)){
219 //BFS算法
220 DeQueue(Q,u);
221 for(w=FirstNeighbor(G,u);w>=0;w=NextNeighbor(G,u,w))//检测所有邻接点
222 {
223 if(!visted[w]){
224 vistted[w]=true;
225 d[w]=d[u]+1;
226 EnQueue(Q,w);
227 }
228 }
229 }
230 }
231
232
233 //交换左子树右子树，递归
234 typedef struct BiTNode{
235 ElemType data;
236 BiNode *lchild;
237 BiNode *rchild;
238 }*BiTree,BiTNode;
239 void Exchange(BiTree t){
240 if(t==NULL){
241 retrun;
242 }
243 Exchange(t->lchild);//对左子树进行交换操作
244 Exchange(t->rchild);
245
246 BiTNode *temp=t->lchild;
247 t->lchild=t->rchild;
248 t->rchild=temp;
249 }
250
251
252
253
254
255 //迪杰斯特拉
256 bool closed[N]={FALSE}; //路径
257 int Min[N]={INF}; //距离
258
void dijkstra(int start){
closed[start]=true;//假设从start出发到其余各个点的最短路径
Min[start]=0; //起点到达终点的最短路径长度 初始化数组d；
260 for(int i=0;i<N;i++){ //将剩余的N-1个顶点距离start的最短路径求出
261 int k=-1;
262 for(int j=1;j<N;++j){
263 if(!closed[j]&&(k=-1||Min[k]>Min[j])){
264 k=j;
265 }
266 }
267 closed[k]=true;//将k加入已得出结果的集合
268
269 for(int j=0;j<N;++j){
270 if(!visited[j]){ //更新未求得最短路径的结点得到start的最短距离
271 if(Min[j]>Min[k]+G[k][j]){
272 Min[j]=Min[k]+G[k][j];
273 }
274
275 }
276 }
277
278 }
}
1 //若用二叉链表作为二叉树的有序存储表示，是编写递归算法交换每一个节点的左子女和右子女
2 typedef struct BiTNode{
3 ElemType data;
4 BiTNode *lchild;
5 BiTNode *rchild;
6 }*BiTree,BiTNode;
7
8 void Exchange(BitTree t){
9 if(t==NULL){
10 return ;
11 }
12 Exchange(t->lchild);
13 Exchange(t->rchild);
14 BiTNode *temp=t->lchild;
15 t->lchild=t->rchild;
16 r->rchild=temp;
17 }
18
19
20 bool visited[MAX_VERTEX_NUM]; //访问标记数组
21 bool DFSTraverseALL(Graph G,int vertex){ //测试vertex是否是根
22 //对图G进行深度优先遍历，访问函数为visit()
23 for(v=0;v<G.vexnum;++v){
24 visited[v]=FALSE; //初始化以访问标记数据
25
26 }
27 for(v=0;v<G.vernum;++v){
28 if(!visited[v]){
29 DFS(G,v);
30 return false;
31 }
32 }
33 return true;
34 }
35
36 void DFS(Graph G,int v){
37 visit(v);
38 visited(v)=TRUE;
39 for(w=FirstNeighbour(G,v);w>=0;w=NextNeighbor(G,v,w)){
40 if(!visited[w]){
41 DFS(G,w);
42 }
43 }
44 }
45
46 int FindRoot(Graph G){
47 for(int i=0;i<N;++i){
48 if(DFSTraverseALL(G,i)){
49 return i;
50 }
51 }
52 return -1;
53 }
1 //若用二叉链表作为二叉树的有序存储表示，是编写递归算法交换每一个节点的左子女和右子女
2 typedef struct BiTNode{
3 ElemType data;
4 BiTNode *lchild;
5 BiTNode *rchild;
6 }*BiTree,BiTNode;
7
8 void Exchange(BitTree t){
9 if(t==NULL){
10 return ;
11 }
12 Exchange(t->lchild);
13 Exchange(t->rchild);
14 BiTNode *temp=t->lchild;
15 t->lchild=t->rchild;
16 r->rchild=temp;
17 }
18
19
20 bool visited[MAX_VERTEX_NUM]; //访问标记数组
21 bool DFSTraverseALL(Graph G,int vertex){ //测试vertex是否是根
22 //对图G进行深度优先遍历，访问函数为visit()
23 for(v=0;v<G.vexnum;++v){
24 visited[v]=FALSE; //初始化以访问标记数据
25
26 }
27 for(v=0;v<G.vernum;++v){
28 if(!visited[v]){
29 DFS(G,v);
30 return false;
31 }
32 }
33 return true;
34 }
35
36 void DFS(Graph G,int v){
37 visit(v);
38 visited(v)=TRUE;
39 for(w=FirstNeighbour(G,v);w>=0;w=NextNeighbor(G,v,w)){
40 if(!visited[w]){
41 DFS(G,w);
42 }
43 }
44 }
45
46 int FindRoot(Graph G){
47 for(int i=0;i<N;++i){
48 if(DFSTraverseALL(G,i)){
49 return i;
50 }
51 }
52 return -1;
53 }
//迪杰斯特拉
const int MAXINT = 32767;
const int MAXNUM = 10;
int dist[MAXNUM];
int prev[MAXNUM];
int A[MAXUNM][MAXNUM];
void Dijkstra(int v0)
{
bool S[MAXNUM]; // 判断是否已存入该点到S集合中
int n=MAXNUM;
for(int i=1; i<=n; ++i)
{
dist[i] = A[v0][i];
S[i] = false; // 初始都未用过该点
if(dist[i] == MAXINT)
prev[i] = -1;
else
prev[i] = v0;
}
dist[v0] = 0;
S[v0] = true;
for(int i=2; i<=n; i++)
{
int mindist = MAXINT;
int u = v0; // 找出当前未使用的点j的dist[j]最小值
for(int j=1; j<=n; ++j)
if((!S[j]) && dist[j]<mindist)
{
u = j; // u保存当前邻接点中距离最小的点的号码
mindist = dist[j];
}
S[u] = true;
for(int j=1; j<=n; j++)
if((!S[j]) && A[u][j]<MAXINT)
{
if(dist[u] + A[u][j] < dist[j]) //在通过新加入的u点路径找到离v0点更短的路径
{
dist[j] = dist[u] + A[u][j]; //更新dist
prev[j] = u; //记录前驱顶点
}
}
}
}
/**
1) Dijkstra 算法的伪代码：
void Dijkstra(G,d[],s)
{
初始化：
for(循环 n 次)
{
u=使d[u] 最小的还未被访问的顶点的标号；
记u为已被访问；
for(从u 出发能达到的所有顶点)
{
if(v未被访问 && 以u为中介点使s到达v能使d[v]更优)
优化d[v];
}
}
}
*/
60
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
