算法分析与设计实验源代码(算法设计与分析实验四)

今天给各位分享算法分析与设计实验源代码的知识，其中也会对算法设计与分析实验四进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

• 1、急求tsp问题算法的源代码（c++）
• 2、地图着色问题源程序C++语言（算法设计与分析）急求
• 3、有关于DES算法的C语言源代码嘛？急需，能直接运行的
• 4、这个是java NumberFormat 类中的源代码，各位大虾可不可以帮我解释一两个算法呢。急急急急
• 5、C语言课程设计：shell排序、堆排序、快速排序、归并(递归和非递归)排序5种算法效率分析！求能运行的源码！

急求tsp问题算法的源代码（c++）

将k=0,lb,x[1:n]=0存入PT

while(PT不为空)

{ 从PT中取出lb值最小元素

k=k+1;

for(i=1; i=n; i++)

{ x[k]=i;

if(c[i][x[k-1]+∞)

{ die=0;计算 lb ;

for(j=1; jk; j++)

if (x[j]=x[k]) {die=1; break; }

if(die=0 and lbup) 将k,lb,x[1:n]存入PT

}

}

if(k=n) { lb=c[x[1]][x[2]]+…+c[x[n-1]][x[n]]+c[x[1]][x[n]]

if (lb 是PT中最小值) 输出丛搭解埋物,结束

else{ up=lb;删除 PT中lb=up元素 }

}

}

哈哈，楼上对了渗液拿

地图着色问题源程序C++语言（算法设计与分析）急求

从一个省开始，给它涂上任意一种颜色1，遍历它旁边的省份，涂上与银培已经涂色并于他相邻的省份不同的颜色就行了。

理论上4种颜色就够了.地图的四色问题嘛!

可能会有多组解。用递归（dfs)就可以输出所有解了。键搏扮

地图着色算法C语言源代码

前面我写了一个地图着色（即四色原理）的C源代码。

写完以后想了一下，感觉还不完善，因为从实际操作的角稿灶度来考虑，四种可用的颜色放在旁边，不同的人可能会有不同的选择顺序，另外，不同的人可能会选择不同的城市作为着色的起点，而当时的程序没有考虑这个问题。于是，把程序修改为下面的样子，还请同行分析并指出代码中的不足之处：

＃i nclude stdio.h

#define N 21

int allcolor[4];/*可用的颜色*/

int ok(int metro[N][N],int r_color[N],int current)

{/*ok函数和下面的go函数和原来的一样,保留用来比较两种算法*/

int j;

for(j=1;jcurrent;j++)

if(metro[current][j]==1r_color[j]==r_color[current])

return 0;

return 1;

}

void go(int metro[N][N],int r_color[N],int sum,int current)

{

int i;

if(current=sum)

for(i=1;i=4;i++)

{

r_color[current]=i;

if(ok(metro,r_color,current))

{

go(metro,r_color,sum,current+1);

return;

}

}

}

void color(int metro[N][N],int r_color[N],int sum,int start)

{

int i,j,k;

r_color

今天给各位分享算法分析与设计实验源代码的知识，其中也会对算法设计与分析实验四进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

for(i=start+1;i!=start;i=(i+1)%(sum+1))/*把所有编号看作一个环*/

if(i==0)/*城市号从1开始编号,故跳过0编号*/

continue;

else

for(j=0;j4;j++)

{

r_color[i]=allcolor[j];/*选取下一种颜色,根据allcolor中颜色顺序不同，结果不同*/

for(k=1;ki;k++)/*检查是否有冲突，感觉还可以改进，如使用禁忌搜索法*/

if(metro[i][k]==1r_color[k]==r_color[i])

break;

if(k=i)

break;

}

}

void main()

