余弦曲线.txt
===========================
余弦直线.txt
#include<stdio.h>
#include<math.h>
main()
{
double y;
int x,m,n,yy;
for(yy=0;yy<20;yy++)
{
y=0.1*yy;
m=acos(1-y)*10;
n=45*(y-1)+31;
for(x=0;x<=62;x++)
if(x==m&&x==n)
printf("+");
else if(x==n)
printf("+");
else if(x==m||x==62-m)
printf("*");
else
printf(" ");
printf("\n");
}
}===========================
傻瓜递归.txt
#include <stdio.h>
main()
{ int m=1,n=1,s;
s=akm(m,n);
printf("%d",s);
}
akm(int m,int n)
{ if(m==0)
return n+1;
else if(m!=0&&n==0)
akm(m-1,1);
else if(m!=0&&n!=0)
akm(m-1,akm(m,n-1));
} ===========================
冒泡排序.txt
# include "stdio.h"
# include "stdlib.h"
struct node{
int values;
struct node *next;
};
struct node *create(int [],int);
void sort (struct node **);
int test_data[20000]={5,9,3,4,5,7,8};
main()
{ struct node *h,*p;
h=create(test_data,20000);
for(p=h;p;p=p->next) printf("%2d",p->values);
printf("\n");
sort(&h);
for(p=h;p;p=p->next) printf("%2d" ,p->values);
printf("\n");
}
struct node *create (int a[],int n)
{struct node *h,*q;
for(h=NULL;n;n--)
{ q=(struct node *) malloc(sizeof(struct node));
q->values=a[n-1];
q->next=h;
h=q;
}
return h;
}
void sort (struct node **h)
{ struct node *q,*p,*r,*s,*h1;
h1=p=(struct node *)malloc(sizeof(struct node));
p->next=*h;
while(p->next!=NULL)
{ q=p->next;
r=p;
while (q->next!=NULL)
{ if(q->next->values<r->next->values) r=q;
q=q->next;
}
if(r!=p)
{ s=r->next;
r->next=s->next;
s->next=p->next;
p->next=s;
}
p=p->next;
}
*h=h1->next;/*问题：h1在程序中做了啥用？ */
free(h1);
}
===========================
冒泡法改进.txt
/* 冒泡法是数据排序的一种基本算法,它的基本方法是:相邻两元素进行比较,如有需要则进行交换,
每完成一次循环就将最小元素排在最后(如从大到小排序),下一次循环是将其他的数进行类似操作?
如将N 个数按从大到小排序,Turbo C语言程序函数
如下: */
void sort(int a[],int n);
main()
{
int a[100],i ,j ,n ;
/*输入数组元素的个数及各元素的值*/
scanf(＂%d＂,&n);
for(i =0;i <n ;i ++ )scanf(＂%d＂,&a [i]);
sort(a,n);
for(i =0;i <n ;i ++ )printf(＂%d＂,a[i]);
}
sort(int a[],int n)
{
int i ,j ,t ;
for(i =n -2;i >=0; i--)
for(j =0;j <i ; j++)
if(a[j]<a[j +1])
{
t =a[j];
a[j]=a[j +1];
a[j +1]=t ;
}
}
/*N 个元素需比较N *(N -1)/2次,效率较差?其实,可根据每一次循环比较中的情
况改进之? [改进一]:若某次循环中没有数据交换过,则可认为数据已经有序了,
不必再进行循环了,可在程序中设一变量Flag 用来标识有无数据交换? */
sort(int a[],int n)
{
int i ,j ,t ,flag ;
for (i =n -2;i >0; i--)
{
flag =0;
for(j =0;j <i ; j++)
if(a[j]<a[j +1])
{
t =a[j];
a[j]=a[j +1];
a[j +1]=t ;
flag =1;
}
if (flag ==0)break;
}
}
/*[改进二]:如果在一次循环中,最后的某些元素没有交换过,则说明后面这些元
素的顺序已排序,下次循环可不对其进行比较?本方法主要考虑要排序的数组元素的范
围,而不是每一轮排序都将数组元素的范围减少1?*/
sort(int a[],int n)
{
int i ,j ,t ,k,flag ;
flag =n -1;
while (flag >0)
{
k=0;
for(j =0;j <i ;j ++)
if(a[j]<a[j +1])
{
t =a[j];
a[j]=a[j +1];
a[j +1]=t ;
k=j ;
}
flag =k; /*此处不填flag = flag -1;*/
}
}
===========================
动态计算网络最长最短路线.txt
/*
* File: longest.c
* Desciption: 动态规划算法计算网络的最长路线和最短路线
* Created: 2001/12/2
* Author: Justin Hou [mailto:justin_hou@hotmail.com]
*
*/
#include <stdio.h>
#define N 7 /* 顶点数目 */
#define I 999 /* 表示无穷大 */
int graph[N][N] = { /* 图的邻接矩阵 */
{I, 4, 5, 8, I, I, I},
{I, I, I, 6, 6, I, I},
{I, I, I, 5, I, 7, I},
{I, I, I, I, 8, 9, 9},
{I, I, I, I, I, I, 5},
{I, I, I, I, I, I, 4},
{I, I, I, I, I, I, I}
};
int List[N]; /* 存放拓扑序列 */
int TopologicalOrder(); /* 拓扑排序函数 */
void main() /* 主 函 数 */
{
int i, j, k, l;
int ee[N], el[N]; /* 最长最短距离 */
int path_e[N][N], path_l[N][N], n_e[N], n_l[N]; /* 记录路径数据 */
/* 初始化数据 */
for (i = 0; i < N; i++) {
n_e[i] = 0; /* 到 i 的最短路线的结点数 */
n_l[i] = 0; /* 到 i 的最长路线的结点数 */
ee[i] = I;
el[i] = 0;
}
ee[0] = el[0] = 0; /* 初始化头结点 */
path_e[0][0] = 0;
path_l[0][0] = 0;
n_e[0] = 1;
n_l[0] = 1;
/* 拓扑排序 */
if (!TopologicalOrder())
return;
/* 对于拓扑序列,运用动态规划步步算出最长路线与最短路线 */
for (i = 0; i < N; i++) {
/* 提取拓扑序列的元素 */
k = List[i];
/* 更新它所指向顶点的所有数据 */
for (j = 0; j < N; j++) {
/* 寻找指向的顶点 */
if (graph[k][j] != I) {
/* 如果新路径更短 */
if (graph[k][j] + ee[k] < ee[j]) {
/* 更新最短路径长度 */
ee[j] = graph[k][j] + ee[k];
/* 更新最短路线 */
for (l = 0; l < n_e[k]; l++) {
path_e[j][l] = path_e[k][l];
}
path_e[j][l] = j;
n_e[j] = l + 1;
}
/* 如果新路径更长 */
if (graph[k][j] + el[k] > el[j]) {
/* 更新最长路径长度 */
el[j] = graph[k][j] + el[k];
/* 更新最长路线 */
for (l = 0; l < n_l[k]; l++) {
path_l[j][l] = path_l[k][l];
}
path_l[j][l] = j;
n_l[j] = l + 1;
}
}
}
}
/* 输出结果到屏幕 */
for (i = 0; i < N; i++) {
printf("shortest(%d): %2d Path: ", i + 1, ee[i]);
for (j = 0; j < n_e[i]; j++) {
printf("%d ", path_e[i][j] + 1);
}
printf("\n");
printf("longest (%d): %2d Path: ", i + 1, el[i]);
for (j = 0; j < n_l[i]; j++) {
printf("%d ", path_l[i][j] + 1);
}
printf("\n");
}
}
int TopologicalOrder()
{
int i, j, top, count;
int indegree[N], Stack[N];
top = 0; /* 栈顶标志 */
for (i = 0; i < N; i++) {
indegree[i] = 0; /* 初始化入度 */
经典数据结构算法c语言实现代码（大全） （161个子文件） 
list.log 18KB
source.txt 258KB asm.txt 16KB 货郎担分枝限界图形演示.txt 14KB 图.txt 13KB 骑士遍历2.txt 13KB 哈夫曼算法.txt 9KB 货郎担限界算法.txt 9KB 万年历的算法 .txt 7KB 万年历.txt 7KB 单链表的处理全集.txt 7KB 排序法.txt 6KB 各种排序法.txt 6KB 动态计算网络最长最短路线.txt 5KB 小白鼠钻迷宫.txt 4KB 小写数字转换成大写数字2.txt 4KB ping.txt 4KB 二叉树实例.txt 4KB 带头结点双链循环线性表.txt 4KB 定长串.txt 4KB 神经元模型.txt 4KB 单链表.txt 3KB 链表（递归）.txt 3KB 单循环链表.txt 3KB 链串.txt 3KB 节点.txt 3KB 顺序表.txt 3KB 大整数.txt 3KB 汉字字模.txt 3KB C标志符命名源程序.txt 3KB 逆矩阵.txt 3KB winsock2.txt 3KB 链队列.txt 3KB 迷宫问题.txt 3KB 检出错误.txt 3KB 网络最短路径Dijkstra算法.txt 3KB N皇后问题回溯算法.txt 2KB 骑士遍历回逆.txt 2KB 顺序队列.txt 2KB 逆阵.txt 2KB 矩阵乘法动态规划.txt 2KB 哈慢树.txt 2KB 四塔1.txt 2KB 骑士遍历1.txt 2KB 大加数.txt 2KB 无向图.txt 2KB 栈操作.txt 2KB 队列.txt 2KB 简单数据库.txt 2KB 逆波兰计算器.txt 2KB 文件加密.txt 2KB 链栈.txt 2KB 符号图形.txt 2KB 小字库DIY.txt 2KB 顺序栈.txt 2KB 简单逆阵.txt 2KB 输出自已.txt 2KB 线性顺序存储结构.txt 2KB 推箱子.txt 2KB 冒泡法改进.txt 2KB 时间陷阱.txt 2KB 二叉树.txt 2KB 线索化二叉树.txt 2KB 二叉排序树.txt 2KB 十五人排序.txt 2KB 挽救软盘.txt 2KB 二分查找1.txt 2KB 建树和遍历.txt 2KB 小明买书.txt 1KB 汉诺塔.txt 1KB 小字库DIY-.txt 1KB 灯塔问题.txt 1KB Crctable.txt 1KB 非递归.txt 1KB 双链表正排序.txt 1KB 小写数字转换成大写数字3.txt 1KB 简单计算器.txt 1KB 迷宫.txt 1KB 二分查找2.txt 1KB 小写数字转换成大写数字1.txt 1KB 冒泡排序.txt 1KB 换位递归.txt 1KB 黑白.txt 1KB 数据结构2.txt 1KB 自我复制.txt 1KB 链表十五人排序.txt 1KB 数字移动.txt 1019B 穷举搜索法.txt 983B 建立链表1.txt 980B 多位阶乘.txt 971B 螺旋数组1.txt 971B 诺汉塔画图版.txt 951B 字符串查找.txt 927B 单词倒转.txt 897B ww.txt 873B 质因子.txt 870B 完数.txt 863B 单链表倒序.txt 853B 螺旋数组2.txt 851B 递归车厢.txt 846B共 161 条
- 1
- 2
- 1
- 2
- 3
- 4
- 5
- 6
前往页