❶ 求严蔚敏教授编写的（《数据结构》c语言版）中赫夫曼算法的完整代码

//*************预定义****************
# include <stdio.h>
# include <malloc.h>
# include <iostream.h>
# include <conio.h>
# include <string.h>
# define MAX_LENGTH 100
typedef char **HuffmanCode;
//**********数据结构*************
typedef struct
{ int weight; //权值
int parent,lchild,rchild; //双亲，左右孩子
}HTNode,*HuffmanTree; //结点和指针
//**********select函数**************
void Select(HuffmanTree HT,int i,int &s1,int &s2)
{ //在建立哈夫曼树的所有结点中选择权值最小的两个结点存放在s1,s2中
int j,k=1;
while(HT[k].parent!=0)
k++;
s1=k;
for(j=1;j<=i;++j)
if(HT[j].parent==0&&HT[j].weight<HT[s1].weight)
s1=j;
k=1;
while((HT[k].parent!=0||k==s1))
k++;
s2=k;
for(j=1;j<=i;++j)
if(HT[j].parent==0&&HT[j].weight<HT[s2].weight&&j!=s1)
s2=j;
}
//**********构建哈夫曼树***********************
void HuffmanCoding（huffmanTree &HT,hu）
void HuffmanCoding(HuffmanTree &HT,HuffmanCode&HC,int *w,int n)
{ int m,i,s1,s2,start,c,f;
HuffmanTree p;
if(n<=1)
return;
m=2*n-1;//由得到的叶子数而计算结点总数
HT=(HuffmanTree)malloc((m+1)*sizeof(HTNode));//分配存储空间
for(p=HT+1,i=1;i<=n;++i,++p,++w)
{ p->weight=*w;//为结点初始化权值
cout<<endl<<"HT["<<i<<"].weight="<<p->weight<<" ";
p->parent=0;
p->lchild=0;
p->rchild=0;
}
for(;i<=m;++i,++p)
{ p->weight=0;
p->parent=0;
p->lchild=0;
p->rchild=0;
}//初始化双亲和左右孩子，使他们成为孤立的
cout<<endl<<endl<<"哈弗曼树创建的顺序如下：";
for(i=n+1;i<=m;++i)
{ Select(HT,i-1,s1,s2); //调用select函数
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;//新结点的权值是s1和s2权值的和
cout<<endl<<"HT["<<s1<<"] and HT["<<s2<<"] create";
cout<<" HT["<<i<<"], weight="<<HT[i].weight;
}//每次选择最小的两个结点做左右孩子，权值和为新的结点的权值和，删去连个小的结点
//*********哈夫曼编码*****************
HC=(HuffmanCode)malloc((n+1)*sizeof(char *));
char *cd;
cd=(char *)malloc(n*sizeof(char));
cd[n-1]='\0';
cout<<endl<<endl<<"HuffmanTree编码是："<<endl;
for(i=1;i<=n;++i)//从底下往上寻回编码
{ start=n-1;
for(c=i,f=HT[i].parent;f!=0;c=f,f=HT[f].parent)
if(HT[f].lchild==c)
cd[--start]='0';
else
cd[--start]='1';
HC[i]=(char*)malloc((n-start)*sizeof(char));
strcpy(HC[i],&cd[start]);
printf("\nHT[%d] node's Huffman code is: %s",i,HC[i]);
}
free(cd);
}
//****************主函数部分********************
void main()
{ HuffmanTree HT;
HuffmanCode HC;
int n,i;
int *w,W[MAX_LENGTH];
cout<<"***********本实验实现的是哈夫曼树的建立以及编码*********";//交互信息
cout<<endl<<"请输入哈弗曼树元素的个数： ";
cin>>n;
for(i=0;i<n;++i)
{ cout<<"请输入第 "<<i+1<<"个元素的权值（0~255的整数）： ";
cin>>W[i];
}
w=W;
HuffmanCoding(HT,HC,w,n);
getch();
}
个人觉得这个有点长。。不知道对不对。看看吧~

❷ 求解数据结构与算法题(C语言版)

一个遍历找到x，好像是
if(p.data等于x),
printf p.data
else
p等于p.left,
p等于p.right
注前序遍历，此时p指向x
treeLeft等于new tree(p.left)
treeRight等于new tree(p.right)
注，以版x的左，权右子树为根，分别构造二叉树
class tree,class node 自己写吧

❸ 数据结构算法（C语言描述）和C或C++程序具体什么关系啊

