数据结构与算法实例(复数实现)

数据结构与算法实例分析——复数实现

数据结构与算法要求:
学会分析研究计算机加工处理的对象的特征，以便为应用涉及的对象选择适当的逻辑结构，存储结构以及相应的算法，并初步掌握算法的时间分析以及空间分析技术

数据结构:是相互之间存在一种或多种特定关系的数据元素的集合。在任何问题中，数据元素都不是孤立存在的，而是在他们之间存在着某种关系，这种数据元素相互之间的关系称为结构。根据数据元素之间的不同特性，通常有下列四种基本结构

①集合——结构中的数据元素之间除了"同属于一个聚合"的关系外，别无其他关系②线性结构——结构中的数据元素之间存在一个对一个的关系；③树形结构——结构中的数据元素之间存在一个对多个的关系；④图状结构或网状结构——结构中的数据元素之间存在多个对多个的关系

算法和算法分析：

算法是对特定问题求解步骤的一种描述，它是指令的有限序列，其中每一条指令表示一个或多个操作；此外，一个算法还具有下列5个重要特性：

★ 有穷性：一个算法必须总是(对任何合法的输入值)在执行有穷步之后结束，且每一步都可在有穷时间内完成

★ 确定性：算法中每一条指令必须有确切的含义并且在任何条件下，算法只有唯一的一条执行路径，即对于相同的输入只能得出相同的输出。

★ 可行性：一个算法是能行的，即算法中描述的操作都是可以通过已经实现的基本运算执行有限次来实现的。

★ 输入：一个算法有零个或多个的输入，这些输入取自于某个特定的对象的集合

★ 输出：一个算法有一个或多个的输出，这些输出是同输入有着某些特定关系的量

复数四则运算

一.复数基本操作

1.复数的四则运算操作：（z1=a（实部）+b（虚部）i,z2=c+di）
z1+z2=(a+c)+(c+d)i;
z1-z2=(a-c)+(c-d)i;
z1*z2=(ac-bd)+(ad+bc)i;
z1/z2=(ac+bd)/(c2+d2)+(bc-ad)/(c2+d2)i;

2.复数的基本操作
<建造空间：struct complex_t *complex_init();
释放已经开辟内存空间：void complex_free(struct complex_t *z);
访问指定内存空间(实部)：double complex_get_real(struct complex_t *z);
访问指定内存空间(虚部)：double complex_get_imag(struct complex_t *z);
修改指定内存参数（实部）：void complex_set_real(struct complex_t *z,double real);
修改指定内存参数（虚部）：void complex_set_imag(struct complex_t *z,double imag);
复数相加操作：void complex_additive(struct complex_t *z1,struct complex_t *z2,struct complex_t *z3);
复数相减操作：void complex_subtract(struct complex_t *z1,struct complex_t *z2,struct complex_t *z3);
复数相乘操作：void complex_multiply(struct complex_t *z1,struct complex_t *z2,struct complex_t *z3);
复数相除操作：void complex_devide(struct complex_t *z1,struct complex_t *z2,struct complex_t *z3);

二.复数的存储结构

1.结构A:

2.结构B:

3.结构C:

4.结构D:

complex_t.h

#ifndef __COMPLEX_T_H__
#define __COMPLEX_T_H__
struct complex_t;
//初始化内存空间，返回指向该内存空间的指针变量
struct complex_t *complex_init();
//释放内存
void complex_free(struct complex_t *z);
//得到复数的实部元素
double complex_get_real(struct complex_t *z);
//得到复数的虚部元素
double complex_get_imag(struct complex_t *z);
//设置复数的实部元素
void complex_set_real(struct complex_t *z,double real);
//设置复数的虚部元素
void complex_set_imag(struct complex_t *z,double imag);
//将z1、z2指向的已定义的存储结构中的复数实部取出相加放入z3指向的存储空间的实部位置
void complex_addition(struct complex_t *z3,struct complex_t *z1,struct complex_t *z2);
//将z1、z2指向的已定义的存储结构中的复数实部取出相减放入z3指向的存储空间的实部位置
void complex_subtract(struct complex_t *z3,struct complex_t *z1,struct complex_t *z2);
//将z1、z2指向的已定义的存储结构中的复数实部取出相乘放入z3指向的存储空间的实部位置
void complex_multiply(struct complex_t *z3,struct complex_t *z1,struct complex_t *z2);
////将z1、z2指向的已定义的存储结构中的复数实部取出相除放入z3指向的存储空间的实部位置
void complex_devide(struct complex_t *z3,struct complex_t *z1,struct complex_t *z2);
#endif

