数据结构与算法实现代码

㈠ 求数据结构算法平衡二叉树实现代码

抄的，你能看懂就行。平衡二叉树实现代码
#include <stdio.h>
typedef struct bitreetype
{
int item;
int bdegree;/*平衡因子,左子树深度-右子树深度*/
struct bitreetype *lchild;
struct bitreetype *rchild;
}bitree;
typedef struct treequeuetype
{
int head;
int tail;
bitree *items[1000];
}treequeue;/*定义一个队列,后面的平衡调整要用层序遍历,于是要用这个队列*/
void resetqueue(treequeue *queue)
{
queue->head=-1;
queue->tail=-1;
return;
}/*把队列清空*/
void inqueue(treequeue *queue,bitree *element)
{
queue->tail++;
queue->items[queue->tail]=element;
}/*入队列*/
bitree *outqueue(treequeue *queue)
{
queue->head++;
return queue->items[queue->head];
}/*出队列*/
int isqueueempty(treequeue *queue)
{
if(queue->head==queue->tail)
return 1;
else
return 0;
}/*判断队列是否为空*/
void fillmemory(char *source,int len,char content)
{
while(len)
{
source=source+len;
*source=content;
source=source-len;
len--;
}
*source=0;
}/*用CONTENT的内容去FILL以SOURCE为首,LEN长度的一块空间,初始化内存方便*/
int getnums(int *dst)/*输入字符串并把字符串转化为一串数存入DST指向的内存中去,我们用它采集原始数据*/
{
char *temp,*num,*p,t;
int len=0;
temp=(char *)malloc(1000*sizeof(char));
num=(char *)malloc(20*sizeof(char));
p=num;
fillmemory(temp,1000,0);
fillmemory(num,20,0);
scanf(\"%s\",temp);
t=*temp;
temp++;
while(t)
{
if(t!=\’,\’)
{
*num=t;
num++;
t=*temp;
temp++;
}/*抽出一个数放入NUM临时空间中*/
else
{
num=p;
*dst=atoi(num);
len++;
fillmemory(num,20,0);
dst++;
t=*temp;
temp++;
}/*将NUM中的数字转化出来存入DST中*/
}
num=p;
*dst=atoi(num);
len++;
fillmemory(num,20,0);
dst++;
t=*temp;
temp++;
return len;
}/*处理最后一个数字*/

㈡ 浙大远程教育数据结构与算法13秋实验代码

我用python和c++写的，如果你不想要python的，请告知。

#表达式转换
defmain():
text=raw_input()
root=build(text)
litx=[]
travel(root,litx)
rslt=litx[0]
foriinrange(1,len(litx)):
rslt=rslt+''+litx[i]
printrslt

defbuild(text):
left=readnode(text);
ifleft['text']=='':
returnleft['node']
text=left['text']
right=readnode(text[1:])
root={}
root['value']=text[0]
root['left']=left['node']
root['right']=right['node']
text=right['text']

whiletext!='':
left=root
right=readnode(text[1:])
root={}
root['value']=text[0]
root['right']=right['node']
ifsignlevel(left['value'])>=signlevel(text[0]):
root['left']=left
else:
root['left']=left['right']
left['right']=root
root=left
text=right['text']

returnroot

deftravel(root,litx):
ifroot['left']!={}:
travel(root['left'],litx)
ifroot['right']!={}:
travel(root['right'],litx)
litx.append(root['value'])

defreadnode(text):
#print'---------------------------readnode'
#printtext
node={}
iftext[0]=='(':
index=readbrace(text)
node=build(text[1:index])
else:
index=readnumber(text)
iftext[0]=='+':
node['value']=text[1:index+1]
else:
node['value']=text[0:index+1]
node['left']={}
node['right']={}
#printnode
#print'++++++++++++++++++++++++++readnode'
return{'node':node,'text':text[index+1:]}

defreadnumber(text):
index=0
foriinrange(1,len(text)):
iftext[i]in['+','-','*','/']:
break
index=i
returnindex

defreadbrace(text):
count=1
i=0
whilecount>0:
i=i+1
iftext[i]=='(':
count=count+1;
iftext[i]==')':
count=count-1;
returni

defsignlevel(sign):
ifsignin['+','-']:
return1
else:
return2

if__name__=="__main__":
main()

#家谱处理
defmain():
text=raw_input()
n=int(text[0:text.find('')])
m=int(text[text.find('')+1:])

root=build(n)
check(root,m)

defbuild(n):
raw_name=raw_input()
name=raw_name.strip()
root={}
root['name']=name
root['layer']=0
root['child']={}
root['sibling']={}

pre_node=root
foriinrange(1,n):
raw_name=raw_input()
name=raw_name.strip()
cur_layer=raw_name.index(name)/2
cur_node={}
cur_node['name']=name
cur_node['layer']=cur_layer
cur_node['child']={}
cur_node['sibling']={}
ifcur_layer==pre_node['layer']:
pre_node['sibling']=cur_node
elifcur_layer==pre_node['layer']+1:
pre_node['child']=cur_node
elifcur_layer==pre_node['layer']+1:
print'error!
'
break
elifcur_layer<pre_node['layer']:
path=getpath(root,pre_node['name'])
pre_subling={}
forpinpath:
ifp['layer']>cur_layer:
break
else:
pre_subling=p
pre_subling['sibling']=cur_node
pre_node=cur_node

returnroot

defcheck(root,m):
#XisachildofY
#XistheparentofY
#XisasiblingofY
#XisadescendantofY
#XisanancestorofY
foriinrange(0,m):
text=raw_input()
X=text[0:text.find('')]
Y=text[text.rfind('')+1:]
if'child'intext:
path=getpath(root,X)
iflen(path)>=2andpath[-2]['name']==Y:
printTrue
else:
printFalse
if'parent'intext:
path=getpath(root,Y)
iflen(path)>=2andpath[-2]['name']==X:
printTrue
else:
printFalse
if'sibling'intext:
pathX=getpath(root,X)
pathY=getpath(root,Y)
iflen(pathX)>=2andlen(pathY)>=2andpathX[-2]['name']==pathY[-2]['name']:
printTrue
else:
printFalse
if'descendant'intext:
path=getpath(root,X)
forpinpath:
ifp['name']==Y:
break
ifp['name']==Y:
printTrue
else:
printFalse
if'ancestor'intext:
path=getpath(root,Y)
forpinpath:
ifp['name']==X:
break
ifp['name']==X:
printTrue
else:
printFalse

defgetpath(root,node_name):
path=[root]
next_node=root['child']
whileTrue:
whilenext_node!={}:
path.append(next_node)
ifnext_node['name']==node_name:
returnpath
next_node=next_node['child']

next_node=path.pop()
ifpath==[]:
returnpath
else:
next_node=next_node['sibling']

if__name__=="__main__":
main()

//奥运排行榜
#include<iostream>
#include<algorithm>

usingnamespacestd;

constintMAX=224;
typedefstruct
{
intindex;
doubleno;
intrange;
}ELEM;
intcmp_des(constELEM&a,constELEM&b){
returna.no>b.no;//降序
}
intcmp_aes(constELEM&a,constELEM&b){
returna.index<b.index;//升序
}
intmain()
{
intn,m;
cin>>n>>m;

doubledata[5][MAX];
intpaiming[5][MAX];
ELEMtmp[MAX];
intcountry[MAX];
inti,j;
for(i=0;i<n;i++)
{
cin>>data[1][i]>>data[2][i]>>data[0][i];
data[3][i]=data[1][i]/data[0][i];
data[4][i]=data[2][i]/data[0][i];
}
for(i=0;i<m;i++)
cin>>country[i];

for(i=1;i<=4;i++)
{
for(j=0;j<n;j++)
{
tmp[j].index=j;
tmp[j].no=data[i][j];
}
sort(tmp,tmp+n,cmp_des);
for(j=0;j<n;j++)
{
if(j>0&&tmp[j].no==tmp[j-1].no)
tmp[j].range=tmp[j-1].range;
else
tmp[j].range=j+1;
}
sort(tmp,tmp+n,cmp_aes);
for(j=0;j<n;j++)
{
paiming[i][j]=tmp[j].range;
}
}

inttop_12,top_34,top_1234;
for(i=0;i<m;i++)
{
top_12=paiming[1][country[i]]<=paiming[2][country[i]]?1:2;
top_34=paiming[3][country[i]]<=paiming[4][country[i]]?3:4;
top_1234=paiming[top_12][country[i]]<=paiming[top_34][country[i]]?top_12:top_34;
printf("%d:%d",(int)paiming[top_1234][country[i]],(int)top_1234);
if(i<m-1)
printf("");
}

return0;
}

㈢ （数据结构与算法）已经并查集的Find函数部分代码如下，请补充剩余代码

如果你的tree数组一开始初始为-1
int Find(int x)
{
int s;
s=x;
while(tree[s]!=-1)
s=tree[s];
return s;
}

如果tree[i]初始化为i
int Find(int x)
{
int s;
s=x;
while(tree[s]!=s) //tree数组是并查集数组，-1假设为根节点的父节点。。
s=tree[s];
return s;
}

㈣ 《数据结构与算法分析》(C++版第二版)中的“可利用空间表”的实现代码的疑问

不是楼主说的意思吧。
它的意思是你可以初始化一段内存，存放在
Link<Elem>* Link<Elem>::freelist中
当我们需要申请内存的时候，只需要从freelist中快速的取出一段即可
然而，当freelist已经使用完毕后，就调用C++默认的::new来申请
内存；
只不过这段代码的freelist的初始化部分并没有给出。

㈤ 数据结构算法代码

我感觉你很有必要把这段代码好好的整理、规范下。。。

typedef
char
ListItem;
typedef
struct
node
*link;

typedef
struct
node
{

ListItem
element;

link
next;
}Node;

typedef
struct
llist
*List;

typedef
struct
llist
{

link
first;
}Llist;

估计到后面，你都弄不清楚，这里面的哪个是哪个了吧。

把这段整理清楚之后，出了问题也就很容易找了。。

㈥ java算法与数据结构代码

第1题：我给你搭建算法框架，具体需求，你只需往里面写Code即可：

publicclassProgram{

	privatestaticfinalintN=6;
	publicstaticvoidmain(String[]args){
		Nodehead=newNode(-1,null);//定义头指针,带头结点的单链表
for(inti=0;i<N;i++){
	Nodee=newNode(i+1,null);
	tailInsert(head,e);
}

//Test
Nodep=head;
while(p.getNext()!=null){
	p=p.getNext();
}
	}
	
	/**
	*@paramhead实施尾插法算法的单链表头指针
	*@parame所需的元素
	*/
	privatestaticvoidtailInsert(Nodehead,Nodee){
		Nodep=head;
		while(p.getNext()!=null){
			p=p.getNext();//寻访单链表,直至到达单链表末尾
		}
		//实施尾插法
		p.setNext(e);
	}
}

classNode{
	privateintid;//编号
	privateNodenext;//单链表后继指针
	privateStringvote;//选票
	
	publicNode(){}
	publicNode(intid,Nodenext){
		super();
		this.id=id;
		this.next=next;
	}
	publicNode(intid,Nodenext,Stringvote){
		super();
		this.id=id;
		this.next=next;
		this.vote=vote;
	}
	@Override
	publicStringtoString(){
		return"Node[id="+id+",next="+next+"]";
	}
	publicintgetId(){
		returnid;
	}
	publicvoidsetId(intid){
		this.id=id;
	}
	publicNodegetNext(){
		returnnext;
	}
	publicvoidsetNext(Nodenext){
		this.next=next;
	}
}

第2题：参看我以前的回答：https://..com/question/431512924412893084

算法思想已经写的清楚得不能在清楚了。转成Java就是小菜一碟。

㈦ 数据结构与算法实验代码

#include <cstdio>

int gold[225],medal[225],population[225];
int list[10];
int fir = 0;//用来判断是否是第一个元素用的
void printresult(int check_number,int n);
int main()
{
int n,m;

scanf("%d%d",&n,&m);
for(int i = 0;i < n;i++)
scanf("%d%d%d",&gold[i],&medal[i],&population[i]);
for(int i = 0;i < m;i++)
{
int check_number;
scanf("%d",&check_number);
printresult(check_number,n);
}
printf("\n");
return 0;
}
void printresult(int check_number,int n)
{
for(int i = 0;i < n;i++)
{
if(gold[i]>gold[check_number])
list[1]++;
}
int result = ++list[1];//这里还要多加一个1，因为数组原来是0
int num = 1;
for(int i = 0;i < n;i++)
{
if(medal[i]>medal[check_number])
list[2]++;
}
list[2]++;
double gold_per = gold[check_number]*1.0/population[check_number];
for(int i = 0;i < n;i++)
{
if((gold[i]*1.0/population[i])>gold_per)
list[3]++;
}
list[3]++;
double medal_per = medal[check_number]*1.0/population[check_number];
for(int i = 0;i < n;i++)
{
if(medal[i]*1.0/population[i]>medal_per)
list[4]++;
}
list[4]++;
for(int i = 1;i < 5;i++)
{
if(list[i]<result)
{
result = list[i];
num = i;
}
}
for(int i = 1;i < 5;i++)
list[i] = 0;//对排名数组清零，因为之后要多次调用
if(!fir)
{
printf("%d:%d",result,num);//首个输入前面不用空格
fir = 1;
}
else
printf(" %d:%d",result,num);
}
//如果超时的话还可以再优化，不过国家的数量比较少，应该不会
//优化就是把排名是1的话直接输出，不进行之后运算

㈧ 刚学数据结构，题目不会，给个代码（算法）参考

1
#include "stdio.h"

#define MAXSIZE 32

typedef char datatype;

typedef struct _Node{
datatype data;
_Node *lchild, *rchild;
}Node, *PNode, *PBitTree;

void visit(PNode node){
printf("%c\t", node->data);
}

(1)
void PreOrder(PBitTree root){
if(!root) return;
visit(root);
PreOrder(root->lchild);
PreOrder(root->rchild);
}

void InOrder(PBitTree root){
if(!root) return;
InOrder(root->lchild);
visit(root);
InOrder(root->rchild);
}

void PostOrder(PBitTree root){
if(!root) return;
PostOrder(root->lchild);
PostOrder(root->rchild);
visit(root);
}

(2)
void Display(PBitTree root){
PNode nodeQueue[MAXSIZE]; /*结点队列*/
int levelQueue[MAXSIZE]; /*用于保存结点层次信息的队列*/
int front=0, rear=0, curlevel = 0, bline = 0; /*bline用于判断是否需要换行*/
PNode p = root;
if(p) { /*根结点入队*/
nodeQueue[rear] = p;
levelQueue[rear] = 0;
rear = (rear + 1) % MAXSIZE;
}
while(front != rear) { /*如果队列不空*/
p = nodeQueue[front]; /*获取队首元素*/
bline = levelQueue[front] != curlevel ? 1 : 0; /*判断是否需要换行*/
curlevel = levelQueue[front];
front = (front + 1) % MAXSIZE; /*出队*/
if(bline) printf("\n"); /*如果需要换行，则输出换行符*/
visit(p);
if(p->lchild) { /*如果左孩子不空，将左孩子入队*/
nodeQueue[rear] = p->lchild;
levelQueue[rear] = curlevel + 1;
rear = (rear + 1) % MAXSIZE;
if(p->rchild) { /*如果右孩子不空，将右孩子入队*/
nodeQueue[rear] = p->rchild;
levelQueue[rear] = curlevel + 1;
rear = (rear + 1) % MAXSIZE;
}
}
}

(3)
void Exchange(PBitTree root) {
if(!root) return;
PNode tmp;
Exchange(root->lchild);
Exchange(root->rchild);
tmp = root->lchild;
root->lchild = root->rchild;
root->rchild = tmp;
}

2
typedef char datatype;

typedef struct _listNode{
datatype data;
_listNode *next;
}RQueueNode, *PRQueueNode, *PRQueue;

PRQueue rear;

void InitRQueue( ) { /*初始化队列*/
rear = (PRQueue) malloc(sizeof(RQueueNode)); /*生成附加头结点*/
rear->next = rear; /*设置为循环的空队*/
}

void EnRQueue(datatype x) { /*入队*/
PRQueueNode *newNode;
newNode = (PRQueue) malloc(sizeof(RQueueNode)); //生成新结点
newNode->data = x;
newNode->next = rear->next; /*将新结点链接到队尾*/
rear->next = newNode;
rear = newNode; /*将新结点作为新的队尾*/
}

datatype DeRQueue( ) { /*出队*/
PRQueueNode *front; /*队首指针*/
datatype tmp; /*用于返回队首元素数据*/
assert(rear->next != rear); /*断言队列不空*/
front = rear->next->next;
rear->next->next = front->next;
if(rear == front) rear = rear->next; /*如果出队的是队列中的最后一个结点*/
tmp = front->data;
free(front);
return tmp;
}

㈨ （数据结构与算法）请编写一个代码段，弹出队列中所有结点，用STL中得队列实现

#include<stdio.h>
#include<queue>
using namespace std;
int main(void)
{
queue<int>Q;
while(!Q.empty())Q.pop();

int i;
for(i=0;i<10;i++)
{
Q.push(i);
}
while(!Q.empty())
{
printf("%d ",Q.front());
Q.pop();
}
puts("");
return 0;
}