1、程序是写完源代码后，计算机编译后得到的可执行文件。
2、算法一般结合数学思想，以下内容算是算法：
给数组按大小排序、查找数组某元素、图形处理算法、音频识别处理。
但广义上，用了顺序分支循环就是算法。

❹ 数据结构C语言——实现各种排序算法

刚做完的
#include <iostream>
using namespace std;

void BiInsertsort(int r[], int n) //插入排序（折半）
{
for(int i=2;i<=n;i++)
{
if (r[i]<r[i-1])
{
r[0] = r[i]; //设置哨兵
int low=1,high=i-1; //折半查找
while (low<=high)
{
int mid=(low+high)/2;
if (r[0]<r[mid]) high=mid-1;
else low = mid+1;
}
int j;
for (j=i-1;j>high;j--) r[j+1] = r[j]; //后移
r[j+1] = r[0];
}
}
for(int k=1;k<=n;k++) cout<<r[k]<<" ";
cout<<"\n";
}

void ShellSort ( int r[], int n) //希尔排序
{
for(int d=n/2;d>=1;d=d/2) //以d为增量进行直接插入排序
{
for (int i=d+1;i<=n;i++)
{
r[0] = r[i]; //暂存被插入记录
int j;
for( j=i-d; j>0 && r[0]<r[j]; j=j-d) r[j+d] = r[j]; //记录后移d个位置
r[j+d] = r[0];

}
}
for(int i=1;i<=n;i++) cout<<r[i]<<" ";
cout<<"\n";
}

void BubbleSort(int r[], int n) //起泡排序
{
int temp,exchange,bound;
exchange=n; //第一趟起泡排序的范围是r[0]到r[n-1]
while (exchange) //仅当上一趟排序有记录交换才进行本趟排序
{
bound=exchange;
exchange=0;
for (int j=1; j<bound; j++) //一趟起泡排序
if (r[j]>r[j+1])
{
temp=r[j];
r[j]=r[j+1];
r[j+1]=temp;
exchange=j; //记录每一次发生记录交换的位置
}
}
for(int i=1;i<=n;i++) cout<<r[i]<<" ";
cout<<"\n";
}

int Partition(int r[], int first, int end) //快速排序一次划分
{
int i=first; //初始化
int j=end;
r[0]=r[first];
while (i<j)
{
while (i<j && r[0]<= r[j]) j--; //右侧扫描
r[i]=r[j];
while (i<j && r[i]<= r[0]) i++; //左侧扫描
r[j]=r[i];
}
r[i]=r[0];
return i; //i为轴值记录的最终位置
}
void QuickSort(int r[], int first, int end) //快速排序
{
if (first<end)
{ //递归结束
int pivot=Partition(r, first, end); //一次划分
QuickSort(r, first, pivot-1);//递归地对左侧子序列进行快速排序
QuickSort(r, pivot+1, end); //递归地对右侧子序列进行快速排序
}
}

void SelectSort(int r[ ], int n) //简单选择排序
{
int i,j,index,temp;
for (i=1; i<n; i++) //对n个记录进行n-1趟简单选择排序
{
index=i;
for (j=i+1; j<=n; j++) //在无序区中选取最小记录
if (r[j]<r[index]) index=j;
if (index!=i)
{
temp=r[i];
r[i]=r[index];
r[index]=temp;
}
}
for(i=1;i<=n;i++) cout<<r[i]<<" ";
cout<<"\n";
}