{

int r_color[N]={0};

int t_color[N]={0};

int i;

int start;/*着色的起点*/

int metro[N][N]={{0},

{0,1,1,1,1,1,1},

{0,1,1,1,1},

{0,1,1,1,0,0,1},

{0,1,1,0,1,1},

{0,1,0,0,1,1,1,0,0,1,0,0,0,0,0,0,1},

{0,1,0,1,0,1,1,1,1,1},

{0,0,0,0,0,0,1,1,1},

{0,0,0,0,0,0,1,1,1,1,0,0,1},

{0,0,0,0,0,1,1,0,1,1,0,0,1,1,1,0,1},

{0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,1,0,0,0,1},

{0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,1},

{0,0,0,0,0,0,0,0,1,1,0,1,1,1,0,0,0,0,0,1,1},

{0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1},

{0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,1,1},

{0,0,0,0,0,0,0,0,0,0,1,0,0,1,1,1,1,1,0,1},

{0,0,0,0,1,0,0,0,1,0,0,0,0,1,1,1,1},

{0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1},

{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1},

{0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,1,0,0,1,1,1},

{0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1}};

allcolor[0]=1;allcolor[1]=2;allcolor[2]=3;allcolor[3]=4;/*选色顺序，顺序不同，结果不同*/

start=1;

/* clrscr();*/

printf("\nAll color is:\n");

for(i=0;i4;i++)/*当前选色顺序*/

printf("%d ",allcolor[i]);

go(metro,r_color,20,1);

printf("\nFirst method:\n");

for(i=1;i=20;i++)

printf("%3d",r_color[i]);

color(metro,t_color,20,start);

printf("\nSecond method:\n");

printf("\nAnd the start metro is:%d\n",start);

for(i=1;i=20;i++)

printf("%3d",t_color[i]);

}

说是人性化着色，其实还有一个问题没有考虑，那就是操作员跳跃式着色，就像大家玩“扫雷”游戏一样。其实也容易实现，可以像定义选色顺序一样定义着色顺序。

有关于DES算法的C语言源代码嘛？急需，能直接运行的

//////////////////////////////////////////////////////////////////////////

/*

Provided by 王俊川, Northeastern University ()

Email: blackdrn@sohu.com

This product is free for use.

*/

//////////////////////////////////////////知枯差////////////////////////////////

#include "memory.h"

enum {ENCRYPT,DECRYPT};

///////////////////////////搭皮////////////////败歼///////////////////////////////

// initial permutation IP

const static char IP_Table[64] = {

58, 50, 42, 34, 26, 18, 10, 2, 60, 52, 44, 36, 28, 20, 12, 4,

62, 54, 46, 38, 30, 22, 14, 6, 64, 56, 48, 40, 32, 24, 16, 8,

57, 49, 41, 33, 25, 17, 9, 1, 59, 51, 43, 35, 27, 19, 11, 3,

61, 53, 45, 37, 29, 21, 13, 5, 63, 55, 47, 39, 31, 23, 15, 7

};

// final permutation IP^-1

const static char IPR_Table[64] = {

40, 8, 48, 16, 56, 24, 64, 32, 39, 7, 47, 15, 55, 23, 63, 31,

38, 6, 46, 14, 54, 22, 62, 30, 37, 5, 45, 13, 53, 21, 61, 29,

36, 4, 44, 12, 52, 20, 60, 28, 35, 3, 43, 11, 51, 19, 59, 27,

34, 2, 42, 10, 50, 18, 58, 26, 33, 1, 41, 9, 49, 17, 57, 25

};

// expansion operation matrix

static const char E_Table[48] = {

32, 1, 2, 3, 4, 5, 4, 5, 6, 7, 8, 9,

8, 9, 10, 11, 12, 13, 12, 13, 14, 15, 16, 17,

16, 17, 18, 19, 20, 21, 20, 21, 22, 23, 24, 25,

24, 25, 26, 27, 28, 29, 28, 29, 30, 31, 32, 1

};

// 32-bit permutation function P used on the output of the S-boxes

const static char P_Table[32] = {

16, 7, 20, 21, 29, 12, 28, 17, 1, 15, 23, 26, 5, 18, 31, 10,

2, 8, 24, 14, 32, 27, 3, 9, 19, 13, 30, 6, 22, 11, 4, 25

};

