Six Degrees Of Separation英文歌词及中文翻译

六度空间理论及其应用一、六度空间理论的背景以及基本定义：1.六度空间理论简述：六度空间理论（Six Degrees of Separation）是一个数学领域的猜想，中文翻译包括以下几种：六度分割理论、六度空间理论或小世界理论等。

六度空间理论的实质即为：你和任何一个陌生人之间所间隔的人不会超过六个，也就是说，最多通过六个人你就能够认识任何一个陌生人。

这就是六度空间理论，也叫小世界理论。

二、六度分割的提出：上世纪60年代，美国哈佛大学的社会心理学家米尔格伦提出了“六度分割”的理论。

简单来说，“六度分割”就是在这个社会里，任何两个人之间建立一种联系，最多需要六个人(不包括这两个人在内），无论这两个人是否认识，生活在地球上任何偏僻的地方，他们之间只有六度分割。

三、六度空间理论应用：1. 六度空间理论的实验基础：（1）寻找马龙·白兰度的过程：有这么一个故事，几年前一家德国报纸接受了一项挑战，要帮法兰克福的一位土耳其烤肉店老板，找到他和他最喜欢的影星马龙·白兰度的关联。

结果经过几个月，报社的员工发现，这两个人只经过不超过六个人的私交，就建立了人脉关系。

原来烤肉店老板是伊拉克移民，有个朋友住在加州，刚好这个朋友的同事，是电影《这个男人有点色》的制作人的女儿在女生联谊会的结拜姐妹的男朋友，而马龙·白兰度主演了这部片子。

（2）耶鲁大学教授设计的连锁信件实验：20世纪60年代，耶鲁大学的社会心理学家米尔格兰姆就设计了一个连锁信件实验。

他将一套连锁信件随机发送给居住在内布拉斯加州奥马哈的160个人，信中放了一个波士顿股票经纪人的名字，信中要求每个收信人将这套信寄给自己认为是比较接近那个股票经纪人的朋友。

朋友收信后照此办理。

最终，大部分信在经过五、六个步骤后都抵达了该股票经纪人。

六度空间的概念由此而来。

这个连锁实验，体现了一个似乎很普遍的客观规律：社会化的现代人类社会成员之间，都可能通过“六度空间”而联系起来，绝对没有联系的A与B是不存在的。

推荐10首活跃气氛的英文歌曲1. Katy Perry – Roar我非常喜欢水果姐的这首歌，这首歌在各种歌唱比赛都听到，这首歌的MV 真的超赞，绿色好心情，曲风也是鼓舞人的，当我情绪低落时，我也非常喜欢听这首歌来活跃自己的气氛！2.《Six Degrees of Separation》——The Script一开始听着很深沉，但是渐渐的就开始变成呐喊，听着会有点淡淡的忧伤，旋律真的很好，听了两年多了，还是很喜欢这首歌，当你情绪低落的时候，听到歌声中的歇斯底里的呐喊，心情得到释放人也就活跃起来了。

3.《Waka Waka (This Time for Africa)》——Shakira2010年南非世界杯主题曲，从2010年一直喜欢到现在，看着MV听着歌曲，你会不自觉的想动起来的，超赞的一首歌曲！4.《Summer Shade》——Cody Simpson这首歌曲，我2014年3月份买手机时店家下载给我的，一直听了两年多，一直都很喜欢，有时候下班回家的路上随机播放到这首歌我总会觉得心情很好，整个人都好似要跳跃起来的那种感觉！5.《Perfect Strangers》——Jonas Blue要是在路上听到这样欢快的歌曲，我一定会很开心的，伴奏配得有趣、活跃，调节情绪、活跃气氛这样的歌曲在适合不过了！6.《Try Everything》——Shakira我是因为听了这首歌曲，才想去看电影《ZOO TO PIA》的，电影中最喜欢的画面就是朱迪在火车上听着这首歌曲走近全新的世界，就像我当年大学毕业时满怀激情的走向曼谷，真的很感动，看着朱迪就好似看着两年前的自己，听着这首活泼的歌曲，气氛不活跃都难啊！7.《I Like How It Feels》——Enrique Iglesias & Pitbull一听就感受到很欢快的嗓音，口哨声，动感的吉他声，真的很欢快，特别适合派对上播放的一首歌曲，当然旅游车上播放也能很好的活跃气氛的！8.《Collide》——Howie Day跟着好听的吉他声渐入到活跃的氛围，听着这首歌曲真的很享受，所有的外在的世界好似都与我无关，我只是在享受这样美好的氛围，一种欢快的氛围！9.《Secrets》——One Republic很有节奏感，唱得也很紧凑，让人都没有时间去想其它的事情，沉浸在歌声中，自我调节，自我感受，一种很私密的美的感受。

1无所不达的六度人脉网赢家的武器：六度分割理论很多人听说过一个由数字领域引发的猜想，如果他是一名人脉学“粉丝”的话，对于“Six Degrees of Separation”这一短语并不会陌生。

翻译成中文，就是六度分割理论。

有时，我们也称它为六度空间理论或小世界理论等。

实际上，你如果想成为一名人脉场上的赢家，就无法忽视这条理论的重要性。

如果你想拥有最快地结识最有用人脉的办法，你的大脑一定离不开“六度思维”。

简述之，我们和处在世界任何一个角落的陌生人之间所间隔的不会超过6个。

你最多通过6个人，就能够认识他们，与之搭上关系。

这个“他们”，包括美国前总统切尼、李嘉诚、或者好莱坞著名导演斯皮尔伯格。

当我初次接触到这条人脉真理时，我还在长江实业集团做一名普通的销售，后来我成为长江实业集团在九龙地区名气最大的销售经理。

有一天，我在接头因为一次被据却而愁眉苦脸，一个亲在的大客户，很有可能购买而且也很需要我们的产品，但我却苦于上门无术，每次递上名片，都被他警惕的眼神和不屑的表情拒之门外。

我很沮丧地站在公主大道的报亭边，忘记了吃午餐，头疼地琢磨下一步的拜访计划，这时，我看到了介绍“Six Degrees of Separation”一本普通杂志。

“任何两个人建立一种联系，最多只需要六个人？多么神奇的理论！六个人就可以让全世界认识你！结合我当时的处境，我顿时就被吸引住了。

它源于美国的社会心理学家米尔格伦在上世纪六十年代的“发明”，他仿佛不停地在告诉我：李维文，你想敲开那家大客户客厅的门，安心地坐在那里和他喝茶聊天，然后向他提出购买你们产品的计划吗？其实这一点儿都不难，你最多只要找到四个人就可以了，在你们中间的的四个人。

只要你这样的渴望，你想认识某一个人，找到四个人就一定能找到。

无论你和这个人是否相识，不管生活在地球上任何一个偏僻或相距遥远的地方，在你们之间，只有六度分割。

我买了这本杂志，抛开杂念，坐在路边的一家快餐店专心地把它看完。

英语必修四第四单元课文翻译霍金Research shows the average person only has regular communication with between seven and fifteen people, and that most of our communication is in fact with five to ten people who are closest to us. However, perhaps we are closer to the rest of the world than we think. “Six Degrees of Separation” refers to the theory that any person on Earth can be connected to any other person through a chain of no more than five other people.研究表明，普通人只与7 至15 个人经常保持联系，而且其中大部分的交流实际上只发生在5 到10 个亲近的人身上。

不过，也许我们与世界上其他人的联系比想象中的更紧密。

“六度分隔”理论说的是地球上任何人都可通过不超过另外五个人与一个陌生人联系起来。

The concept was first talked about as long ago as in the 1920s. The Hungarian author Frigyes Karinthy published a book called Everything Is Different in 1929, in which he introduced the idea of friendship networks and his ideas influenced many of our early impressions of social networks.这个概念早在20世纪20年代就被提出。

SEV EN 7 SP IR ITS W IN ES: TH E AU STRA LIAN SP IR IT CAP TUR ED IN W IN E柒善葡萄酒：捕捉了澳大利亚精神的葡萄酒7 Spi ri ts Wi nes are made with a philosophy deeply embedded in the Australian lifestyle and culture, drawing on millennia of nature’s influence over the land and the soils. We work with our environment and our soils and apply the winemakers craft to making great wines.柒善葡萄酒是本着深深扎根于澳大利亚生活方式和文化的理念而酿造的，吸取着上千万年来大自然给大地和土壤带来的精粹。

我们充分利用我们的环境和土壤，加上精湛的酿酒技术来酿造最好的葡萄酒。

Many thousands of years after first human settlement in Australia, 7 Spi ri ts Wi nes is a leading proponent of Terrior and the Spi ri t of the La nd; letting natures hand guide our wine making and vineyard management to achieve wines of great depth and complexity and offering truly sensational and rewarding wine drinking experience.在最早的人类在澳大利亚扎根几千年后的今天，柒善葡萄酒是风土和土地精神的领先支持者；让自然之手指导我们的葡萄酒酿造和葡萄园管理以创造出拥有深度和复杂性的葡萄酒，带来真正美妙和让人如愿以偿的品酒经历。

“六度分割理论”马克思主义哲学认为，世界是一个普遍联系的有机整体，没有一个事物是孤立存在的。

在自然界、人类社会和人的思维中，到处都充满着体现客观事物之间普遍联系的事例。

例如在数学中有个著名的“六度分割理论”（英文翻译Six Degrees of Separation）又称为“六度空间理论”、“小世界理论”等。

早在1929年，匈牙利作家F Karinthy就做出了“小世界现象”论断，认为地球上的任何两个人都可以平均通过一条由六位联系人组成的链条而联系起来。

1967年，美国著名社会心理学家、斯坦利米尔格兰姆教授(Stanley Milgram)提出了“六度分割理论”。

它指出，世界上任何无论多么陌生两个人之间所间隔的人不会超过六个人，也即是说我们至多通过六个人就可以认识想要结识的人。

“六度分隔”现象，是米尔格兰姆教授在一次连锁信实验中发现的。

他将一套连锁信件随机发送给内布拉斯加州奥马哈的160个人，信中写有一个波士顿股票经纪人的名字。

在信中他要求每位收信人将这封信寄给自己认为是比较接近那个股票经纪人的朋友。

朋友收信后照此办理。

最终，大部分信件都寄到了这名股票经纪人手中，每封信在经过平均经手6．2次到达。

同年5月，米尔格兰姆在《今日心理学》杂志上发表了实验结果，并提出了著名的“六度分割理论”。

为验证理论的正确性，一家德国报纸曾接受了这样一项挑战：一位法兰克福的土耳其烤肉店老板，很希望结识影星马龙白兰度。

于是该报就要帮助老板找到他和马龙白兰度之间的“关系链”。

经过了几个月的努力，报社员工终于发现，其实这两个人之间只需要不超过六个人的联系，就可以建立人脉关系。

原来烤肉店老板是伊拉克移民，他有一个朋友住在加州，刚好这个朋友的同事，是电影制作人的女儿在女生联谊会的结拜姐妹的男朋友，而马龙白兰度正好主演了这部片子。

通过上述人脉关系，使得烤肉店老板在不超过六个人的间隔就建立两者之间的结识渠道。

“六度分割理论”内容及其验证事例，表明事情之间是存在普遍联系的。

SixDegreeofSeparation本博客的代码的思想和图⽚参考：好⼤学慕课浙江⼤学陈越⽼师、何钦铭⽼师的《数据结构》题⽬：六度空间”理论⼜称作“六度分隔（Six Degrees of Separation）”理论。

这个理论可以通俗地阐述为：“你和任何⼀个陌⽣⼈之间所间隔的⼈不会超过六个，也就是说，最多通过五个⼈你就能够认识任何⼀个陌⽣⼈。

”如图1所⽰。

图1 六度空间⽰意图“六度空间”理论虽然得到⼴泛的认同，并且正在得到越来越多的应⽤。

但是数⼗年来，试图验证这个理论始终是许多社会学家努⼒追求的⽬标。

然⽽由于历史的原因，这样的研究具有太⼤的局限性和困难。

随着当代⼈的联络主要依赖于电话、短信、微信以及因特⽹上即时通信等⼯具，能够体现社交⽹络关系的⼀⼿数据已经逐渐使得“六度空间”理论的验证成为可能。

假如给你⼀个社交⽹络图，请你对每个节点计算符合“六度空间”理论的结点占结点总数的百分⽐。

输⼊格式:输⼊第1⾏给出两个正整数，分别表⽰社交⽹络图的结点数NNN（1<N≤1041<N\le 10^41<N≤10输出格式:对每个结点输出与该结点距离不超过6的结点数占结点总数的百分⽐，精确到⼩数点后2位。

每个结节点输出⼀⾏，格式为“结点编号:（空格）百分⽐%”。

输⼊样例:10 91 22 33 44 55 66 77 88 99 10输出样例:1: 70.00%2: 80.00%3: 90.00%4: 100.00%5: 100.00%6: 100.00%7: 100.00%8: 90.00%9: 80.00%10: 70.00%We use two kinds of method to store the graph:adjacnet matrix and adjacnet tableThe code is followed:1/*2 * sixDigreeSeparation.c3 *4 * Created on: 2017年5⽉8⽇5 * Author: ygh6*/7 #include <stdio.h>8 #include <stdlib.h>910/*11 * Algorithm thought:12 * We easily know this question is BFS.13 * we access the first level nodes, then access second level nodes14 * until we reach the sixth level.15 * We let every node to BFS until it reach the sixth level,then we record the total nodes M16 * it can reach, calculate the M/N(The total point the test data gives) .17*/19#define MAX_VERTEX_MUM 1000120 typedef int vertex; /*vertex is the index of point in the graph*/21 typedef int dataType; /*dataType is the data type of vertex */22 typedef int weightType; /*The data type of weight */2324/*25 * Define a data structure to edge26*/27 typedef struct eNode *ptrToENode;28 typedef struct eNode {29 vertex v1, v2;30 weightType wight;31 };32 typedef ptrToENode edge;3334/*35 * Define a data structure for adjacent table node36*/37 typedef struct adjNode *ptrToAdjNode;38 typedef struct adjNode {39 vertex adjVertex; /*The index of vertex in the graph*/40 weightType weight; /*the value of the weight*/41 ptrToAdjNode next; /*A point to point next node*/42 };4344/*45 * Define a data structure for adjacent table head point46*/47 typedef struct vNode *ptrToVNode;48 typedef struct vNode {49 dataType data; /*The value of every vertex,some times it will be ignore*/50 ptrToAdjNode head;/*The point to point the adjacent table first element*/51 } adjList[MAX_VERTEX_MUM];5253/*Define a data structure for graph*/54 typedef struct gNode *ptrToGNode;55 typedef struct gNode {56int vertex_num;57int edge_num;58 adjList g;59 };60 typedef ptrToGNode adjacentTableGraph; /*a graph show by adjacent table*/ 6162/*63 create a graph given the vertex number.64 @param vertexNum The verter number of the graph65 @return a graph with vertex but no any egdgs66*/67 ptrToGNode createGraph(int vertexNum) {68 vertex v;69 adjacentTableGraph graph = (adjacentTableGraph) malloc(70sizeof(struct gNode));71 graph->vertex_num = vertexNum;72 graph->edge_num = 0;73for (v = 1; v <= graph->vertex_num; v++) {74 graph->g[v].head = NULL;75 }76return graph;77 }7879/*80 insert a edge to graph.We will distinct oriented graph and undirected graph81 The e->v1 and e->v2 are the vertexs' indexs in the adjacent table82 @param graph The graph you want to insert edge83 @param e The edge you want to insert the graph84 @param isOriented Whether the graph is oriented graph.If the graph is oriented85 we will set adjacent table graph[v1]->head=v2 and set graph[v1].head=v286 otherwise we only set graph[v1].head=v287*/88void insertEdge(adjacentTableGraph graph, edge e, int isOriented) {89 ptrToAdjNode newNode;90 newNode = (ptrToAdjNode) malloc(sizeof(struct adjNode));91 newNode->adjVertex = e->v2;92 newNode->weight = e->wight;93 newNode->next = graph->g[e->v1].head;94 graph->g[e->v1].head = newNode;95if (!isOriented) {96 newNode = (ptrToAdjNode) malloc(sizeof(struct adjNode));97 newNode->adjVertex = e->v1;98 newNode->weight = e->wight;99 newNode->next = graph->g[e->v2].head;100 graph->g[e->v2].head = newNode;101 }103104 adjacentTableGraph buildGraph() {105 adjacentTableGraph graph;106 edge e;107 vertex v;108int vertex_num;109 scanf("%d", &vertex_num);110 graph = createGraph(vertex_num);111 scanf("%d", &(graph->edge_num));112if (graph->edge_num) {113 e = (edge) malloc(sizeof(struct eNode));114for (v = 0; v < graph->edge_num; v++) {115 scanf("%d %d", &e->v1, &e->v2);116 e->wight = 1;117 insertEdge(graph, e, 0);118 }119 }120return graph;121 }122123/*==============================define a queue=====================================================*/ 124/*define a list to store the element in the queue*/125 typedef vertex elementType;126 typedef struct node *pList;127 typedef struct node {128 elementType element;129struct node *next;130 };131132/*define a queue to point the list*/133 typedef struct node2 *pQueue;134 typedef struct node2 {135 pList front; /*the front point to point the head of the list*/136 pList rear; /*the rear point to point the rear of of the list*/137 };138139/*create a empty list to store the queue element*/140 pList createEmptyList() {141 pList list;142 list = (pList) malloc(sizeof(struct node));143 list->next = NULL;144return list;145 }146/*create a empty queye*/147 pQueue createEmptyQueue() {148 pQueue queue = (pQueue) malloc(sizeof(struct node2));149 queue->front = NULL;150 queue->rear = NULL;151return queue;152 }153154/*155 Wether the queue is empty156 @param queue The queue need to adjust157 @return If the queue is null,return 1 otherwise return 0158*/159int isQueueEmpty(pQueue queue) {160return (queue->front == NULL);161 }162163/*164 Add a element to a queue,If the queue is null,we will create a new queue165 @parama queue The queue we will add elememt to166 @prama element The element we will add to queue167*/168void addQueue(pQueue queue, elementType element) {169if (isQueueEmpty(queue)) {170 pList list = createEmptyList();171 list->element = element;172 queue->front = queue->rear = list;173 } else {174 pList newNode = (pList) malloc(sizeof(struct node));175 newNode->element = element;176 newNode->next = queue->rear->next;177 queue->rear->next = newNode;178 queue->rear = newNode;179 }180 }181182/*183 delete a element from a queue184 @param queue The queue will be deleted a element185 @return The element has been deleted187 elementType deleteEleFromQueue(pQueue queue) {188if (isQueueEmpty(queue)) {189 printf("the queue is empty,don't allow to delete elemet from it!"); 190 } else {191 pList oldNode = queue->front;192 elementType element = oldNode->element;193if (queue->front == queue->rear) {194 queue->rear = queue->front = NULL;195 } else {196 queue->front = queue->front->next;197 }198free(oldNode);199return element;200 }201 }202203/*204 * Initialize a visited array that make them all to zero205*/206void initVisited(adjacentTableGraph graph, int *visited) {207int i;208for (i = 0; i <= graph->vertex_num; i++) {209 visited[i] = 0;210 }211 }212213/*214 Breadth first search215 @param graph The graph stored by the adjacent table216 @param startPoint The point we start search217 @param visited A array to tag the elemeent whether has been visited 218*/219int BFS(adjacentTableGraph graph, vertex startPoint, int *visited) { 220 ptrToAdjNode p;221int count = 0;222int level = 0;223int last = startPoint, tail;224 visited[startPoint] = 1;225 count++;226 pQueue queue = createEmptyQueue();227 addQueue(queue, startPoint);228while (!isQueueEmpty(queue)) {229 elementType element = deleteEleFromQueue(queue);230for (p = graph->g[element].head; p; p = p->next) {231if (visited[p->adjVertex] == 0) {232 visited[p->adjVertex] = 1;233 addQueue(queue, p->adjVertex);234 count++;235 tail = p->adjVertex;236 }237 }238if (last == element) {239 level++;240 last = tail;241 }242if (level == 6) {243return count;244 }245 }246return count;247 }248249/*250 *Prove the six degree of separation251*/252void SDS(adjacentTableGraph graph) {253 vertex v;254int count;255int visited[graph->vertex_num+1];256float result;257for (v = 1; v <= graph->vertex_num; v++) {258 initVisited(graph, visited);259 count = BFS(graph, v, visited);260 result = (float)((float)count / graph->vertex_num)*100;261 printf("%d: %0.2f", v, result);262 printf("%%");263 printf("\n");264 }265 }266267int main() {268 adjacentTableGraph graph = buildGraph();269 SDS(graph);Adjacnet Table1/*2 * sixDigreeSeparation.c3 *4 * Created on: 2017年5⽉9⽇5 * Author: ygh6*/7 #include <stdio.h>8 #include <stdlib.h>910/*11 * Algorithm thought:12 * We easily know this question is BFS.13 * we access the first level nodes, then access second level nodes14 * until we reach the sixth level.15 * We let every node to BFS until it reach the sixth level,then we record the total nodes M16 * it can reach, calculate the M/N(The total point the test data gives) .17*/1819#define MAX_VERTEX_NUM 10001 /*define the max number of the vertex*/20#define INFINITY 65535 /*define double byte no negitive integer max number is 65535*/2122 typedef int vertex; /*define the data type of the vertex*/23 typedef int weightType; /*define the data type of the weight*/24 typedef char dataType; /*define the data type of the vertex value*/2526/*define the data structure of the Edge*/27 typedef struct eNode *ptrToENode;28 typedef struct eNode {29 vertex v1, v2; /*two vertex between the edge <v1,v2>*/30 weightType weight; /*the value of the edge's weigth */31 };32 typedef ptrToENode edge;3334/*define the data structure of the graph*/35 typedef struct gNode *ptrToGNode;36 typedef struct gNode {37int vertex_number; /*the number of the vertex*/38int edge_nunber; /*the number of the edge*/39 weightType g[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; /*define the adjacent matrix of graph*/40 dataType data[MAX_VERTEX_NUM]; /*define the dataType array to store the value of vertex*/41 };42 typedef ptrToGNode adjacentMatrixGraph; /*a graph show by adjacent matrix*/4344/*45 create a graph given the vertex number.46 @param vertexNum The verter number of the graph47 @return a graph with vertex but no any egdgs48*/49 adjacentMatrixGraph createGraph(int vertexNum) {50 vertex v, w;51 adjacentMatrixGraph graph;52 graph = (adjacentMatrixGraph) malloc(sizeof(struct gNode));53 graph->vertex_number = vertexNum;54 graph->edge_nunber = 0;55/*initialize the adjacent matrix*/56for (v = 1; v <= graph->vertex_number; v++) {57for (w = 1; w <= graph->vertex_number; w++) {58 graph->g[v][w] = 0;59 }60 }6162return graph;63 }6465/*66 insert a edge to graph.We will distinct oriented graph and undirected graph67 @param graph The graph you want to insert edge68 @param e The edge you want to insert the graph69 @param isOriented Whether the graph is oriented graph.If the graph is oriented70 we will set adjacent matrix [n][m]=[m][n]=edge's weight,else we only set71 the adjacent matrix [n][m]=edge's weight72*/73void inserEdge(adjacentMatrixGraph graph, edge e, int isOriented) {74 graph->g[e->v1][e->v2] = e->weight;75if (!isOriented) {76 graph->g[e->v2][e->v1] = e->weight;7980/*81 construct a graph according user's input8283 @return a graph has been filled good84*/85 adjacentMatrixGraph buildGraph() {86 adjacentMatrixGraph graph;87 edge e;88int vertex_num, i;89 scanf("%d", &vertex_num);90 graph = createGraph(vertex_num);91 scanf("%d", &(graph->edge_nunber));92if (graph->edge_nunber) {93 e = (edge) malloc(sizeof(struct eNode));94for (i = 0; i < graph->edge_nunber; i++) {95 scanf("%d %d", &e->v1, &e->v2);96 e->weight = 1;97 inserEdge(graph, e, 0);98 }99 }100101return graph;102103 }104105/*=====================define a queue used BFS================================*/ 106/*107 * The elementType is element which the following list store.108*/109 typedef int elementType;110111/*112 * Define a list to store the queue elements113*/114 typedef struct node1 *pList;115 typedef struct node1 {116 elementType element;117struct node1 *next;118 };119120/*121 * Define a queue used to BFS122*/123 typedef struct node2 *pQueue;124 typedef struct node2 {125 pList font;126 pList rear;127 };128129/*130 * Create a empty list131*/132 pList createEmptyList() {133 pList list = (pList) malloc(sizeof(struct node1));134 list->next = NULL;135return list;136 }137138/*139 * Create a empty queue140*/141 pQueue createEmptyQueue() {142 pQueue queue = (pQueue) malloc(sizeof(struct node2));143 queue->font = queue->rear = NULL;144return queue;145 }146147/*148 * Whether the queue is empty149*/150int isQueueEmpty(pQueue queue) {151return (queue->font == NULL);152 }153154/*155 * Insert a element to a queue156*/157void insertQueue(pQueue queue, elementType element) {158159if (isQueueEmpty(queue)) {160 pList list = createEmptyList();162 queue->font = queue->rear = list;163 } else {164 pList newNode = (pList) malloc(sizeof(struct node1));165 newNode->element = element;166//newNode->next = queue->rear->next;167 queue->rear->next = newNode;168 queue->rear = newNode;169 }170 }171172 elementType deleteElementQueue(pQueue queue) {173if (isQueueEmpty(queue)) {174return -1;175 } else {176if (queue->font == queue->rear) {177 pList temp = queue->font;178 elementType elememt = temp->element;179free(temp);180 queue->font = queue->rear = NULL;181return elememt;182 } else {183 pList temp = queue->font;184 elementType elememt = temp->element;185free(temp);186 queue->font = queue->font->next;187return elememt;188 }189190 }191192 }193194/*195 *Breath first search a graph which store in form of adjacent matrix 196 *@param graph The graph stored with adjacent matrix197 *@param startPoint The start point we start search198 *@param visited A array to tag whether element has been accessed 199*/200int BFS(adjacentMatrixGraph graph, vertex startPoint, int *visited) { 201 vertex v, w;202/*203 * count:to record the total nodes the start point can access204 * level:to record the level the current node accessed205 * tail:to record the every node's index, every access it will be flush 206 * last:to record last lever latest accessed node,we can use it to 207 * let level add.208*/209int count = 0;210int level = 0, last = startPoint;211int tail = last;212 pQueue queue = createEmptyQueue();213 count++;214 visited[startPoint] = 1;215 insertQueue(queue, startPoint);216while (!isQueueEmpty(queue)) {217 w = deleteElementQueue(queue);218for (v = 1; v <= graph->vertex_number; v++) {219if (graph->g[w][v] != 0 && visited[v] == 0) {220 visited[v] = 1;221 insertQueue(queue, v);222 tail = v;223 count++;224 }225 }226if (w == last) {227 level++;228 last = tail;229 }230231if (level == 6) {232return count;233 }234 }235return count;236237 }238239/*240 * Initialize a visited array that make them all to zero241*/242void initVisited(adjacentMatrixGraph graph, int *visited) {243int i;244for (i = 1; i <= graph->vertex_number; i++) {246 }247 }248249/*250 *Prove the six degree of separation251 *@param graph A graph prepared252*/253void SDS(adjacentMatrixGraph graph) {254int visited[graph->vertex_number + 1];255 vertex v;256int count;257float result;258for (v = 1; v <= graph->vertex_number; v++) {259 initVisited(graph, visited);260 count = BFS(graph, v, visited);261 result = (float) ((float) count / graph->vertex_number * 100);262 printf("%d: %0.2f", v, result);263 printf("%%");264 printf("\n");265 }266 }267268int main() {269 adjacentMatrixGraph graph = buildGraph();270 SDS(graph);271return0;272 }Adjacnet MatrixFrom PTA test result,we find the adjacent matrix effective is more high than adjacent table.But the adjacent matrix take more memory.Is it use spaceto swap the timethe test result is follow。

六度分隔的另一种证明方式英文回答：The six degrees of separation theory, also known as the small-world phenomenon, is a sociological theory that states that any two people on Earth are connected by a chain of six or fewer acquaintances. This theory has been popularized by the play and film "Six Degrees of Separation," which follows the story of a young man who claims to be the son of Sidney Poitier.There are several different ways to prove the six degrees of separation theory. One method is to use the "Erdős number," which is a measure of how close someone is to the Hungarian mathematician Paul Erdős. Erdős was a prolific collaborator, and he published over 1,500 papers with more than 500 different co-authors. As a result, anyone who has ever collaborated with Erdős has an Erdős number of 1. Anyone who has collaborated with someone who has an Erdős number of 1 has an Erdős number of 2, and soon.By calculating the Erdős numbers of a large number of people, it is possible to show that the average Erdős number is around 4. This means that any two people on Earth are likely to be connected by a chain of four or fewer acquaintances.Another way to prove the six degrees of separation theory is to use the "small-world experiment." In this experiment, participants are given a list of names and asked to send a message to a target person. Theparticipants are only allowed to send the message to someone they know, and the recipient of the message is then allowed to send it to someone they know, and so on. The experiment has been conducted several times, and it has consistently shown that the average number of steps it takes to send a message from one person to another is around six.The six degrees of separation theory has implications for a variety of different fields, including sociology,psychology, and marketing. For example, the theory suggests that it is possible for people to spread information or ideas very quickly through their social networks. The theory also suggests that it is possible for people to find common ground with others, even if they come from different backgrounds.中文回答：六度分隔理论，又称小世界现象，是一种社会学理论，声称地球上的任何两个人都可以通过六个人或更少的熟人联系起来。