通信软件基础实验分享

文章目录
前言
一、移动通信中的算法问题
- 1.算法背景
- 2.核心代码
二、通信网中的算法问题
- 1.算法背景
- 2.核心思路
- 3.python版本
三.k-means算法实验
- 1.算法背景
- 2.代码实现
总结
前言
坐标南山，通信工程，对自己所学内容进行记录和分享，希望可以帮助到有需要的的同学。
一、移动通信中的算法问题 1.算法背景
信号强度核心算法：

相关检测技术：
相关检测技术是信号检测领域里一种重要工具，常用于从噪声背景中检测出有用的确定性信号。它利用确定性信号在不同时刻的取值一般都具有较强相关性，而干扰噪声因为随机性较强，不同时刻取值相关性较差的特性，把确定性信号和干扰噪声区分开来。
假设确定信号序列为x[m],具有噪声背景的实际信号序列为y[n],m 
滑动相关核心算法：
  
2.核心代码 
#include 
#include 
#include 
#include 
#define datafile_N 48
#define pssfile_N 3
#define data_N 30000
#define pss_N 4096
double sum_power(double *arr);
double bubble_sort(double *a, int n);
double slide_re(double *a, double *b);
main()
{
    int i=0, j=0, k=0, x, y;
    double max;
    char order[3]="",path1[50]="C:\Users\17513\Desktop\data\data";
    char path2[50]="C:\Users\17513\Desktop\data\PSS";
    char datar[data_N][50];
    double datat[data_N];
    double power[datafile_N];
    double power_sort[datafile_N];
	double re_all[3][48];
	double re_max[pssfile_N][1];
    char pssr[pssfile_N][50];
    double psst[pssfile_N][pss_N];
    //char pssi[pssfile_N][pss_N/2];
   	
    FILE *fp[48];
    for(i=0;i9)
        {
             order[1]=i%10 + '0';
             order[0]=i/10 + '0';
        }
        else
            order[0]=i+'0';
        strcat(strcat(path1, order), ".txt");
        if((fp[i]= fopen(path1, "r"))==NULL)
            printf("nCannot open the file!");
        else
            //printf("file %s open successfully!n",path1);
            for(j=0;jmax)
			{
				max=re_all[i][j];
				y=j;
			}
		}
		printf("PSS%d and data%d is the most relevant!n", x, y);	   
	}
    
	for(k=0;k<48;k++)
	{
		if(power[k]==power_sort[47])
		printf("nMAX POWER IS data%d.txt", k);
	}
    
   
}
double sum_power(double *arr)//计算能量 
{
	int i=0;
	double a=0.0;
	for(i=0;ia[i+1])  	//从大到小排就把左边的">"改为"<" 
            {
                temp=a[i];      //a[i]与a[i+1](即a[i]后面那个) 交换
                a[i]=a[i+1];    //基本的交换原理"c=a;a=b;b=c" 
                a[i+1]=temp;
            }
        }
    }  
	return 0;
}
double slide_re(double *a, double *b)
{
	int i, j ,k, location;
	double c[(data_N-pss_N)/2+1];
	double s, r, v, max;
	for(i=0;i<(data_N-pss_N);i+=2)
	{
		s = 0;
		r = 0;
		v = 0;
		for(j=0;jmax)
		{
			max=c[i];
			location=i;
		}	   
	}
	//printf("%dn",location);
	return max;
}
 
二、通信网中的算法问题 
1.算法背景 
由于实验要求使用Dijkstra算法计算图的最短路径问题，所以简单介绍一下相关内容
 
 求解问题：
 
 算出此拓扑图中的各个点到其它点的最短路径 
** 
2.核心思路 
**
 由于lz没想到什么更好的办法，所以将此拓扑图手动变成矩阵写在一个txt文件中，再通过文件操作读入程序中，然后再进行其他操作。 

 代码： 
#include 
#include 
#define MAX 100
#define INF 10000
int dist[MAX], prev[MAX];
// 邻接矩阵
typedef struct _graph
{
    int vexs[MAX];       	  // 顶点集合
    int vexnum;           // 顶点数
    int edgnum;           // 边数
    int *matrix;     	  // 一维数组指针偏移表示邻接矩阵
}Graph, *PGraph;