// permuted choice table (key)

const static char PC1_Table[56] = {

57, 49, 41, 33, 25, 17, 9, 1, 58, 50, 42, 34, 26, 18,

10, 2, 59, 51, 43, 35, 27, 19, 11, 3, 60, 52, 44, 36,

63, 55, 47, 39, 31, 23, 15, 7, 62, 54, 46, 38, 30, 22,

14, 6, 61, 53, 45, 37, 29, 21, 13, 5, 28, 20, 12, 4

};

// permuted choice key (table)

const static char PC2_Table[48] = {

14, 17, 11, 24, 1, 5, 3, 28, 15, 6, 21, 10,

23, 19, 12, 4, 26, 8, 16, 7, 27, 20, 13, 2,

41, 52, 31, 37, 47, 55, 30, 40, 51, 45, 33, 48,

44, 49, 39, 56, 34, 53, 46, 42, 50, 36, 29, 32

};

// number left rotations of pc1

const static char LOOP_Table[16] = {

1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1

};

// The (in)famous S-boxes

const static char S_Box[8][4][16] = {

// S1

14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7,

0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8,

4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0,

15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13,

// S2

15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10,

3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5,

0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15,

13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9,

// S3

10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8,

13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1,

13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7,

1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12,

// S4

7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15,

13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9,

10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4,

3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14,

// S5

2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9,

14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6,

4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14,

11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3,

// S6

12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11,

10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8,

9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6,

4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13,

// S7

4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1,

13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6,

1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2,

6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12,

// S8

13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7,

1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2,

7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8,

2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11

};

//////////////////////////////////////////////////////////////////////////

typedef bool (*PSubKey)[16][48];

//////////////////////////////////////////////////////////////////////////

static void DES(char Out[8], char In[8], const PSubKey pSubKey, bool Type);//标准DES加/解密

static void SetKey(const char* Key, int len);// 设置密钥

static void SetSubKey(PSubKey pSubKey, const char Key[8]);// 设置子密钥

static void F_func(bool In[32], const bool Ki[48]);// f 函数

static void S_func(bool Out[32], const bool In[48]);// S 盒代替

static void Transform(bool *Out, bool *In, const char *Table, int len);// 变换

static void Xor(bool *InA, const bool *InB, int len);// 异或

static void RotateL(bool *In, int len, int loop);// 循环左移

static void ByteToBit(bool *Out, const char *In, int bits);// 字节组转换成位组

static void BitToByte(char *Out, const bool *In, int bits);// 位组转换成字节组

//////////////////////////////////////////////////////////////////////////

static bool SubKey[2][16][48];// 16圈子密钥

static bool Is3DES;// 3次DES标志

static char Tmp[256], deskey[16];

//////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////

// Code starts from Line 130

//////////////////////////////////////////////////////////////////////////

bool Des_Go(char *Out, char *In, long datalen, const char *Key, int keylen, bool Type)

{

if( !( Out In Key (datalen=(datalen+7)0xfffffff8) ) )

return false;

SetKey(Key, keylen);

if( !Is3DES ) { // 1次DES

for(long i=0,j=datalen3; ij; ++i,Out+=8,In+=8)

DES(Out, In, SubKey[0], Type);

} else{ // 3次DES 加密:加(key0)-解(key1)-加(key0) 解密::解(key0)-加(key1)-解(key0)

for(long i=0,j=datalen3; ij; ++i,Out+=8,In+=8) {

DES(Out, In, SubKey[0], Type);

DES(Out, Out, SubKey[1], !Type);

DES(Out, Out, SubKey[0], Type);

}

}

return true;

}

void SetKey(const char* Key, int len)

{

memset(deskey, 0, 16);

memcpy(deskey, Key, len16?16:len);

SetSubKey(SubKey[0], deskey[0]);

Is3DES = len8 ? (SetSubKey(SubKey[1], deskey[8]), true) : false;

}

void DES(char Out[8], char In[8], const PSubKey pSubKey, bool Type)

