算法设计与分析随机数生成

Ⅰ 求助一道C语言的题目. (速度).....

/*一副扑克有52张牌，打升级时应将牌分给四个人。请设计一个程序完成自动发牌的工作。

要求：黑桃用S(Spaces)表示；红桃用H(Hearts)表示；方块用D(Diamonds)表示；梅花用C(Clubs)表示。

问题分析与算法设计
按照打升级的规定，每人应当有13张牌。在人工发牌时，先进行洗牌，然后将洗好的牌按一定的顺序发给每一个人。
为了便于计算机模拟，可将人工方式的发牌过程加以修改：先确定好发牌顺序：1、2、3、4；将52张牌顺序编号
：黑桃2对应数字0，红桃2对应数字1，方块2对应数字2，梅花2对应数字3，黑桃3对应数字4，红桃3对应数字5，…
然后从52 张牌中随机的为每个人抽牌（也可以采取其它的编号方式）。
这里可以采用C语言库函数的随机函数，生成0到51之间的共52个随机数，以产生洗牌后发牌的效果。

运行示例：
S K J 8
H A J 5 3
D Q 8
C K J 7 5

S A T 6 4 2
H 4 2
D 7 6 4
C Q T 9

S 9 7 5 3
H K Q T 9
D J 3 2
C 8 2

S Q
H 8 7 6
D A K T 9 5
C A 6 4 3
思考题（必须完成）：完成2副牌的自动发牌，每人应当有26张牌，而且需将每家所得的牌进行排序。
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#include <conio.h>

#define CARD_NUM_OF_A_PACK 52
#define NUM_OF_PLAYERS 4
#define NUM_ONEPACK_OF_PLAYER (CARD_NUM_OF_A_PACK/4)

#define SIZE (sizeof(Card_t)*CARD_NUM_OF_A_PACK)

typedef struct tagCard
{
char value;
char color;
}Card_t;

void CardInit(Card_t **pInCard)
{
Card_t *pCard = *pInCard;
Card_t *pTempCard = NULL;
int i;
int j;

memset(pCard,0,SIZE);
pTempCard = pCard;

for(j = 1;j <= 4;j++)
{
for (i = 1;i <= CARD_NUM_OF_A_PACK/4;i++)
{
if (1 == j)
{
pTempCard->color = 'S';
}
else if (2 == j)
{
pTempCard->color = 'H';
}
else if (3 == j)
{
pTempCard->color = 'D';
}
else if (4 == j)
{
pTempCard->color = 'C';
}

if (i <= 10)
{
pTempCard->value = i;
}
else if(i == 11)
{
pTempCard->value = 'J';
}
else if(i == 12)
{
pTempCard->value = 'Q';
}
else if(i == 13)
{
pTempCard->value = 'K';
}
pTempCard++;
}
}

return;

}

void CardFree(Card_t **pCard)
{
if (*pCard)
{
free(*pCard);
*pCard = NULL;
}
}

void Deal(Card_t **pInCard)
{
Card_t players[NUM_OF_PLAYERS][CARD_NUM_OF_A_PACK/NUM_OF_PLAYERS];
int i;
int j;
int k;
int temp;
long cardUsedNum = 0;
int packOfCard = 0;
int playerNo = 0;
int playerCardNo = 0;
Card_t tempCard = {0};
int CartCount = 0;
Card_t *pCard = *pInCard;
int run = 1;
int cCount[NUM_OF_PLAYERS];
int hCount[NUM_OF_PLAYERS];
int dCount[NUM_OF_PLAYERS];
int sCount[NUM_OF_PLAYERS];

char c[NUM_OF_PLAYERS][CARD_NUM_OF_A_PACK/NUM_OF_PLAYERS];
char h[NUM_OF_PLAYERS][CARD_NUM_OF_A_PACK/NUM_OF_PLAYERS];
char d[NUM_OF_PLAYERS][CARD_NUM_OF_A_PACK/NUM_OF_PLAYERS];
char s[NUM_OF_PLAYERS][CARD_NUM_OF_A_PACK/NUM_OF_PLAYERS];

CartCount = CARD_NUM_OF_A_PACK;
memset(players,0,sizeof(players));
memset(c,0,sizeof(c));
memset(h,0,sizeof(h));
memset(d,0,sizeof(d));
memset(s,0,sizeof(s));

if (NULL == pCard)
{
return;
}

srand((int)time(0));

while(run)
{
temp = (int)(CartCount*rand()/(RAND_MAX+1.0));

players[playerNo][playerCardNo].color = pCard[temp].color;
players[playerNo][playerCardNo].value = pCard[temp].value;

pCard[temp].color = pCard[CartCount-1].color;
pCard[temp].value = pCard[CartCount-1].value;

pCard[CartCount-1].color = players[playerNo][playerCardNo].color;
pCard[CartCount-1].value = players[playerNo][playerCardNo].value;

CartCount-=1;
if (CartCount < 0)
{
packOfCard++;
if(packOfCard >= 1)
{
run = 0;
}
CartCount = CARD_NUM_OF_A_PACK;
}

playerCardNo+=1;
if (playerCardNo >= NUM_ONEPACK_OF_PLAYER)
{
playerNo+=1;
playerCardNo = 0;
}
}

for(i = 0;i < NUM_OF_PLAYERS;i++)
{
sCount[i] = 0;
hCount[i] = 0;
dCount[i] = 0;
cCount[i] = 0;
for (j = 0;j < NUM_ONEPACK_OF_PLAYER;j++)
{
if ('S' == players[i][j].color)
{
s[i][sCount[i]] = players[i][j].value;
sCount[i]++;
}
else if ('H' == players[i][j].color)
{
h[i][hCount[i]] = players[i][j].value;
hCount[i]++;
}
else if ('D' == players[i][j].color)
{
d[i][dCount[i]] = players[i][j].value;
dCount[i]++;
}
else if ('C' == players[i][j].color)
{
c[i][cCount[i]] = players[i][j].value;
cCount[i]++;
}
}
}

for (i = 0;i < NUM_OF_PLAYERS;i++)
{
for (j = 0;j < cCount[i] ;j++)
{
for(k = 1;k < cCount[i]-j;k++)
{
if(c[i][j] > c[i][k])
{
temp = c[i][j];
c[i][j] = c[i][k];
c[i][k] = temp;
}
}
}
}

for (i = 0;i < NUM_OF_PLAYERS;i++)
{
for (j = 0;j < hCount[i] ;j++)
{
for(k = 1;k < hCount[i] -j;k++)
{
if(h[i][j] > h[i][k])
{
temp = h[i][j];
h[i][j] = h[i][k];
h[i][k] = temp;
}
}
}
}

for (i = 0;i < NUM_OF_PLAYERS;i++)
{
for (j = 0;j < dCount[i] ;j++)
{
for(k = 1;k < dCount[i] -j;k++)
{
if(d[i][j] > d[i][k])
{
temp = d[i][j];
d[i][j] = d[i][k];
d[i][k] = temp;
}
}
}
}

for (i = 0;i < NUM_OF_PLAYERS;i++)
{
for (j = 0;j < sCount[i] ;j++)
{
for(k = 1;k < sCount[i] - j;k++)
{
if(h[i][j] > h[i][k])
{
temp = s[i][j];
s[i][j] = s[i][k];
s[i][k] = temp;
}
}
}
}

for (i = 0;i < NUM_OF_PLAYERS;i++)
{
printf("Player:%d\n",i+1);
printf("S:");
for (j = 0;j < sCount[i];j++)
{
if (s[i][j] <= 10)
printf("%d ",s[i][j]);
else
printf("%c ",s[i][j]);
}
printf("\nH:");
for (j = 0;j < hCount[i];j++)
{
if (h[i][j] <= 10)
printf("%d ",h[i][j]);
else
printf("%c ",h[i][j]);
}
printf("\nD:");
for (j = 0;j < dCount[i];j++)
{
if (d[i][j] <= 10)
printf("%d ",d[i][j]);
else
printf("%c ",d[i][j]);
}
printf("\nC:");
for (j = 0;j < cCount[i];j++)
{
if (c[i][j] <= 10)
printf("%d ",c[i][j]);
else
printf("%c ",c[i][j]);
}

printf("\n");
}
}

int main()
{
Card_t *pCard = NULL;

pCard = (Card_t *)malloc(SIZE);
if (NULL == pCard)
{
printf("error");
return;
}

CardInit(&pCard);

Deal(&pCard);

free(pCard);

}

Ⅱ 利用rand的函数产生10个随机数，从小到大排序 matlab程序 急求大神！！

1、首先打开电脑上的“matlab”软件。

注意事项：

MATLAB可以进行矩阵运算、绘制函数和数据、实现算法、创建用户界面、连接其他编程语言的程序等，主要应用于工程计算、控制设计、信号处理与通讯、图像处理、信号检测、金融建模设计与分析等领域。

Ⅲ 请问：怎样用matlab随机生成一个只有0,1元素的矩阵用什么命令，谢谢啊！

编写rand_BinaryMatrix函数，代码如下：

function [ BinaryMatrix ] = rand_BinaryMatrix( i, j )

% 随机生成i行j列的0和1元素填充的矩阵

BinaryMatrix = rand(i,j);

for count_i = 1:i

for count_j = 1:j

if BinaryMatrix(count_i, count_j) < 0.5

BinaryMatrix(count_i, count_j) = 0;

else

BinaryMatrix(count_i, count_j) = 1;

end

end

end

end

在命令行窗口中，（假设要输入4行7列的0、1填充的矩阵）令i=4，j=7，输入代码：

rand_BinaryMatrix(4,7)

回车即可。

(3)算法设计与分析随机数生成扩展阅读：

在Matlab中，rand用于生成0～1之间均匀分布的伪随机数，randn用于生成均值为0、方差为1的标准正态分布的伪随机数，两者语法一样。

Y = randn(n)，返回一个n*n的随机项的矩阵。如果n不是个数量，将返回错误信息。

Y = randn(m,n) 或 Y = randn([m n])，返回一个m*n的随机项矩阵。

Y = randn(m,n,p,...) 或 Y = randn([m n p...])，产生随机数组

Ⅳ 随机算法的基本概念

随机算法是算法本身包含了随机数生成器的算法。根据《算法导论（中文第二版）》描述，在进行算法分析的时，有时可以在获得了一定输入分布信息之后对输入的分布进行一定的假定，在此基础上进行平均情况分析得到算法的时间复杂度。然而有时候无法获得输入分布的信息，这时可以在算法本身增加一定的随机性，继而实现对算法进行平均情况分析。通过设计随机算法有效地避免较多的较坏情况输入的出现，从而提高算法的平均情况下的性能。

Ⅳ 一道c语言

看出来了,你很有前途~

Ⅵ 利用随机函数产生N个随机整数（20000以上），对这些数进行多种方法进行排序。 用C语言编程

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <time.h>

#define N 20000
struct Student
{
int score;
struct Student *next;
};

//创建单向键表,返回链表表头head
struct Student *CreatLink(struct Student *head ,int n)
{
int i;
struct Student *p1,*p2;
head=p1=(struct Student *)malloc(sizeof(struct Student));
if(p1 == NULL)
{
printf("Not enough memory to allocate buffer\n");
system("PAUSE");
exit(1); /* terminate program if out of memory */
}
p1->score = rand()%101;//产生随机值
p1->next=NULL;
for(i=2;i<=n;i++)
{
p2=p1;
p1=(struct Student *)malloc(sizeof(struct Student));
if(p1 == NULL)
{
printf("Not enough memory to allocate buffer\n");
system("PAUSE");
exit(1); /* terminate program if out of memory */
}
p1->score = rand()%101;
p1->next=NULL;//最近产生的节点下一节点指向空
p2->next=p1;
}
return head;
}