void main()
{
const int numv=12;
int a[3][numv]={{0,6,13,19,23,37,39,41,45,48,58,86},{0,86,58,48,45,41,39,37,23,19,13,6},{0,23,13,48,86,19,6,41,58,37,45,39}};
int z1[numv],z2[numv];
int m,n;
cout<<"请选择测试数据类型：⑴正序 ⑵逆序 ⑶随机 [ 若跳出,请按⑷ ]" <<endl;
cin>>m;
while(m>0&&m<4)
{
cout<<"请选择排序算法：⑴直接插入排序 ⑵希尔排序 ⑶冒泡排序 ⑷快速排序 \n ⑸简单选择排序"<<endl;
cin>>n;
switch(n)
{
case 1:
cout << "直接插入排序前：" << "\n";
for(int j=1;j<numv;j++) cout<<a[m-1][j]<<" ";
cout << "\n直接插入排序结果为：" << "\n";
BiInsertsort(a[m-1],numv-1);
break;
case 2:
cout << "\n希尔排序前：" << "\n";
for(int j=1;j<numv;j++) cout<<a[m-1][j]<<" ";
cout << "\n希尔排序结果为：" << "\n";
ShellSort(a[m-1], numv-1);
break;
case 3:
cout << "\n冒泡排序前：" << "\n";
for(int k=1;k<numv;k++) cout<<a[m-1][k]<<" ";
cout << "\n冒泡排序结果为：" << "\n";
BubbleSort(a[m-1], numv-1);
break;
case 4:
cout << "\n快速排序前：" << "\n";
for(int j=1;j<numv;j++) cout<<a[m-1][j]<<" ";
cout << "\n快速排序结果为：" << "\n";
QuickSort(a[m-1],0,numv-1);
for(int i=1;i<numv;i++)
cout<<a[m-1][i]<<" ";
cout<<"\n";
break;
case 5:
cout << "\n简单选择排序前：" << "\n";
for(int j=1;j<numv;j++) cout<<a[m-1][j]<<" ";
cout << "\n简单选择排序结果为：" << "\n";
SelectSort(a[m-1],numv-1);
break;

default:
cout<<"输入错误！"<<endl;
}
m=0;
cout<<"请选择测试数据类型：⑴正序 ⑵逆序 ⑶随机 [ 若跳出,请按⑷ ]" <<endl;
cin>>m;
}
if(m==4) cout<<"(*^__^*) 再见！"<<endl;
else cout<<"输入错误！"<<endl;
}

❺ 数据结构C语言版算法时间复杂度计算

把那些基本的时间复杂度记住，然后遇到循环就相乘，遇到顺序结构就相加回，而一般高阶答的复杂度可以吞并低阶的。
比如说，二分法的复杂度是和log(n)同阶，如果再出现在对n个数的遍历的循环中，复杂度就是和n*log(n)同阶。
如果先二分查找，再顺序查找，就是n+log(n)。

❻ 请问大学学习数据结构与算法（C语言版）需要多强的C语言基础

有时间的话肯定是深入学习一下比较好，不过也不要有压力，大学的东西都是“平易近人内”的，只容要你认真学肯定是没问题的，顶多就是比基础好的人多花点时间。
数据结构的话跟C语言还有点关系，但是大部分人对数据结构都不会很了解，所以基本可以认为你们处于同一起跑线。
算法的话重要的是你的逻辑思维能力和数学功底，C语言只是实现算法的工具，只要算法理解透了，你可以用C++，可以用Java，甚至脚本语言Python，如果C语言基础好，只会使你实现算法的时候更加顺手，但算法的实现本不是算法学习的精髓，算法本身及逻辑能力的提高才是你需要重点关注的。

❼ 数据结构中常见的算法（C语言版）

1、冒泡排序（最容易考到）
#include<stdio.h>
#define N 5

void main()
{
int i=0,j=0;
int a[n],temp;
int *ptr1,*ptr2;
ptr1=&a[j+1];
ptr2=&temp;
printf("\n输入数字串:\n",N);
for(i=0;i<N;i++)
{
scanf("%d",&a[i]);

}
for(i=0;i<N;i++)
{
for(j=0;j<N;j++)
{
if(a[j]<a[j+1])
{
/*交换元素*/
ptr2=a[j+1];
a[j+1]=a[j];
a[j]=ptr2;
}
}
}
printf("\n排序后的数字串:");
for(i=0;i<N;i++)
{
printf("%d",a[i]);
}
printf("\n");
}
2、统计字符个数
#include<stdio.h>
void main()
{
char line[100];
int i,count=0;
printf("\n请输入一行字符： ");
gets(line);
i=0;
while(line[i]!='\0')
{
if(line[i]=='x'||line[i]=='X')
{
count++;
}
i++;
}
printf("\n其中X的个数为%d\n",count);

}
3、数字翻转
#include<stdio.h>
void main()
{
int a,b;
a=0;
do
{
printf("\n请输入一个数:");
scanf("%d",&a);
if(a<=0)
printf("该数必须为正数\n");
}while(a<=0);
printf("\n反转后的数为:");
do
{
b=a%10;
printf("%d",b);
a=a/10;
}while(a!=0);
printf("\n");
}
我这里还有好多，需要的联系我QQ

❽ 《数据结构（C语言版）》之“串的模式匹配算法”