void printf_path(int u,int x);
void dijkstra(Graph G, int vs, int prev[], int dist[], int n); 
int *read_Matrix(int *a, int n);
int read_Vex(int i, int n);
main()
{
	int i, j, n, vs;
	int *a;
	int *b;
	Graph G;
	printf("Please Input The Matrix's Scale:n");
	scanf("%d", &n);
	for(i=0;i0 && G.matrix[i*n+j]<10000) //读取边数 
				G.edgnum++;
			printf("%-5d ", G.matrix[i*n+j]);  
		}
		printf("n");
	 	
	}
	printf("nn");
	do
	{
		system("pause");
		system("cls");
		printf("Please Input The Source Code:n");
		scanf("%d", &vs);
		if(vs<=0 || vs>n)
			break;
		dijkstra(G, vs-1, prev, dist, n);
	}while(1);

	
}
int read_Vex(int i, int n) //输入顶点编号 
{
	if(i0; i--)
            printf("%d-",a[i]+1);
        printf("%d",a[0]+1);
    }
    printf("n");
}

 
运行结果：
 
 保证程序的可移植性，手动输入邻接矩阵的大小。
 
 读入数据。 

 输入源点后得到相应的最短路径。 
3.python版本 
利用python方便许多，可直接将数据写入excel中，再进行读入，代码也很短 
代码： 
from pandas import read_excel 
import os
path_metrix=read_excel(os.getcwd()+"\metrix.xlsx")##读取文件用
tu_dict={}##邻接矩阵表示的图
rt_dict={}##一个节点的路由字典
point_queue=[]
#导入邻接矩阵
for i in range(0,len(path_metrix)):
    tu_dict["v"+str(i+1)]={}
    for j in range(0,len(path_metrix)):
        tu_dict["v"+str(i+1)]["v"+str(j+1)]=path_metrix[i][j]

result_file=open("结果.txt","w+")
for h in range(0,len(path_metrix)):
    #建立路由字典(v1,v2,v3...vh)
    for i in range(0,len(path_metrix)):
        rt_dict["v"+str(i+1)]={}
        if i==h:
            rt_dict["v"+str(i+1)]["dis"]=0
            rt_dict["v"+str(i+1)]["n_point"]="v"+str(h+1)
        else:
            rt_dict["v"+str(i+1)]["dis"]=1000
            rt_dict["v"+str(i+1)]["n_point"]="none"
    point_queue.append("v"+str(h+1))

    ##迪杰斯特拉算法开始
    while point_queue!=[]:
        for v in tu_dict[point_queue[0]]:
            if rt_dict[point_queue[0]]["dis"]+tu_dict[point_queue[0]][v] 
结果： 
 
三.k-means算法实验 
1.算法背景 
聚类算法简单介绍：
 
 
 k-means算法
 k-means算法，也被称为k-均值或k-平均。
 该算法首先随机地选择k个对象作为初始的k个簇的质心；然后对剩余的每个对象，根据其与各个质心的距离，将它赋给最近的簇，然后重新计算每个簇的质心；这个过程不断重复，直到准则函数收敛。
 通常采用的准则函数为平方误差和准则函数，即 SSE(sum of the squared error)，其定义如下: 

 SSE是数据库中所有对象的平方误差总和，p为数据对象，mi是簇Ci的平均值。这个准则函数使生成的结果尽可能的紧凑和独立。 
实验所求问题：
 
 通过这三年的数据，将这几只球队分成三类 
2.代码实现 
#include 
#include 
#include 
#include 
#include
#include
#define N 15 //数据个数 
#define K 3 //聚类个数 
#define delta 0.01 //迭代终止的判断条件 
using namespace std;

typedef struct
{
	double x;
	double y;
	double z;
	int Group;
	char name[15];
}Data ;
Data D[N];
Data Dpre[N];

void read_data(Data D[N],int n); //文件读数据
void data_pre_manage(Data D[N], int n); //数据预处理 
void K_means(Data D[N], int n, int k);//核心算法 
void Code_iteration(double x[], double y[], double z[], int k);//中心点迭代 
double dist_cal(double x1, double y1, double z1, double x2, double y2, double z2);//点距离计算 

main()
{
	int i;
	read_data(D, N);
	read_data(Dpre,N);
	data_pre_manage(Dpre, N);
	for(i=0;iD[i].x)
			Dx_min=D[i].x;
		if(Dx_maxD[i].y)
			Dy_min=D[i].y;
		if(Dy_maxD[i].z)
			Dz_min=D[i].z;
		if(Dz_max 
由于初始点的选择是随机的，由于本身数据的原因和lz代码的不健全性，所以结果会不稳定，因此挑选了一个相对较好的结果：
 
 ps:
 当时做实验时对文件读入情有独钟，故基本上数据读入都是文件操作 
总结 
以上是我大二一门实验课的部分实验内容及结果，有些代码是借鉴别的大佬的，由于时间过久，不知原帖在何处，如有了解的烦请告知。
通信软件基础实验分享

Python相关栏目本月热门文章