//显示循环链表的成员
void DisplayLink(struct Student *head)
{
struct Student *p;
p=head;
do
{
printf("%3d ", p->score);
p=p->next;
}while(p!=NULL); //p再次与head相等时，即所有成员都遍历完成
printf("\n\n");
}

//选择排序法排序链表
struct Student *SortLink(struct Student *head)
{
struct Student *head2=NULL,*p1,*p2,*p1lst,*p2lst,*q;
float MaxScore;

while(head!=NULL)
{
p2=p1=head;
MaxScore=head->score;
while(p1!=NULL)
{
if(p1->score > MaxScore)
{
MaxScore=p1->score;
p2lst=p1lst;
p2=p1;
}
p1lst=p1;
p1=p1->next;
}
if(p2==head)
{
head=head->next;
}
else
{
p2lst->next=p2->next;
}
if(head2==NULL)
{
head2=q=p2;
}
else
{
q->next=p2;
q=q->next;
}
}
q->next=NULL;
return head2;
}

int main(int argc, char *argv[])
{
struct Student *head;
srand((unsigned)time( NULL ));
head=CreatLink(head,N);
printf("The sorces random Generated :\n");
DisplayLink(head);
head=SortLink(head);
printf("After Sort The sorces are follows:\n");
DisplayLink(head);
free(head);
system("PAUSE");
return 0;
}