{

static bool M[64], tmp[32], *Li=M[0], *Ri=M[32];

ByteToBit(M, In, 64);

Transform(M, M, IP_Table, 64);

if( Type == ENCRYPT ){

for(int i=0; i16; ++i) {

memcpy(tmp, Ri, 32);

F_func(Ri, (*pSubKey)[i]);

Xor(Ri, Li, 32);

memcpy(Li, tmp, 32);

}

}else{

for(int i=15; i=0; --i) {

memcpy(tmp, Li, 32);

F_func(Li, (*pSubKey)[i]);

Xor(Li, Ri, 32);

memcpy(Ri, tmp, 32);

}

}

Transform(M, M, IPR_Table, 64);

BitToByte(Out, M, 64);

}

void SetSubKey(PSubKey pSubKey, const char Key[8])

{

static bool K[64], *KL=K[0], *KR=K[28];

ByteToBit(K, Key, 64);

Transform(K, K, PC1_Table, 56);

for(int i=0; i16; ++i) {

RotateL(KL, 28, LOOP_Table[i]);

RotateL(KR, 28, LOOP_Table[i]);

Transform((*pSubKey)[i], K, PC2_Table, 48);

}

}

void F_func(bool In[32], const bool Ki[48])

{

static bool MR[48];

Transform(MR, In, E_Table, 48);

Xor(MR, Ki, 48);

S_func(In, MR);

Transform(In, In, P_Table, 32);

}

void S_func(bool Out[32], const bool In[48])

{

for(char i=0,j,k; i8; ++i,In+=6,Out+=4) {

j = (In[0]1) + In[5];

k = (In[1]3) + (In[2]2) + (In[3]1) + In[4];

ByteToBit(Out, S_Box[i][j][k], 4);

}

}

void Transform(bool *Out, bool *In, const char *Table, int len)

{

for(int i=0; ilen; ++i)

Tmp[i] = In[ Table[i]-1 ];

memcpy(Out, Tmp, len);

}

void Xor(bool *InA, const bool *InB, int len)

{

for(int i=0; ilen; ++i)

InA[i] ^= InB[i];

}

void RotateL(bool *In, int len, int loop)

{

memcpy(Tmp, In, loop);

memcpy(In, In+loop, len-loop);

memcpy(In+len-loop, Tmp, loop);

}

void ByteToBit(bool *Out, const char *In, int bits)

{

for(int i=0; ibits; ++i)

Out[i] = (In[i3](i7)) 1;

}

void BitToByte(char *Out, const bool *In, int bits)

{

memset(Out, 0, bits3);

for(int i=0; ibits; ++i)

Out[i3] |= In[i](i7);

}

//////////////////////////////////////////////////////////////////////////

// Code ends at Line 231

//////////////////////////////////////////////////////////////////////////

这个是java NumberFormat 类中的源代码，各位大虾可不可以帮我解释一两个算法呢。急急急急

楼主贴的代码一点也没有涉及到format的核心，都是个外围调用。

还是希望楼主能静下心来好好读读这些源码，对OODP（面向蚂配对象设计与编程）的理解可加深很多啊。

祝楼主好运！

-----------

再补充下， 想起一个好方法， 楼主可以写个例子， 运行，再在举渗Eclipse里以debug方式跟踪进去，看看那些代码具体是怎么执行的。

这个过程很美，以前自闷答指己研究Hibernate框架就是那样开始的，像看一部长篇小说那样。

祝福楼主。

C语言课程设计：shell排序、堆排序、快速排序、归并(递归和非递归)排序5种算法效率分析！求能运行的源码！

#include stdio.h

#include time.h

#include stdlib.h

#include Windows.h

void shellSort(int *a,int len)

{

int step;

int i,j;

int temp;

for(step=len/2; step0;step/=2)

{

for(i=step;ilen;i++)

{

temp = a[i];

for(j=i-step;(j=0 temp a[j]);j-=step)

{

a[j+step] = a[j];

}

a[j+step] = temp;

}

}

}