main.c

//进行复数的四则运算
#include <stdio.h>
#include <stdlib.h>
#include "complex_t.h"
int main(int argc, char *argv[]) {
    //定义三个结构体指针变量，用来分别指向三个相同的将要定义的存储空间
    struct complex_t *z1=NULL;
    struct complex_t *z2=NULL;
    struct complex_t *z3=NULL;

    z1=complex_init();
    //将3.32存储到指针变量z1指向的内存空间的实部位置
    complex_set_real(z1,3.32);
    //将-5.12存储到指针变量z1指向的内存空间的虚部位置
    complex_set_imag(z1,-5.12);
    //将z1指向的存储结构中的复数实部和虚部取出
    printf("z1=%.2f+%.2fi
",complex_get_real(z1),complex_get_imag(z1));

    z2=complex_init();
    complex_set_real(z2,9.21);
    complex_set_imag(z2,0.54);
    printf("z2=%.2f+%.2fi
",complex_get_real(z2),complex_get_imag(z2));

    z3=complex_init();
    //将指针变量z1,z2和指向存放结果结构的z3传入complex_addition函数相加（z1指向的存储结构中复数实部和z2指向的存储结构中复数实部相加存入z3指向的存储结构的实部中……）
    complex_addition(z3,z1,z2);
    printf("z1+z2=%.2f+%.2fi
",complex_get_real(z3),complex_get_imag(z3));

    complex_subtract(z3,z1,z2);
    printf("z1_z2=%.2f+%.2fi
",complex_get_real(z3),complex_get_imag(z3));

    complex_multiply(z3,z1,z2);
    printf("z1*z2=%.2f+%.2fi
",complex_get_real(z3),complex_get_imag(z3));

    complex_devide(z3,z1,z2);
    printf("z1/z2=%.2f+%.2fi
",complex_get_real(z3),complex_get_imag(z3));

    complex_free(z1);
    complex_free(z2);
    complex_free(z3);

    return 0;
}

complex_t.c
结构A

#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include "complex_t.h"
//定义结构体存放复数的实部和虚部
struct complex_t{
    double real;
    double imag;
};
//开辟内存空间用来存放复数的实部和虚部，返回指向该内存空间的指针变量
struct complex_t *complex_init()
{
    struct complex_t *z=NULL;
    //开辟结构体类型complex_t大小的空间，将malloc()返回的指向已开辟空间的指针强制类型装换赋给z
    z=(struct complex_t *)malloc(sizeof(struct complex_t));//分配内存空间
    if(z==NULL)  return NULL;

    assert(z!=NULL);
    z->imag=0.0f;//初始化
    z->real=0.0f;

    return z;
}

void complex_free(struct complex_t *z)
{
    assert(z!=NULL);

    free(z);
}
//根据结构体指针变量z，取出复数的实部部分
double complex_get_real(struct complex_t *z)
{
    assert(z!=NULL);

    return z->real;
}
//根据结构体指针变量z，取出复数的虚部部分
double complex_get_imag(struct complex_t *z)
{
    assert(z!=NULL);

    return z->imag;
}
//根据结构体指针变量z，存储复数的实部部分
void complex_set_real(struct complex_t *z,double real)
{
    assert(z!=NULL);

    z->real=real;
}
//根据结构体指针变量z，存储复数的实部部分
void complex_set_imag(struct complex_t *z,double imag)
{
    assert(z!=NULL);

    z->imag=imag;
}
//将z1和z2指向的内存空间中的复数实部和虚部分别取出相加，结果分别存储到z3指向的内存空间存储复数实部和虚部的位置
void complex_addition(struct complex_t *z3,struct complex_t *z1,struct complex_t *z2)
{
    assert(z1!=NULL);
    assert(z2!=NULL);
    assert(z3!=NULL);

    double a,b,c,d;
    a=z1->real;
    b=z1->imag;
    c=z2->real;
    d=z2->imag;

    z3->real=a+c;
    z3->imag=b+d;
}
//将z1和z2指向的内存空间中的复数实部和虚部分别取出相减，结果分别存储到z3指向的内存空间存储复数实部和虚部的位置
void complex_subtract(struct complex_t *z3,struct complex_t *z1,struct complex_t *z2)
{
    assert(z1!=NULL);
    assert(z2!=NULL);
    assert(z3!=NULL);

    double a,b,c,d;
    a=z1->real;
    b=z1->imag;
    c=z2->real;
    d=z2->imag;

    z3->real=a-c;
    z3->imag=b-d;
}
////将z1和z2指向的内存空间中的复数实部和虚部分别取出相乘，结果分别存储到z3指向的内存空间存储复数实部和虚部的位置
void complex_multiply(struct complex_t *z3,struct complex_t *z1,struct complex_t *z2)
{
    assert(z1!=NULL);
    assert(z2!=NULL);
    assert(z3!=NULL);

    double a,b,c,d;
    a=z1->real;
    b=z1->imag;
    c=z2->real;
    d=z2->imag;

    z3->real=a*c+b*d;
    z3->imag=b*c-a*d;
}
//将z1和z2指向的内存空间中的复数实部和虚部分别取出相除，结果分别存储到z3指向的内存空间存储复数实部和虚部的位置
void complex_devide(struct complex_t *z3,struct complex_t *z1,struct complex_t *z2)
{
    assert(z1!=NULL);
    assert(z2!=NULL);
    assert(z3!=NULL);

    double a,b,c,d;
    a=z1->real;
    b=z1->imag;
    c=z2->real;
    d=z2->imag;

    z3->real=(a*c-b*d)/(c*c+d*d);
    z3->imag=(b*c+a*d)/(c*c+d*d);
}

结构B

//数组名为数组的首地址
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include "complex_t.h"
//定义结构体用来存放数组的首地址（数组中存放复数的实部和虚部）
struct complex_t{
    double *data;
};
//初始化存储结构，返回指向该存储结构的指针变量
struct complex_t *complex_init()
{
    struct complex_t *z=NULL;
    z=(struct complex_t *)malloc(sizeof(struct complex_t));
    if(z==NULL)  return NULL;

    assert(z!=NULL);

    z->data=NULL;
    z->data=(int *)malloc(sizeof(int)*2);
    if(z->data==NULL){
        free(z);
        return NULL;
    }
    assert(z!=NULL);

    z->data[1]=0.0f;
    z->data[2]=0.0f;

    return z;
}

void complex_free(struct complex_t *z)
{
    assert(z!=NULL);
    assert(z->data!=NULL);

    free(z->data);
    free(z);
}

double complex_get_real(struct complex_t *z)
{
    //数组名为数组的首地址
    assert(z!=NULL);
    assert(z->data!=NULL);

    return z->data[1];
}

double complex_get_imag(struct complex_t *z)
{
    assert(z!=NULL);
    assert(z->data!=NULL);

    return z->data[2];
}

void complex_set_real(struct complex_t *z,double real)
{
    assert(z!=NULL);
    assert(z->data!=NULL);

    z->data[1]=real;
}

void complex_set_imag(struct complex_t *z,double imag)
{
    assert(z!=NULL);
    assert(z->data!=NULL);

    z->data[2]=imag;
}
//将z1和z2指向的内存空间中的复数实部和虚部分别取出相加，结果分别存储到z3指向的内存空间存储复数实部和虚部的位置
void complex_addition(struct complex_t *z3,struct complex_t *z1,struct complex_t *z2)
{
    assert(z1!=NULL);
    assert(z2!=NULL);
    assert(z3!=NULL);

    double a,b,c,d;
    a=z1->data[1];
    b=z1->data[2];
    c=z2->data[1];
    d=z2->data[2];

    z3->data[1]=a+c;
    z3->data[2]=b+d;
}
//将z1和z2指向的内存空间中的复数实部和虚部分别取出相减，结果分别存储到z3指向的内存空间存储复数实部和虚部的位置
void complex_subtract(struct complex_t *z3,struct complex_t *z1,struct complex_t *z2)
{
    assert(z1!=NULL);
    assert(z2!=NULL);
    assert(z3!=NULL);

    double a,b,c,d;
    a=z1->data[1];
    b=z1->data[2];
    c=z2->data[1];
    d=z2->data[2];

    z3->data[1]=a-c;
    z3->data[2]=b-d;
}
//将z1和z2指向的内存空间中的复数实部和虚部分别取出相乘，结果分别存储到z3指向的内存空间存储复数实部和虚部的位置
void complex_multiply(struct complex_t *z3,struct complex_t *z1,struct complex_t *z2)
{
    assert(z1!=NULL);
    assert(z2!=NULL);
    assert(z3!=NULL);

    double a,b,c,d;
    a=z1->data[1];
    b=z1->data[2];
    c=z2->data[1];
    d=z2->data[2];

    z3->data[1]=a*c+b*d;
    z3->data[2]=b*c-a*d;
}
//将z1和z2指向的内存空间中的复数实部和虚部分别取出相除，结果分别存储到z3指向的内存空间存储复数实部和虚部的位置
void complex_devide(struct complex_t *z3,struct complex_t *z1,struct complex_t *z2)
{
    assert(z1!=NULL);
    assert(z2!=NULL);
    assert(z3!=NULL);

    double a,b,c,d;
    a=z1->data[1];
    b=z1->data[2];
    c=z2->data[1];
    d=z2->data[2];

    z3->data[1]=(a*c-b*d)/(c*c+d*d);
    z3->data[2]=(b*c+a*d)/(c*c+d*d);
}

结构C:

//除在指针定义处外，*（变量名）均表示指针变量指向的值
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include "complex_t.h"
//定义结构体作为一级结构，指针变量real存放复数实部地址和指针变量imag存放虚部的地址
struct complex_t{
    double *real;
    double *imag;
};

struct complex_t *complex_init()
{
    struct complex_t *z=NULL;
    z=(struct complex_t *)malloc(sizeof(struct complex_t));
    if(z==NULL)  return NULL;

    assert(z!=NULL);

    z->real=NULL;
    z->real=(double *)malloc(sizeof(double));
    if(z->real==NULL) {
        free(z);
        return NULL; 
    }

    assert(z->real!=NULL);

    z->imag=NULL;
    z->imag=(double *)malloc(sizeof(double));
    if(z->imag==NULL){
        free(z);
        return NULL;
    }
    //将初值赋给z->real的值
    *(z->real)=0.0f;
    *(z->imag)=0.0f;

    return z;
}

void complex_free(struct complex_t *z)
{
    assert(z->real!=NULL);
    assert(z->imag!=NULL);
    assert(z!=NULL);

    free(z);
    free(z->real);
    free(z->imag);
}

double complex_get_real(struct complex_t *z)
{
    assert(z->real!=NULL);
    assert(z->imag!=NULL);
    assert(z!=NULL);
    //返回z->real的值
    return *(z->real);
}

double complex_get_imag(struct complex_t *z)
{
    assert(z->real!=NULL);
    assert(z->imag!=NULL);
    assert(z!=NULL);
    //返回z->imag的值
    return *(z->imag);
}

void complex_set_real(struct complex_t *z,double real)
{
    assert(z->real!=NULL);
    assert(z->imag!=NULL);
    assert(z!=NULL);

    *(z->real)=real;
}

void complex_set_imag(struct complex_t *z,double imag)
{
    assert(z->real!=NULL);
    assert(z->imag!=NULL);
    assert(z!=NULL);

    *(z->imag)=imag;
}
//将z1和z2指向的内存空间中的复数实部和虚部分别取出相加，结果分别存储到z3指向的内存空间存储复数实部和虚部的位置
void complex_addition(struct complex_t *z3,struct complex_t *z1,struct complex_t *z2)
{
    assert(z1!=NULL);
    assert(z2!=NULL);
    assert(z3!=NULL);

    double a,b,c,d;
    a=*(z1->real);
    b=*(z1->imag);
    c=*(z2->real);
    d=*(z2->imag);

    *(z3->real)=a+c;
    *(z3->imag)=b+d;
}
//将z1和z2指向的内存空间中的复数实部和虚部分别取出相减，结果分别存储到z3指向的内存空间存储复数实部和虚部的位置
void complex_subtract(struct complex_t *z3,struct complex_t *z1,struct complex_t *z2)
{
    assert(z1!=NULL);
    assert(z2!=NULL);
    assert(z3!=NULL);
    double a,b,c,d;
    a=*(z1->real);
    b=*(z1->imag);
    c=*(z2->real);
    d=*(z2->imag);

    *(z3->real)=a-c;
    *(z3->imag)=b-d;
}
//将z1和z2指向的内存空间中的复数实部和虚部分别取出相乘，结果分别存储到z3指向的内存空间存储复数实部和虚部的位置
void complex_multiply(struct complex_t *z3,struct complex_t *z1,struct complex_t *z2)
{
    assert(z1!=NULL);
    assert(z2!=NULL);
    assert(z3!=NULL);

    double a,b,c,d;
    a=*(z1->real);
    b=*(z1->imag);
    c=*(z2->real);
    d=*(z2->imag);
    *(z3->real)=a*c+b*d;
    *(z3->imag)=b*c-a*d;
}
//将z1和z2指向的内存空间中的复数实部和虚部分别取出相除，结果分别存储到z3指向的内存空间存储复数实部和虚部的位置
void complex_devide(struct complex_t *z3,struct complex_t *z1,struct complex_t *z2)
{
    assert(z1!=NULL);
    assert(z2!=NULL);
    assert(z3!=NULL);

    double a,b,c,d;
    a=*(z1->real);
    b=*(z1->imag);
    c=*(z2->real);
    d=*(z2->imag);

    *(z3->real)=(a*c-b*d)/(c*c+d*d);
    *(z3->imag)=(b*c+a*d)/(c*c+d*d);
}

结构D:

#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include "complex_t.h"
//定义结构体类型complex_node作为数据节点类型，data存放要存储的数值，指针变量next指向下一个complex_node类型的数据节点
struct complex_node{
    double data;
    struct complex_node *next;
};
//定义complex_t结构体类型,其中指针变量head指向coplex_node类型的结构体
struct complex_t{
    struct complex_node *head;
};

struct complex_t *complex_init()
{
    struct complex_t *z=NULL;
    z=(struct complex_t *)malloc(sizeof(struct complex_t));
    if(z==NULL)  return NULL;

    assert(z!=NULL);

    z->head=NULL;
    z->head=(struct complex_node *)malloc(sizeof(struct complex_node));
    if(z->head==NULL){
        free(z);
        return NULL;
    }

    assert(z->head!=NULL);

    z->head->data=0.0f;
    z->head->next=NULL;
    z->head->next=(struct complex_node *)malloc(sizeof(struct complex_node));
    if(z->head->next==NULL){
    free(z->head);
    free(z);
    return NULL;
}

    assert(z->head->next!=NULL);

    z->head->next->data=0.0f;
    z->head->next->next=NULL;

    return z;
}
 
void complex_free(struct complex_t *z)
{
    assert(z->head->next!=NULL);
    assert(z->head!=NULL);
    assert(z!=NULL);

    free(z->head->next);
    free(z->head);
    free(z);
}

double complex_get_real(struct complex_t *z)
{
    assert(z->head->next!=NULL);
    assert(z->head!=NULL);
    assert(z!=NULL);
    return z->head->data;
}

double complex_get_imag(struct complex_t *z)
{
    assert(z->head->next!=NULL);
    assert(z->head!=NULL);
    assert(z!=NULL);

    return z->head->next->data;
}

void complex_set_real(struct complex_t *z,double real)
{
    assert(z->head->next!=NULL);
    assert(z->head!=NULL);
    assert(z!=NULL);

    z->head->data=real;
}

void complex_set_imag(struct complex_t *z,double imag)
{
    assert(z->head->next!=NULL);
    assert(z->head!=NULL);
    assert(z!=NULL);

    z->head->next->data=imag;	
}
//将z1和z2指向的内存空间中的复数实部和虚部分别取出相减，结果分别存储到z3指向的内存空间存储复数实部和虚部的位置
void complex_addition(struct complex_t *z3,struct complex_t *z1,struct complex_t *z2)
{
    assert(z1!=NULL);
    assert(z2!=NULL);
    assert(z3!=NULL);

    double a,b,c,d;
    a=z1->head->data;
    b=z1->head->next->data;
    c=z2->head->data;
    d=z2->head->next->data;

    z3->head->data=a+c;
    z3->head->next->data=b+d;
}

void complex_subtract(struct complex_t *z3,struct complex_t *z1,struct complex_t *z2)
{
    assert(z1!=NULL);
    assert(z2!=NULL);
    assert(z3!=NULL);

    double a,b,c,d;
    a=z1->head->data;
    b=z1->head->next->data;
    c=z2->head->data;
    d=z2->head->next->data;
 
    z3->head->data=a-c;
    z3->head->next->data=b-d;
}

void complex_multiply(struct complex_t *z3,struct complex_t *z1,struct complex_t *z2)
{
    assert(z1!=NULL);
    assert(z2!=NULL);
    assert(z3!=NULL);

    double a,b,c,d;
    a=z1->head->data;
    b=z1->head->next->data;
    c=z2->head->data;
    d=z2->head->next->data;

    z3->head->data=a*c+b*d;
    z3->head->next->data=b*c-a*d;
}

void complex_devide(struct complex_t *z3,struct complex_t *z1,struct complex_t *z2)
{
    assert(z1!=NULL);
    assert(z2!=NULL);
    assert(z3!=NULL);	

    double a,b,c,d;
    a=z1->head->data;
    b=z1->head->next->data;
    c=z2->head->data;
    d=z2->head->next->data;

    z3->head->data=(a*c-b*d)/(c*c+d*d);
    z3->head->next->data=(b*c+a*d)/(c*c+d*d);
}

### 三．编译结果
![](https://img2018.cnblogs.com/blog/1597476/202001/1597476-20200127204032549-1193747276.png)