演算法設計與分析隨機數生成

Ⅰ 求助一道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#專業人士閱讀。