# include <string.h>
# include <stdio.h>
# include <stdlib.h>
# define OK 1
# define ERROR 0
typedef int Status;
//串的定长顺序存储结构
# define MAX_STR_LEN 40
typedef char SString[MAX_STR_LEN + 1];//0号单元存放串的长度
Status StrAssign(SString T,char * chars)//生成一个其值等于chars的串T
{
int i;
if (strlen(chars) > MAX_STR_LEN)
{
return ERROR;
}
else
{
T[0] = strlen(chars);
for (i=1; i<=T[0]; ++i)
{
T[i] = * (chars + i - 1);
}
return OK;
}
}
//返回串S的元素的个数
int StrLength(SString S)
{
return S[0];
}
//用Sub返回串S的自第pos个字符起长度为len的子串
Status SubString(SString Sub,SString S,int pos,int len)
{
int i;
if (pos<1 || pos>S[0] || len<0 || len>S[0]-pos+1)
{
return ERROR;
}
for (i=1; i<=len; ++i)
{
Sub[i] = S[pos+i-1];
}
Sub[0] = len;
return OK;
}
//输出字符串T
void StrPrint(SString T)
{
int i;
for (i=1; i<=T[0]; ++i)
{
printf("%c ",T[i]);
}
printf("\n");
}
//求模式串T的next函数值并存入数组next
void get_next(SString T,int next[])
{
int i = 1,j = 0;
next[1] = 0;
while (i < T[0])
{
if (j==0 || T[i]==T[j])
{
++i;
++j;
next[i] = j;
}
else
{
j = next[j];
}
}
}
//求模式串T的next函数修正值并存入数组nextval
void get_nextval(SString T,int nextval[])
{
int i = 1,j = 0;
nextval[1] = 0;
while (i < T[0])
{
if (j==0 || T[i]==T[j])
{
++i;
++j;
if (T[i] != T[j])
{
nextval[i] = j;
}
else
{
nextval[i] = nextval[j];
}
}
else
{
j = nextval[j];
}
}
}
//利用模式串T的next函数求T在主串S中第pos字符之后的位置的KMP算法
//1=<pos=<StrLength(S)
int Index_KMP(SString S,SString T,int pos,int next[])
{
int i = pos,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;
}
}
int main(void)
{
int i,* p;
SString s1,s2;
StrAssign(s1,"aaabaaaab");
printf("主串为：");
StrPrint(s1);
StrAssign(s2,"aaaab");
printf("子串为：");
StrPrint(s2);
p = (int *)malloc((StrLength(s2) + 1) * sizeof(int));
get_next(s2,p);
printf("子串的next的数组为：");
for (i=1; i<=StrLength(s2); ++i)
{
printf("%d ",* (p+i));
}
printf("\n");
i = Index_KMP(s1,s2,1,p);
if (i)
{
printf("主串和子串在第%d个字符处首次匹配\n",i);
}
else
{
printf("主串和子串匹配不成功\n");
}
get_nextval(s2,p);
printf("子串的nextval数组为：");
for (i=1; i<=StrLength(s2); ++i)
{
printf("%d ",* (p+i));
}
printf("\n");
printf("主串和子串在第%d个字符处首次匹配\n",Index_KMP(s1,s2,1,p));
printf("求串s1的从第5个字符起长度为5的子串s2:\n");
SubString(s2,s1,5,5);
printf("串s2为:");
StrPrint(s2);
return 0;
}
/*
在vc++6.0中的输出结果：
------------------------
主串为：a a a b a a a a b
子串为：a a a a b
子串的next的数组为：0 1 2 3 4
主串和子串在第5个字符处首次匹配
子串的nextval数组为：0 0 0 0 4
主串和子串在第5个字符处首次匹配
求串s1的从第5个字符起长度为5的子串s2:
串s2为:a a a a b
Press any key to continue
------------------------------
*/

❾ 数据结构的算法如何变成C语言程序

1、算法有啦一个大致的雏形后，想清楚算法的流程，然后先将主程序打好，细节先用过程与版函数代替权。
2、然后再完善细节部分。
3、最后构造一些数据测试。
建议构造3种数据。
第一种随机生成的大数据，以检验程序在平均情况下的时间效率。
第二种是人工构造的奇葩/猥琐数据，且最好能确定答案，以检验其正确性，比如贪心的一些可能的反例。
最后一种是人工构造的特殊数据，比如，在有关树的题目中，将输入中的树退化成一条链。

❿ 数据结构c语言版算法2.3完整程序

同学，你这样提问很难找到答案啊。
《数据结构c语言版》有很多版本的，没有办法知道你说的是哪一个版本。
或者，你就麻烦下把算法描述打一遍发上来，不然我们没有办法帮到你