数据结构C++代码(大部分)—入门必看—代码大全。haut2020计科

一、线性表
1、无法删除的线性表（无delete函数）
#include
#include<stdio.h>
using namespace std;
#define MAXSIZE 100
typedef struct {
char* elem;
int length;
}sqlist, * sqlistp;
void Initlist(sqlist& L)//创建线性表
{
L.elem = new char[MAXSIZE];
if (!L.elem)exit(OVERFLOW);//内存不足弹出程序。
L.length = 0;
}
int Locateelem(sqlist L, char e)//定位元素
{
for (int i = 0; i < L.length; i++)
{
if (L.elem[i] == e)return i + 1;//找到返回下标
}
return -1;//未找到返回-1
}
int Insertelem(sqlist& L, int i, char e)//插入元素,将e插入到第i个位置上
{
if (i<1 || i>L.length + 1)return 0;
if (L.length == MAXSIZE)return 0;
for (int j = L.length - 1; j >= i - 1; j–)
L.elem[j + 1] = L.elem[j];
L.elem[i - 1] = e;
++L.length;
return 1;
}
int Deleteelem(sqlist& L, int i, char& e)//删除第i个元素，并用e返回第i个元素的值
{
if (i<1 || i>L.length)return -1;
e = L.elem[i - 1];
for (int j = i; j <= L.length; j++)
L.elem[j - 1] = L.elem[j];
–L.length;
return 1;
}
void getelem(sqlist L, int i,char& e)//返回第i个元素
{
e = L.elem[i - 1];
}
void Displist(sqlist L)//输出线性表
{
for (int i = 1; i <= L.length; i++)
printf("%c “, L.elem[i - 1]);
printf(”\n");
}
void Union(sqlist& la, sqlist lb)//将B串合在A串后面
{
char e;
for (int i = 1; i <= lb.length; i++)
{
getelem(lb, i,e);
if (Locateelem(la, e) == -1)
{
int i = la.length;
Insertelem(la,++i, e);
}
}
}
void mergelist(sqlist la, sqlist lb, sqlist& lc)//顺序表的合并，前提是la，lb为顺序表
{
char* pa = la.elem; char* pb = lb.elem; char* pa_end = pa + la.length-1; char* pb_end = pb + lb.length-1;
lc.length = la.length + lb.length;
lc.elem = new char[lc.length];
char* pc = lc.elem;
while (pa <= pa_end && pb <= pb_end)
{
if (*pa <= *pb)
*pc++ = *pa++;
else *pc++ = pb++;
}
while (pa <= pa_end)
{
pc++ = pa++;
}
while (pb <= pb_end)
{
pc++ = pb++;
}
}
int main()
{
sqlist LA,LB,LC; int n; char e;
cin >> n;
Initlist(LA);
Initlist(LC);
Initlist(LB);
for (int i = 1; i <= n; i++)
{
cin >> e;
Insertelem(LA, i, e);
}
Displist(LA);
for (int i = 1; i <= n; i++)
{
cin >> e;
Insertelem(LB, i, e);
}
Displist(LB);
// Union(LA, LB);
mergelist(LA, LB, LC);
Displist(LC);
return 0;
}
2、单链表
#include<stdio.h>
#include
using namespace std;
typedef struct lnode
{
char data;
struct lnode next;
}lnode, * linklist;
void Initlst(linklist& L)//初始化单链表
{
L = new lnode;
L->next = NULL;
}
int getelem(linklist L, int i, char& e)//找到第单链表中第i个元素并且用e输出
{
linklist p = L->next;
int j = 1;
while (p && j < i)
{
p = p->next;
++j;
}
if (!p || j > i)return -1;
e = p->data;
return 1;
}
lnode Locateelem(linklist L, char e)//找到单链表中data为e的地址；
{
linklist p = L->next;
while (p && p->data != e)
p = p->next;
return p;
}
int Insertelem(linklist& L, int i, char e)//在第单链表中第i个位置插入一个data为e的单位
{
linklist p = L; int j = 0;
while (p && j < i - 1)
{
p = p->next;
++j;
}
if (!p || j > i - 1)return -1;
linklist s = new lnode;
s->data = e;
s->next = p->next;
p->next = s;
return 1;
}
int Deletelist(linklist& L, int i, char& e)//删除单链表中第i个元素
{
linklist p = L;
int j = 0;
while (p->next && j < i - 1)
{
p = p->next;
++j;
}
if (!(p->next) || j > i - 1)return -1;
linklist q = p->next;
p->next = q->next;
e = q->data;
delete q;
return 1;
}
void Displist(linklist L)//打印单链表
{
linklist p = L->next;
while §
{
cout << p->data << " ";
p = p->next;
}
cout << endl;
delete p;
}
void Creatlist_F(linklist& L, int n)//前插法创建链表
{
Initlst(L);
for (int i = 0; i < n; i++)
{
linklist p = new lnode;
cin >> p->data;
p->next = L->next;
L->next = p;
}
}
void Creatlist_L(linklist& L, int n)//后插法创建链表
{
Initlst(L);
linklist r = L;
for (int i = 0; i < n; i++)
{
linklist p = new lnode;
cin >> p->data;
p->next = NULL;
r->next = p;
r = p;
}
}
void mergelist(linklist& la, linklist& lb, linklist& lc)//合并两个有序单链表，前提la，lb均递增
{
linklist pa = la->next; linklist pb = lb->next; linklist pc = lc;
while (pa && pb)
{
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;//pa?为判断pa是否为空
delete la, lb;
}
int main()
{
linklist F, L,C;
Initlst©;
//Creatlist_F(F, 4);
Creatlist_L(F, 4);
Displist(F);
Creatlist_L(L, 4);
Displist(L);
mergelist(L, F, C);
Displist©;
return 0;
}
3、双链表
#include<stdio.h>
#include
using namespace std;
typedef struct dulnode
{
char data;
struct dulnode prior;
struct dulnode next;
}dulnode,dullinklist;
void Initdullst(dullinklist& L)//初始化双链表
{
L = new dulnode;
L->next = NULL;
L->prior = NULL;
}
dullinklist getelem(dullinklist L, int i)//找到双链表中第i-1个元素的地址
{
dullinklist p = L; int j = 0;
while (p && j < i - 1)
{
p = p->next;
++j;
}
if (!p || j > i - 1)return NULL ;
return p;
}
int Insertlist(dullinklist& L, int i, char e)//在第i个位置插入e
{
dullinklist p;
if (!(p = getelem(L, i)))return -1;
dullinklist s = new dulnode;
s->data = e;
if (p->next == NULL)
{
p->next =s;
s->next = NULL;
return 1;
}
s->next = p;
p->prior->next = s;
p->prior = s;
return 1;
}
int Deletelist(dullinklist& L, int i, char& e)//删除双链表中第i个元素
{
dullinklist p;
if (!(p = getelem(L, i+1)))return -1;
e = p->data;
if (p->next == NULL)
{
p->prior->next = NULL;
delete p;
return 1;
}
p->prior->next=p->next;
p->next->prior = p->prior;
delete p;
return 1;
}
void Displist(dullinklist L)//打印双链表
{
dullinklist p = L->next;
while §
{
cout << p->data << " ";
p = p->next;
}
cout << endl;
delete p;
}
int main()
{
dullinklist L; int n; char e;
Initdullst(L);
cin >> n;
for (int i = 1; i <= n; i++)
{
cin >> e;
Insertlist(L, i, e);
}
Displist(L);
return 0;
}
4、多项式的表达
#include<stdio.h>
#include
using namespace std;
typedef struct pnode
{
float coef;//系数
int expn;//指数
struct pnode next;
}pnode,polyn;
void creatpolyn(polyn& p, int n)//创建多项式，项的次数递增
{
p = new pnode;
p->next = NULL;
for (int i = 1; i <= n; i++)
{
polyn s = new pnode;
cin >> s->coef >> s->expn;
polyn pre = p;
polyn q = p->next;
while (q && q->expn < s->expn)
{
pre = q;
q = q->next;
}
s->next = q;
pre->next = s;
}
}
void addpolyn(polyn& pa, polyn& pb)
{
polyn p1 = pa->next; polyn p2 = pb->next;
polyn p3 = pa;
while (p1 && p2)
{
if (p1->expn == p2->expn)
{
float sum = p1->coef + p2->coef;
if (sum != 0)//次方相同且相加不为0
{
p1->coef = sum;
p3->next = p1; p3 = p1;
p1 = p1->next;
polyn r = p2; p2 = p2->next; delete r;
}
else //次方相同相加为0
{
polyn r = p2; p2 = p2->next; delete r;
r = p1; p1 = p1->next; delete r;
}
}
else if (p1->expn < p2->expn)//p1的次方小于p2的
{
p3->next = p1;
p3 = p1;
p1 = p1->next;
}
else//p2的次方小于p1的
{
p3->next = p2;
p3 = p2;
p2 = p2->next;
}
}
p3->next = p1 ? p1 : p2;
delete pb;
}
void Displist(polyn L)//打印链表
{
polyn p = L->next;
while §
{
cout << “系数:” << p->coef << “次方:”<expn<< " ";
p = p->next;
}
cout << endl;
delete p;
}
int main()
{
polyn a, b;
creatpolyn(a, 4);
Displist(a);
creatpolyn(b, 4);
Displist(b);
addpolyn(a, b);
Displist(a);
return 0;
}
5、顺序栈
#include<stdio.h>
#include
using namespace std;
#define maxsize 100//可存100个
typedef struct
{
char base;
char top;
int stacksize;
}sqstack;
int Initstack(sqstack& s)//初始化顺序栈
{
s.base = new char[maxsize];
if (!s.base)exit(OVERFLOW);
s.top = s.base;
s.stacksize = maxsize;
return 1;
}
int Push(sqstack& s, char e)//插入元素e为新的栈顶元素
{
if (s.top - s.base == s.stacksize)return -1;
*s.top++ = e;
return 1;
}
int Pop(sqstack& s, char& e)//从栈顶出栈
{
if (s.top == s.base)return -1;
e = –s.top;
return 1;
}
int GetTop(sqstack s, char& e)//读取栈顶元素
{
if (s.top == s.base)return -1;
e = –s.top;
return 1;
}
int main()
{
sqstack a; char e;
Initstack(a);
for (int i = 1; i <= 3; i++)
{
cin >> e;
Push(a, e);
}
Pop(a, e);
GetTop(a, e);
cout << e;
}
6、链栈
#include<stdio.h>
#include
using namespace std;
typedef struct stacknode
{
char data;
struct stacknode next;
}stacknode,linkstack;
int Initstack(linkstack& s)//初始化栈顶元素
{
s = NULL;
return 1;
}
int Push(linkstack& s, char e)//插入栈顶元素
{
linkstack p = new stacknode;
p->data = e;
p->next = s;
s = p;
return 1;
}
int Pop(linkstack& s, char& e)//从栈顶出栈
{
if (s == NULL)return -1;
e = s->data;
linkstack p = s;
s = s->next;
delete p;
return 1;
}
int stackempty(linkstack s)//判空
{
if (s == NULL)return -1;
return 1;
}
void gettop(linkstack s, char& x)//得到栈顶元素
{
if(stackempty(s)-1)return;
x = s->data;
}
int Matching()//判断括号是否匹配，仅能；
{
linkstack s;
Initstack(s);
char c,x;
int flag = 1;
cin >> c;
while (c != ‘#’ && flag)
{
switch ©
{
case ‘)’:
gettop(s,x);
if(stackempty(s)!=-1&&x’(’)
Pop(s,x);
else flag=0;
break;
case’[’:
case’(’:
Push(s, c);
break;
case ‘]’:
gettop(s,x);
if (stackempty(s)!=-1 &&x == ‘[’)
Pop(s, x);
else flag=0;
break;
}
cin >> c;
}
if (stackempty(s) && flag)return 1;
else return -1;
}
int main()
{
/linkstack a; char e;
Initstack(a);
for (int i = 1; i <= 3; i++)
{
cin >> e;
Push(a, e);
}
while (a)
{
Pop(a, e);
cout << e << " ";
}/
if (Matching() == 1)cout << “YES” << endl;
else cout << “NO”<< endl;
}
7、进制转换
void conversion()//转换为8进制
{
linkstack s; int N; char e;
Initstack(s);
cin >> N;
while (N)
{
Push(s, N % 8);
N = N / 8;
}
while (s)
{
Pop(s, e);
cout << e << " ";
}
}
8、Hanio塔
#include<stdio.h>
#include
using namespace std;
int m = 0;
void Hanoi(int n, char A, char B, char C)//A要上到下盘子由小变大，将A上的盘子移到C上（要上到下由小变大）
{
if (n == 1)
m++;//最后一个盘子
else
{
Hanoi(n - 1, A, C, B);//前n-1个移到B上
m++;//将第n个盘子移到C上；
Hanoi(n - 1, B, A, C);
}
}
int main()
{
char A=‘a’, B=‘b’, C=‘c’;
Hanoi(4, A, B, C);
cout << m;
return 0;
}
9、 循环队列
#include<stdio.h>
#include
using namespace std;
#define maxsize 100
typedef struct
{
char base;
int front;//队头
int rear;//队尾
}sqqueue;
int Initqueue(sqqueue& q)//初始化循环队列
{
q.base = new char[maxsize];
if (!q.base)exit(OVERFLOW);
q.front = q.rear = 0;
return 1;
}
int queuelength(sqqueue q)//返回队的长度
{
return (q.rear - q.front + maxsize) % maxsize;
}
int enqueue(sqqueue& q, char e)//从队尾进队
{
if ((q.rear + 1) % maxsize == q.front)return -1;
q.base[q.rear] = e;
q.rear = (q.rear + 1) % maxsize;
return 1;
}
int dequeue(sqqueue& q, char& e)//出队
{
if (q.rear == q.front)return -1;
e = q.base[q.front];
q.front = (q.front + 1) % maxsize;
return 1;
}
int main()
{
sqqueue s;
Initqueue(s);
char e;
for (int i = 0; i < 4; i++)
{
cin >> e;
enqueue(s, e);
}
cout<<queuelength(s);
for (int i = 0; i < 4; i++)
{
dequeue(s, e);
cout << e << " ";
}
}
10、 链队
#include<stdio.h>
#include
using namespace std;
typedef struct qnode
{
char data;
struct qnode next;
}qnode, *qnodep;
typedef struct
{
qnodep front;//队头
qnodep rear;//队尾
}linkque;
int Initqueue(linkque& q)//初始化队列
{
q.front = q.rear = new qnode;
if (!q.front)exit(OVERFLOW);
q.front->next = NULL;
return 1;
}
int enqueue(linkque& q, char e)//进队元素
{
qnodep p = new qnode;
p->data = e; p->next = NULL;
q.rear->next = p;
q.rear = p;
return 1;
}
int dequeue(linkque& q, char& e)//出队元素
{
if (q.front == q.rear)return -1;
qnodep p = q.front->next;
e = p->data;
q.front->next = p->next;
if (q.rear == p)q.rear = q.front;
delete p;
return 1;
}
void yanghui(int n)//打印杨辉三角形的前几行，结构体中data要换成int型
{ //01101210133101…
int t;
linkque q;
Initqueue(q);
enqueue(q, 1); enqueue(q, 1);
int s = 0;
for (int i = 1; i <= n; i++)
{
cout << endl;
enqueue(q, 0);
for (int j = 1; j <= i + 2; j++)
{
dequeue(q, t);
enqueue(q，s + t);
s = t;
if (j != i + 2)cout << s << ’ ';
}
}
}
int main()
{
linkque q;
char e;
Initqueue(q);
for (int i = 0; i < 4; i++)
{
cin >> e;
enqueue(q, e);
}
for (int i = 0; i < 4; i++)
{
dequeue(q, e);
cout << e << " ";
}
return 0;
}
11、 BF算法
int Index(sstring s, sstring t, int pos)//t在s的第pos个字符后第一次出现的位置
{
int i = pos; int j = 1;
while (i <= s[0] && j <= t[0])//s[0]存的是s的长度
{
if (s[i] == t[j])
{
++i; ++j;
}
else
{
i = i - j + 2; j = 1;
}
}
if (j > t[0])return i - t[0];
else return 0;
}
12、 KMP算法
int Index_kmp(sstring s, sstring t, int pos)//利用模式串t的next数组求t在主串s的第pos个字符后的位置
{
int i = pos;int j = 1;
while (i <= s[0] && j <= t[0])
{
if (j == 0 || s[i] == t[j])
{
++i; ++j;
}
else j = next[j];
}
if (j > t[0])return i - t[0];
else return 0;
}
void get_next(sstring t, int next[])//求模式串t的next函数值并存入数组next
{
int i = 1; next[1] = 0;int j = 0;
while (i < t[0])
{
if (j == 0 || t[i] == t[j])
{
++i; ++j;
next[i] = j;
}
else j = next[j];
}
}
13、 广义表

typedef enum { atom, list } elemtag;//atom=0表示原子，list=0表示有子表(涉及enum的用法)
typedef struct glnode
{
char ATOM;//原子节点的值
struct{ struct glnode * hp,tp; }ptr;//ptr是表节点的指针域，hp表示表头，tp表示表尾（相当于next）
}glist;
14、 二叉树的建立于遍历
#include<stdio.h>
#include
using namespace std;
typedef struct bitnode
{
char data;
struct bitnode lchild, * rchild;
}bitnode,bitree;
void inordertraverse1(bitree t)//中序遍历输出运用递归
{
if (t)
{
inordertraverse1(t->lchild);
cout << t->data;
inordertraverse1(t->rchild);
}
}
//void preprint(tree& T)//先序输出
//{
// if (T)
// {
// cout << " " << T->data;
// preprint(T->left);
// preprint(T->right);
// }
//}
//void postprint(tree& T)//后序输出
//{
// if (T)
// {
// postprint(T->left);
// postprint(T->right);
// cout << " " << T->data;
// }
//}

//void inordertraverse2(bitree t)//应用循环，不属于递归
//{
// initstack(s);//初始化一个链栈S，存地址；
// bitree p = t;
// while (p || !stackempty(s))
// {
// if §
// {
// push(s, p);//节点压入栈
// p = p->lchild;
// }
// else
// {
// pop(s, p);//此处的pop与之前的pop不同此处应改变p的指向，使其指向s中的元素
// cout << t->data;
// p = p->rchild;
// }
// }
//}
void creatbitree(bitree &t)//应用递归先序建立二叉链表
{
char ch;
cin >> ch;
if (ch == ‘#’)t = NULL;
else
{
t = new bitnode;
t->data = ch;
creatbitree(t->lchild);
creatbitree(t->rchild);
}
}
void copy(bitree t, bitree& newtree)//复制二叉树
{
if (t == NULL)
{
newtree = NULL;
return;
}
else
{
newtree = new bitnode;
newtree->data = t->data;
copy(t->lchild, newtree->lchild);
copy(t->rchild, newtree->rchild);
}
}
int depth(bitree t)//应用递归求二叉树的深度
{
if (t == NULL)return 0;
else
{
int m, n;
m = depth(t->lchild);
n = depth(t->rchild);
if (m > n)return m + 1;
else return n + 1;
}
}
int nodecount(bitree t)//统计二叉树的节点个数
{
if (t == NULL)
{
return 0;
}
else return nodecount(t->lchild) + nodecount(t->rchild)+1;
}

int main()
{
bitree t,s;
creatbitree(t);
copy(t, s);
inordertraverse1(s);
cout << endl;
cout << nodecount(s) << endl;
cout << depth(s) << endl;
return 0;
}
15、 哈夫曼编码
#pragma warning( disable : 4996)
#include<stdio.h>
#include<stdlib.h>
#include
#include
using namespace std;
typedef struct {
int weight;
int parent, lchild, rchild;
}HTNode, * HTNodep;
typedef char** hfcode;
void Select(HTNode HT[], int m, int& s1, int& s2) {//从这m个数里边选择最小的2个//把第一个进行标记就ok
int i;//从下标为1的位置开始计数
int min1 = 1000;
int min2 = 1000;//规定一个特别大的数

for (i = 1; i <= m; i++) {
	if (HT[i].parent == 0 && min1 > HT[i].weight) {
		min1 = HT[i].weight;
		s1 = i;
	}
}
for (i = 1; i <= m; i++) { 
	if (i != (s1) && HT[i].parent == 0)
		if (HT[i].weight < min2) {
			min2 = HT[i].weight;
			s2 = i;
		}

}

}
void creattree(HTNodep &HT,int n)//创建哈夫曼树
{
int s1=1000, s2=1000;
if (n <= 1) return;
int m = 2 * n - 1;
HT = new HTNode[m + 1];
for (int i = 1; i <= m; ++i)
{
HT[i].parent = 0; HT[i].lchild = 0; HT[i].rchild = 0;
}
for (int i = 1; i <= n;++i)
{
cin >> HT[i].weight;
}
for (int i = n + 1; i <= m; ++i)
{
Select(HT, i - 1, s1, s2);
HT[s1].parent = i;
HT[s2].parent = i;
HT[i].lchild = s1;
HT[i].rchild = s2;
HT[i].weight = HT[s1].weight + HT[s2].weight;
}
}
void printtree(HTNodep& HT,int n)//打印哈夫曼树
{
for (int i = 1; i < 2 * n; i++) {//是2n-1个结点，申请了2n个位置0-2n-1（这是2n个用1-2n-1）
printf("%2d %6d %6d %6d %6d\n", i, HT[i].weight, HT[i].parent, HT[i].lchild, HT[i].rchild);
}
}
void creathfcode(HTNodep HT, hfcode &HC, int n)//创建哈夫曼编码
{
HC = new char* [n + 1];
char* cd = new char[n];
cd[n - 1] = ‘\0’;
for (int i = 1; i <= n; i++)
{
int start = n - 1;
int c = i,f = HT[i].parent;
while (f != 0)
{
–start;
if (HT[f].lchild == c)cd[start] = ‘0’;
else cd[start] = ‘1’;
c = f; f = HT[f].parent;
}
HC[i] = new char[n - start];
strcpy(HC[i], &cd[start]);
}
}
int main()
{
HTNodep HT;
hfcode HC;
HC=NULL;
creattree(HT, 4);
printtree(HT, 4);
creathfcode(HT, HC, 4);
for (int i = 1; i <= 4; i++)
{
cout << HT[i].weight<< “:”;
int j = 0;
while (HC[i][j] != ‘\0’)
{
cout << HC[i][j] << " “;
j++;
}
cout << endl;
}
return 0;
}
16、Primtree和kruskal最短路径
#include<stdio.h>
#include
using namespace std;
#define maxint 327667//表示极大值相当于正无穷
#define mvnum 100// 表示最大顶点数
typedef char vertextype;//顶点数据类型
typedef int arctype;//边的权值
typedef struct
{
vertextype vexs[mvnum];//顶点表
arctype arcs[mvnum][mvnum];//邻接矩阵
int vexnum, arcnum;//顶点数和边数
}amgraph;
int located(amgraph G, char v1)
{
int i = 0;
for (i; i < G.vexnum; i++)
{
if (G.vexs[i] == v1)
{
return i;
}
}
}
struct//该结构体为kruskal所用的
{
vertextype Head;
vertextype Tail;
arctype lowcost;
}edge[8];//这里的8要求是边数，可以改变。
int creatudn(amgraph& G)
{
cin >> G.vexnum >> G.arcnum;//输入顶点数和边数
for (int i = 0; i < G.vexnum; i++)
{
cin >> G.vexs[i];
}
for (int i = 0; i < G.vexnum; i++)
{
for (int j = 0; j < G.vexnum; j++)
{
G.arcs[i][j] = maxint;
}
}
for (int k = 0; k < G.arcnum; k++)
{
int w;
char v1, v2;
cin >> v1 >> v2 >> w;
edge[k].Head = v1; edge[k].Tail = v2; edge[k].lowcost = w;
int i = located(G, v1);
int j = located(G, v2);
G.arcs[i][j] = G.arcs[j][i] = w;
}
return 1;
}
struct
{
vertextype adjvex;//最小边在U(已经确定的点)中的那个顶点
arctype lowcost;//最小边的权值
}closedge[mvnum];
void primtree(amgraph g, char m)//普利姆
{
int k = located(g, m);
for (int j = 0; j < g.vexnum; j++)
{
if (j != k) closedge[j] = { m,g.arcs[k][j] };
}
closedge[k].lowcost = 0;
for (int i = 1; i < g.vexnum; i++)
{
int k = 200;
for (int i = 0; i < g.vexnum; i++)
{
if (closedge[i].lowcost != 0 && closedge[i].adjvex < k)k = i;
}
char u0 = closedge[k].adjvex;
char v0 = g.vexs[k];
cout << u0 << " " << v0 << endl;
closedge[k].lowcost = 0;
for (int j = 0; j < g.vexnum; j++)
if (g.arcs[k][j] < closedge[j].lowcost)
closedge[j] = { g.vexs[k],g.arcs[k][j] };
}
}
int vexset[mvnum];
void kruskal(amgraph g)//克鲁斯卡尔
{
int v1,v2,vs1,vs2;
//sort(edge);此处作者懒狗自己没写
for (int i = 0; i < g.arcnum; i++)
{
vexset[i] = i;
}
for (int i = 0; i < g.arcnum; i++)
{
v1 = located(g, edge[i].Head);
v2= located(g, edge[i].Tail);
vs1 = vexset[v1];
vs2 = vexset[v2];
if (vs1 != vs2)
{
cout << edge[i].Head << " " << edge[i].Tail << endl;
}
for (int i = 0; i < g.arcnum; i++)
{
if (vexset[i] == vs2)vexset[i] = vs1;
}
}
}
int main()
{
amgraph G;
creatudn(G);
for (int i = 0; i < G.vexnum; i++)
{
for (int j = 0; j < G.vexnum; j++)
{
printf(”%11d", G.arcs[i][j]);
}
cout << endl;
}
kruskal(G);
//primtree(G, ‘a’);
return 0;
}
17、线索二叉树
#include<stdio.h>
#include
using namespace std;
typedef struct bithrnode {
char data;
struct bithrnode* lchild, *rchild;
int ltag, rtag;//左右标志
}bithrnode,*bithrtree;
bithrtree pre;
void initthrtree(bithrtree p)//根据已有子树建立中序线索化
{
if §
{
initthrtree(p->lchild);
if (!p->lchild)
{
p->ltag = 1;
p->lchild = pre;
}
if (!pre->rchild)
{
pre->rtag = 1;
pre->rchild = p;
}
pre = p;
initthrtree(p->rchild);
}
}
void inorderthread(bithrtree& thrt, bithrtree t)//中序遍历t并且将其中序线索化放入thrt中，存在问题尚未解决
{
thrt = new bithrnode;
thrt->ltag= 0; thrt->rtag = 1;
thrt->rchild = thrt;
if (!t)thrt->lchild = thrt;
else {
thrt->lchild = t;
pre = thrt;
initthrtree(t);
pre->rchild = thrt;
thrt->rtag = 1;
thrt->rchild = pre;
}
}
void inordertraver(bithrtree T)//遍历，存在问题尚未解决
{
bithrtree p;
p = T->lchild;
while (p != T)
{
while (p->ltag == 0)p = p->lchild;
cout << p->data;
while (p->rtag == 1 && p->rchild != T)
{
p = p->rchild; cout << p->data;
}
p = p->rchild;
}
}