void swap(int *a,int *b)

{

int temp = *a;

*a = *b;

*b = temp;

}

void heapify(int *a,int n,int k)

{

int l,r,lg = -1;

l = 2*k;

r = l+1;

if (l = n a[l-1] a[k-1])

{

lg = l;

}

else

{

lg = k;

}

if (r = n a[r-1] a[lg-1])

{

lg = r;

}

if (lg != k)

{

swap(a[lg-1],a[k-1]);

heapify(a,n,lg);

}

}

void build_heap(int a[],int n)

{

for (int i=n/2+1; i0; i--)

{

heapify(a,n,i);

}

}

void heap_sort(int a[],int n)

{

build_heap(a,n);

for (int i=n; i0; i--)

{

swap(a[0],a[i-1]);

heapify(a,i-1,1);

}

}

int partitions(int a[],long p,long q)

{

long i,j=p-1;

for (i=p; iq; i++)

{

if (a[i-1] = a[q-1])

{

j++;

swap(a[i-1],a[j-1]);

}

}

j++;

swap(a[j-1],a[q-1]);

return j;

}

void quicksort(int a[],long p,long q)

{

long i;

if (pq)

{

i = partitions(a,p,q);

quicksort(a,p,i-1);

quicksort(a,i+1,q);

}

}

void merge(int *a,int start, int mid, int end)

{

int n1 = mid - start + 1;

int n2 = end - mid;

int *left = (int *)malloc(sizeof(int)*n1), *right=(int *)malloc(sizeof(int)*n2);

int i, j, k;

for (i = 0; i n1; i++) /* left holds a[start..mid] */

left[i] = a[start+i];

for (j = 0; j n2; j++) /* right holds a[mid+1..end] */

right[j] = a[mid+1+j];

i = j = 0;

k = start;

while (i n1 j n2)

if (left[i] right[j])

a[k++] = left[i++];

else

a[k++] = right[j++];

while (i n1) /* left[] is not exhausted */

a[k++] = left[i++];

while (j n2) /* right[] is not exhausted */

a[k++] = right[j++];

free(left);

free(right);

}

void MergeSort(int *a,int start, int end)

{

int mid;

if (start end)

{

mid = (start + end) / 2;

MergeSort(a,start, mid);

MergeSort(a,mid+1, end);

merge(a,start, mid, end);

}

}

double gettime(LARGE_INTEGER t,LARGE_INTEGER t1,LARGE_INTEGER t2)

{

double time;

if (t.LowPart==0 t.HighPart==0)

time = -1;

else

{

time = (float)(t2.LowPart - t1.LowPart);

if (time 0) time += 2^32;

time /= (t.LowPart+t.HighPart * 2^32);

}

return time;

}

int main()

{

const int NUM = 1000;

srand(time(NULL));

int data[NUM];

int i;

for (i=0; iNUM; ++i)

{

data[i] = rand()/(RAND_MAX/20000+1);

}

LARGE_INTEGER t,t1,t2;

QueryPerformanceFrequency(t);

QueryPerformanceFrequency(t1);

shellSort(data,NUM);

QueryPerformanceFrequency(t2);

printf("shell time:%0.4f\n",gettime(t,t1,t2));

QueryPerformanceFrequency(t1);

heap_sort(data,NUM);

QueryPerformanceFrequency(t2);

printf("shell time:%0.4f\n",gettime(t,t1,t2));

QueryPerformanceFrequency(t1);

quicksort(data,1,NUM);

QueryPerformanceFrequency(t2);

printf("shell time:%0.4f\n",gettime(t,t1,t2));

QueryPerformanceFrequency(t1);

MergeSort(data,0,NUM);

QueryPerformanceFrequency(t2);

printf("shell time:%0.4f\n",gettime(t,t1,t2));

return 0;

}

算法分析与设计实验源代码的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于算法设计与分析实验四、算法分析与设计实验源代码的信息别忘了在本站进行查找喔。