链表也是一种数据结构，看看这个程序满足你的要求不

Ⅶ 不用rand()，如何产生乱数

乱数是不重复的随机数吗？

很多算法的每一个计算步骤都是固定的，而在下面我们要讨论的概率算法，允许算法在执行的过程中随机选择下一个计算步骤。许多情况下，当算法在执行过程中面临一个选择时，随机性选择常比最优选择省时。因此概率算法可在很大程度上降低算法的复杂度。
概率算法的一个基本特征是对所求解问题的同一实例用同一概率算法求解两次可能得到完全不同的效果。这两次求解问题所需的时间甚至所得到的结果可能会有相当大的差别。一般情况下，可将概率算法大致分为四类:数值概率算法，蒙特卡罗（Monte Carlo）算法，拉斯维加斯（Las Vegas）算法和舍伍德（Sherwood）算法。
数值概率算法常用于数值问题的求解。这类算法所得到的往往是近似解。而且近似解的精度随计算时间的增加不断提高。在许多情况下，要计算出问题的精确解是不可能或没有必要的，因此用数值概率算法可得到相当满意的解。
蒙特卡罗算法用于求问题的准确解。对于许多问题来说，近似解毫无意义。例如，一个判定问题其解为“是”或“否”，二者必居其一，不存在任何近似解答。又如，我们要求一个整数的因子时所给出的解答必须是准确的，一个整数的近似因子没有任何意义。用蒙特卡罗算法能求得问题的一个解，但这个解未必是正确的。求得正确解的概率依赖于算法所用的时间。算法所用的时间越多，得到正确解的概率就越高。蒙特卡罗算法的主要缺点就在于此。一般情况下，无法有效判断得到的解是否肯定正确。
拉斯维加斯算法不会得到不正确的解，一旦用拉斯维加斯算法找到一个解，那么这个解肯定是正确的。但是有时候用拉斯维加斯算法可能找不到解。与蒙特卡罗算法类似。拉斯维加斯算法得到正确解的概率随着它用的计算时间的增加而提高。对于所求解问题的任一实例，用同一拉斯维加斯算法反复对该实例求解足够多次，可使求解失效的概率任意小。
舍伍德算法总能求得问题的一个解，且所求得的解总是正确的。当一个确定性算法在最坏情况下的计算复杂性与其在平均情况下的计算复杂性有较大差别时，可以在这个确定算法中引入随机性将它改造成一个舍伍德算法，消除或减少问题的好坏实例间的这种差别。舍伍德算法精髓不是避免算法的最坏情况行为，而是设法消除这种最坏行为与特定实例之间的关联性。
本文简要的介绍一下数值概率算法和舍伍德算法。
首先来谈谈随机数。随机数在概率算法设计中扮演着十分重要的角色。在现实计算机上无法产生真正的随机数，因此在概率算法中使用的随机数都是一定程度上随机的，即伪随机数。
产生随机数最常用的方法是线性同余法。由线性同余法产生的随机序列a1,a2,...,an满足
a0=d
an=(ban-1+c)mod m n=1,2.......
其中,b>=0, c>=0, d>=m。d称为该随机序列的种子。
下面我们建立一个随机数类RadomNumber，该类包含一个由用户初始化的种子randSeed。给定种子之后，既可产生与之相应的随机数序列。randseed是一个无符号长整型数，既可由用户指定也可由系统时间自动产生。
const unsigned long maxshort=65536L;
const unsigned long multiplier=1194211693L;
const unsigned long adder=12345L;
class RandomNumber
{
private:
//当前种子
unsigned long randseed;
public:
//构造函数，缺省值0表示由系统自动产生种子
RandomNumber(unsigned long s=0);
//产生0-n-1之间的随机整数
unsigned short Random(unsigned long n);
//产生[0，1)之间的随机实数
double fRandom(void);
};
RandomNumber::RandomNumber(unsigned long s)
{
if(s==0)
randseed=time(0);
else
randseed=s;
}
unsigned short RandomNumber::Random(unsigned long n)
{
randseed=multiplier*randseed+adder;
return (unsigned short)((randseed>>16)%n);
}
double RandomNumber::fRandom(void)
{
return Random(maxshort)/double(maxshort);
}
函数Random在每次计算时，用线性同余式计算新的种子。它的高16位的随机性较好，将randseed右移16位得到一个0-65535之间的随机整数然后再将此随机整数映射到0-n-1范围内。
对于函数fRandom,先用Random(maxshort)产生一个0-(maxshort-1之间的整型随机序列)，将每个整型随机数除以maxshort，就得到[0，1）区间中的随机实数。
下面来看看数值概率算法的两个例子：
1.用随机投点法计算π
设有一半径为r的圆及其外切四边形，如图所示。向该正方形随机投掷n个点。设落入圆内的点在正方形上均匀分布，因而所投入点落入圆内的概率为 πr^2/4r^2，所以当n足够大时，k与n之比就逼近这一概率，即π/4。由此可得使用随机投点法计算π值的数值概率算法。具体实现时，只需要在第一次象限计算即可。

double Darts(int n)
{
static RandomNumber dart;
int k=0;
for(int i=1;i<=n;i++){
double x=dart.fRandom();
double y=dart.fRandom();
if((x*x+y*y)<1)
k++;
}
return 4*k/double(n);
}
再简单举个舍伍德算法的例子。
我们在分析一个算法在平均情况下的计算复杂性时，通常假定算法的输入数据服从某一特定的概率分布。例如，在输入数据是均匀分布时，快速排序算法所需的平均时间是O(n logn)。但是如果其输入已经基本上排好序时，所用时间就大大增加了。此时，可采用舍伍德算法消除算法所需计算时间与输入实例间的这种联系。
在这里，我们用舍伍德型选择算法随机的选择一个数组元素作为划分标准。这样既能保证算法的线性时间平均性能又避免了计算拟中位数的麻烦。非递归的舍伍德型算法可描述如下：
template<class Type>
Type select(Type a[], int l, int r, int k)
{
static RandomNumber rnd;
while(true){
if(l>=r)
return a[l];
int i=l, j=l=rnd.Random(r-l+1);
Swap(a[i], a[j]);
j=r+1;
Type pivot=a[l];
while(true)
{
while(a[++i]<pivot);
while(a[--j]>pivot);
if(i>=j)
break;
Swap(a[i], a[j]);
}
if(j-l+1==k)
return pivot;
a[l]=a[j];
a[j]=pivot;
if(j-l+1<k)
{
k=k-j+l-1;
l=j+1;
}
else
r=j-1;
}
}
template <class Type>
Type Select(Type a[], int n, int k)
{
if(k<1||k>n)
throw OutOfBounds();
return select(a, 0, n-1, k);
}
平时我们一般开始考虑的是一个有着很好平均性能的选择算法，但在最坏情况下对某些实例算法效率较低。这时候我们用概率算法，将上述算法改造成一个舍伍德型算法，使得该算法对任何实例均有效。
不过在有些情况下，所给的确定性算法无法直接改造成舍伍德型算法。这时候就可以借助随机预处理技术，不改变原有的确定性算法，仅对其输入进行随机洗牌，同样可以得到舍伍德算法的效果。还是刚才的例子，换一种方法实现：
template<class Type>
void Shuffle(Type a[], int n)
{
static RandomNumber rnd;
for(int i=1;i<n;i++){
int j=rnd.Random(n-i)+i;
Swap(a[i], a[j]);
}
}

Ⅷ 数据结构与算法分析的作品目录

第1章引论
1.1本书讨论的内容
1.2数学知识复习
1.2.1指数
1.2.2对数
1.2.3级数
1.2.4模运算
1.2.5证明方法
1.3递归的简单介绍
1.4C++类
1.4.1基本class语法
1.4.2特别的构造函数语法与访问函数
1.4.3接口与实现的分离
1.4.4vector和string
1.5C++细节
1.5.1指针
1.5.2参数传递
1.5.3返回值传递
1.5.4引用变量
1.5.5三大函数：析构函数、复制构造函数和operator=
1.5.6C风格的数组和字符串
1.6模板
1.6.1函数模板
1.6.2类模板
1.6.3Object、Comparable和例子
1.6.4函数对象
1.6.5类模板的分离编译
1.7使用矩阵
1.7.1数据成员、构造函数和基本访问函数
1.7.2operator[]
1.7.3析构函数、复制赋值和复制构造函数
小结
练习
参考文献
第2章算法分析
2.1数学基础
2.2模型
2.3要分析的问题
2.4运行时间计算
2.4.1一个简单的例子
2.4.2一般法则
2.4.3最大子序列和问题的解
2.4.4运行时间中的对数
2.4.5检验你的分析
2.4.6分析结果的准确性
小结
练习
参考文献
第3章表、栈和队列
3.1抽象数据类型(ADT)
3.2表ADT
3.2.1表的简单数组实现
3.2.2简单链表
3.3STL中的向量和表
3.3.1迭代器
3.3.2示例：对表使用erase
3.3.3const_iterator
3.4向量的实现
3.5表的实现
3.6栈ADT
3.6.1栈模型
3.6.2栈的实现
3.6.3应用
3.7队列ADT
3.7.1队列模型
3.7.2队列的数组实现
3.7.3队列的应用
小结
练习
第4章树
4.1预备知识
4.1.1树的实现
4.1.2树的遍历及应用
4.2二叉树
4.2.1实现
4.2.2一个例子——表达式树
4.3查找树ADT——二叉查找树
4.3.1contains
4.3.2findMin和findMax
4.3.3insert
4.3.4remove
4.3.5析构函数和复制赋值操作符
4.3.6平均情况分析
4.4AVL树
4.4.1单旋转
4.4.2双旋转
4.5伸展树
4.5.1一个简单的想法(不能直接使用)
4.5.2伸展
4.6树的遍历
4.7B树
4.8标准库中的set和map
4.8.1set
4.8.2map
4.8.3set和map的实现
4.8.4使用几个map的例子
小结
练习
参考文献
第5章散列
5.1基本思想
5.2散列函数
5.3分离链接法
5.4不使用链表的散列表
5.4.1线性探测
5.4.2平方探测
5.4.3双散列
5.5再散列
5.6标准库中的散列表
5.7可扩散列
小结
练习
参考文献
第6章优先队列(堆)
6.1模型
6.2一些简单的实现
6.3二叉堆
6.3.1结构性质
6.3.2堆序性质
6.3.3基本的堆操作
6.3.4堆的其他操作
6.4优先队列的应用
6.4.1选择问题
6.4.2事件模拟
6.5d堆
6.6左式堆
6.6.1左式堆性质
6.6.2左式堆操作
6.7斜堆
6.8二项队列
6.8.1二项队列结构
6.8.2二项队列操作
6.8.3二项队列的实现
6.9标准库中的优先队列
小结
练习
参考文献
第7章排序
7.1预备知识
7.2插入排序
7.2.1算法
7.2.2插入排序的STL实现
7.2.3插入排序的分析
7.3一些简单排序算法的下界
7.4谢尔排序
7.5堆排序
7.6归并排序
7.7快速排序
7.7.1选取枢纽元
7.7.2分割策略
7.7.3小数组
7.7.4实际的快速排序例程
7.7.5快速排序的分析
7.7.6选择问题的线性期望时间算法
7.8间接排序
7.8.1vector<Comparable*>不运行
7.8.2智能指针类
7.8.3重载operator<
7.8.4使用“*”解引用指针
7.8.5重载类型转换操作符
7.8.6随处可见的隐式类型转换
7.8.7双向隐式类型转换会导致歧义
7.8.8指针减法是合法的
7.9排序算法的一般下界
7.10桶排序
7.11外部排序
7.11.1为什么需要新算法
7.11.2外部排序模型
7.11.3简单算法
7.11.4多路合并
7.11.5多相合并
7.11.6替换选择
小结
练习
参考文献
第8章不相交集类
8.1等价关系
8.2动态等价性问题
8.3基本数据结构
8.4灵巧求并算法
8.5路径压缩
8.6按秩求并和路径压缩的最坏情形
8.7一个应用
小结
练习
参考文献
第9章图论算法
9.1若干定义
9.2拓扑排序
9.3最短路径算法
9.3.1无权最短路径
9.3.2Dijkstra算法
9.3.3具有负边值的图
9.3.4无环图
9.3.5所有顶点对的最短路径
9.3.6最短路径举例
9.4网络流问题
9.5最小生成树
9.5.1Prim算法
9.5.2Kruskal算法
9.6深度优先搜索的应用
9.6.1无向图
9.6.2双连通性
9.6.3欧拉回路
9.6.4有向图
9.6.5查找强分支
9.7NP完全性介绍
9.7.1难与易
9.7.2NP类
9.7.3NP完全问题
小结
练习
参考文献
第10章算法设计技巧
10.1贪心算法
10.1.1一个简单的调度问题
10.1.2赫夫曼编码
10.1.3近似装箱问题
10.2分治算法
10.2.1分治算法的运行时间
10.2.2最近点问题
10.2.3选择问题
10.2.4一些算术问题的理论改进
10.3动态规划
10.3.1用表代替递归
10.3.2矩阵乘法的顺序安排
10.3.3最优二叉查找树
10.3.4所有点对最短路径
10.4随机化算法
10.4.1随机数生成器
10.4.2跳跃表
10.4.3素性测试
10.5回溯算法
10.5.1公路收费点重建问题
10.5.2博弈
小结
练习
参考文献
第11章摊还分析
11.1一个无关的智力问题
11.2二项队列
11.3斜堆
11.4斐波那契堆
11.4.1切除左式堆中的结点
11.4.2二项队列的懒惰合并
11.4.3斐波那契堆操作
11.4.4时间界的证明
11.5伸展树
小结
练习
参考文献
第12章高级数据结构及其实现
12.1自顶向下伸展树
12.2红黑树
12.2.1自底向上插入
12.2.2自顶向下红黑树
12.2.3自顶向下删除
12.3确定性跳跃表
12.4AA树
12.5treap树
12.6k-d树
12.7配对堆
小结
练习
参考文献
附录类模板的分离编译
索引

Ⅸ 推介一本对培养写算法能力有帮助的书，要切合基础的

新华书店文轩网搜索的，供参考：

C 语言算法速查手册
作者：程晓旭 等编着
出版：人民邮电出版社 出版日期：2009年10月
本书用C语言编写了科研和工程中最常用的166个算法，这些算法包括复数运算、多项式的计算、矩阵运算、线性代数方程组的求解、非线性方程与方程组的求解、代数插值法、数值积分法、常微分方程（组）初值问题的求解、拟合与逼近、特殊函数、极值问题、随机数产生与统计描述、查找、排序、数学变换与滤波等。同时结合这些算法列举了将近100个应用实例，对其进行验证和分析。 本书适用于C语言算法的初学者，也可以作为高等院校师生的学习参考用书。

妙趣横生的算法(C语言实现)(配光盘)
作者：杨峰 编着
出版：清华大学出版社 出版日期：2010年04月
本书理论与实践相结合，旨在帮助读者理解算法，并提高C语言编程能力，培养读者的编程兴趣，并巩固已有的C语言知识。全书分为2个部分共10章，内容涵盖了编程必备的基础知识（如数据结构、常用算法等），编程实例介绍，常见算法和数据结构面试题等。本书最大的特色在于实例丰富，题材新颖有趣，实用性强，理论寓于实践之中。通过本书的学习，可以使读者开阔眼界，提高编程的兴趣，提高读者的编程能力和应试能力。 本书附带1张光盘，内容为本书源代码和作者为本书录制的5.5小时多媒体教学视频。本书可作为算法入门人员的

算法设计与分析:C++语言描述
作者：
出版：电子工业出版社2 出版日期：2006年06月
本书内容分为3部分：算法和算法分析，算法设计策略及求解困难问题。第1部分介绍问题求解方法、算法复杂度和分析、递归算法和递推关系；第2部分讨论常用的算法设计策略：基本搜索和遍历方法、分治法、贪心法、动态规划法、回溯法和分枝限界法；第3部分介绍NP完全问题、随机算法、近似算法和密码算法。书中还介绍了两种新的数据结构：跳表和伸展树，以及它们特定的算法分析方法，并对现代密码学做了简要论述。本书结构清晰、内容翔实、逻辑严谨、深入浅出。书中算法有完整的C++程序，程序构思精巧，且有详细注释，所有程序都已

算法：C语言（第1~4 部分）
作者：（美）塞奇威克 着
出版：机械工业出版社 出版日期：2009年10月
本书细腻讲解计算机算法的C语言实现。全书分为四部分，共16章。包括基本算法分析原理，基本数据结构、抽象数据结构、递归和树等数据结构知识，选择排序、插入排序、冒泡排序、希尔排序、快速排序方法、归并和归并排序方法、优先队列与堆排序方法、基数排序方法以及特殊用途的排序方法，并比较了各种排序方法的性能特征，在进一步讲解符号表、树等抽象数据类型的基础上，重点讨论散列方法、基数搜索以及外部搜索方法。书中提供了用C语言描述的完整算法源程序，并且配有丰富的插图和练习，还包含大量简洁的实现将理论和实践成功地相结合

数据结构与算法C#语言描述
作者：（美）麦克米伦（McMillan,M） 着；吕秀锋，崔睿 译
出版：人民邮电 出版日期：2009年05月
本书是在.NET框架下用C#语言实现数据结构和算法的第一本全面的参考书。本书介绍的方法非常实用，采用了时间测试而非大O表示法来分析算法性能。内容涵盖了数据结构和算法的基本原理，涉及数组、广义表、链表、散列表、树、图、排序搜索算法以及更多概率算法和动态规则等高级算法。此外，书中还提供了.NET框架类库中的C#语言实现的数据结构和算法。 本书适合作为C#数据结构课程的教材，同时也适合C#专业人士阅读。