chapter 2_arrays

于 2024-09-26 19:21:56 发布
阅读量204 收藏 3
点赞数 1
文章标签： 算法 数据结构 矩阵 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80948460/article/details/142369257
版权

chapter 2_arrays

文章目录

一、多项式抽象数据类型

1、多项式的ADT定义

class Polynomial
{
private:
    int degree;                 //degree<=MaxDegree
    float coef[MaxDegree+1];    //系数数组
public:
    Polynomial();                       //构造函数
    float Eval(float x);                //计算多项式数值
    Polynomial Add(Polynomial ploy);    //多项式加法
    Polynomial Mult(Polynomial poly);   //多项式乘法
};

若degree<<MaxDegree，coef[ ]的大多位置不会被占用，可以做出如下改进

class Polynomial
{
private:
    int degree;     //degree<=MaxDegree
    float *coef; 	//系数数组
	...
};

若为稀疏多项式，则仅存储非零项，可以做出如下改进

class Term				//数组元素
{
    friend Polynomial;
private:
    float coef;			//系数
    int exp;			//指数
    ...
}
class Polynomial		//数组
{
    Term* termArray;    //非零项数组
    int terms;          //非零项数
    int capacity;       //最大容量
    ...
};

2、计算多项式数值

float Polynomial::Eval(float x)
{
    int temp=0;
    for(int i=0;i<this->terms;i++)
    {
        temp+=this->termArray[i].coef*pow(x,this->termArray[i].exp);
    }
    return temp;
}

3、多项式加法

void Polynomial::TailInsertTerm(float coef,int exp) //尾插节点
{
    if(this->terms==this->capacity){   //及时扩容
        this->capacity*=2;
        Term* tempTerm=new Term[this->capacity];
        for(int i=0;i<this->terms;i++)tempTerm[i]=this->termArray[i];
        delete[]this->termArray;                                    
        this->termArray=tempTerm;          
    }    
    this->termArray[terms].exp=exp;
    this->termArray[terms++].coef=coef;
}
Polynomial Polynomial::Add(Polynomial poly)
{
    Polynomial tempPoly;
    int aPos=0,bPos=0;                          //记录this->terms与poly的下标
    while(aPos<this->terms&&bPos<poly.terms)
    {
        if(this->termArray[aPos].exp==poly.termArray[bPos].exp){
            if(this->termArray[aPos].coef+poly.termArray[bPos].coef!=0)     //指数相同且系数和非0   
                tempPoly.TailInsertTerm(this->termArray[aPos].coef+poly.termArray[bPos].coef,this->termArray[aPos].exp);
            aPos++,bPos++;
        }
        else if(this->termArray[aPos].exp<poly.termArray[bPos].exp)         //存入指数更小的系数
            tempPoly.TailInsertTerm(this->termArray[aPos].coef,this->termArray[aPos].exp),aPos++;
        else
            tempPoly.TailInsertTerm(poly.termArray[bPos].coef,poly.termArray[bPos].exp),bPos++;
    }
    while(aPos<this->terms&&tempPoly.terms<=tempPoly.capacity)              //拷贝数组剩余元素
    {
        tempPoly.TailInsertTerm(this->termArray[aPos].coef,this->termArray[aPos].exp),aPos++;
    }
    while(bPos<poly.terms&&tempPoly.terms<=tempPoly.capacity)               //拷贝数组剩余元素
    {
        tempPoly.TailInsertTerm(poly.termArray[bPos].coef,poly.termArray[bPos].exp),bPos++;
    }
    return tempPoly;
}

4、多项式乘法

void Polynomial::InsertTerm(float coef,int exp)     //插入节点
{
    if(this->terms==this->capacity){   				//及时扩容
        this->capacity*=2;
        Term* tempTerm=new Term[this->capacity];
        for(int i=0;i<this->terms;i++){
            tempTerm[i]=this->termArray[i];
        }
        delete[]this->termArray;                                    
        this->termArray=tempTerm;          
    }  
    int idx=this->terms;                            //标记插入节点位置
    for(int i=0;i<this->terms-1;i++){
        if(this->termArray[i].exp==exp){
            idx=i;break;
        }
        if(this->termArray[i].exp<exp&&this->termArray[i+1].exp>exp){
            idx=i+1;break;
        }
    }
    if(this->termArray[0].exp>=exp)idx=0;
    if(this->termArray[terms-1].exp==exp)idx=terms-1;
    if(this->termArray[idx].exp==exp){               //查找到指数相同节点
        this->termArray[idx].coef+=coef;
        if(this->termArray[idx].coef==0){            //若系数和为零
            for(int i=idx;i<this->terms-1;i++)this->termArray[i]=this->termArray[i+1];
            this->terms--;
        }
    }
    else{                                            //未查找到指数相同节点
        for(int i=this->terms;i>idx;i--){
            this->termArray[i]=this->termArray[i-1];
        }
        this->termArray[idx].exp=exp;
        this->termArray[idx].coef=coef;
        this->terms++;
    }
}
Polynomial Polynomial::Mult(Polynomial poly)
{
    Polynomial tempPoly;
    int coef=0,exp=0;
    for(int i=0;i<this->terms;i++){
        for(int j=0;j<poly.terms;j++){
            coef=this->termArray[i].coef*poly.termArray[j].coef;
            exp=this->termArray[i].exp+poly.termArray[j].exp;
            tempPoly.InsertTerm(coef,exp);
        }
    }
    return tempPoly;
}

二、稀疏矩阵

1、稀疏矩阵的ADT定义

class MatrixTerm			//稀疏矩阵元素
{
    friend SparseMatrix;
private:
    int row;    			//行
    int col;    			//列
    int value;  			//元素数值
};
class SparseMatrix			//稀疏矩阵
{
private:
    MatrixTerm* termArray;  //非零项数组
    int rows;               //总行数
    int cols;               //总列数
    int terms;              //非零项数
    int capacity;           //最大容量
public:
    SparseMatrix(int r,int c,int t);    //创建一个有r行c列，可以容纳t个非0项的SparseMatrix
    SparseMatrix Transpose();           //矩阵转置
    SparseMatrix Add(SparseMatrix matrix);   //矩阵加法
    SparseMatrix Mult(SparseMatrix matrix);  //矩阵乘法
};

2、矩阵转置

SparseMatrix SparseMatrix::Transpose()
{
    SparseMatrix temp=SparseMatrix(this->cols,this->rows,this->terms);
    if(this->terms)    {
        int counter=0;
        for(int i=0;i<this->cols;i++){
            for(int j=0;j<this->terms;j++){
                if(this->termArray[j].col==i){
                    temp.termArray[counter].row=i;
                    temp.termArray[counter].col=this->termArray[j].row;
                    temp.termArray[counter++].value=this->termArray[j].value;
                }
            }
        }
    }
    return temp;
}

在terms达到rowscols的数量级时，Transpose的运行时间达到O(rowcol^2)，用时过长，以下给出快速转置的方法

SparseMatrix SparseMatrix::FastTranspose()
{
    SparseMatrix temp=SparseMatrix(this->cols,this->rows,this->terms);
    if(terms>0){
        int* rowStart=new int[this->cols]{};
        int* rowSize=new int[this->cols]{};
        for(int i=0;i<this->terms;i++)rowSize[this->termArray[i].col]++;
        for(int i=1;i<this->cols;i++)rowStart[i]=rowStart[i-1]+rowSize[i-1];
        for(int i=0;i<this->terms;i++){
            temp.termArray[rowStart[this->termArray[i].col]++]=this->termArray[i];
            swap(temp.termArray[rowStart[this->termArray[i].col]-1].col,temp.termArray[rowStart[this->termArray[i].col]-1].row);
        }
        delete[]rowSize;
        delete[]rowStart;
    }
    return temp;
}

3、矩阵加法

void SparseMatrix::TailInsertTerm(int row,int col,int value)
{
    if (this->terms == this->capacity)
    {
        this->capacity *= 2;
        MatrixTerm* tempTerm = new MatrixTerm[this->capacity];
        for (int i = 0; i < this->terms; i++) {
        tempTerm[i] = this->termArray[i];
        }
        delete[]this->termArray;
        this->termArray = tempTerm;
    }
    this->termArray[terms].row=row;
    this->termArray[terms].col=col;
    this->termArray[terms].value=value;
    this->terms++;
}

SparseMatrix SparseMatrix::Add(SparseMatrix matrix)
{
    if(this->rows!=matrix.rows||this->cols!=matrix.cols){
        throw"Incompatible matrices";
    }
    SparseMatrix tempSparseMatrix{this->rows,matrix.cols,0};
    int apos=0,bpos=0;
    while(apos<this->terms&&bpos<matrix.terms)
    {
        if(this->termArray[apos].row<matrix.termArray[bpos].row){
            tempSparseMatrix.InsertTerm(this->termArray[apos].row,this->termArray[apos].col,this->termArray[apos].value);apos++;
        }
        else if(this->termArray[apos].row>matrix.termArray[bpos].row){
            tempSparseMatrix.InsertTerm(matrix.termArray[bpos].row,matrix.termArray[bpos].col,matrix.termArray[bpos].value);bpos++;
        }
        else if(this->termArray[apos].col<matrix.termArray[bpos].col){
            tempSparseMatrix.InsertTerm(this->termArray[apos].row,this->termArray[apos].col,this->termArray[apos].value);apos++;
        }
        else if(this->termArray[apos].col>matrix.termArray[bpos].col){
            tempSparseMatrix.InsertTerm(matrix.termArray[bpos].row,matrix.termArray[bpos].col,matrix.termArray[bpos].value);bpos++;
        }
        else{
            tempSparseMatrix.InsertTerm(matrix.termArray[bpos].row,matrix.termArray[bpos].col,this->termArray[apos].value+matrix.termArray[bpos].value);apos++,bpos++;
        }
    }
    while(apos<this->terms)
    {
        tempSparseMatrix.InsertTerm(this->termArray[apos].row,this->termArray[apos].col,this->termArray[apos].value);apos++;
    }
    while(bpos<matrix.terms)
    {
        tempSparseMatrix.InsertTerm(matrix.termArray[bpos].row,matrix.termArray[bpos].col,matrix.termArray[bpos].value);bpos++;
    }
    return tempSparseMatrix;
}

4、矩阵乘法

void SparseMatrix::InsertTerm(int row, int col, int value)	
{
    if (this->terms == this->capacity)	//及时扩容
    {
        this->capacity *= 2;
        MatrixTerm* tempTerm = new MatrixTerm[this->capacity];
        for (int i = 0; i < this->terms; i++) {
        tempTerm[i] = this->termArray[i];
        }
        delete[]this->termArray;
        this->termArray = tempTerm;
    }
    if(row==this->termArray[terms-1].row&&col==this->termArray[terms-1].col){    //与前项位置相同
        this->termArray[terms-1].value+=value;
        if(!this->termArray[terms-1].value)this->terms--;    //系数和为零            
    }
    else{    //与前面项位置不同
        this->termArray[terms].row = row;
        this->termArray[terms].col = col;
        this->termArray[terms].value = value;
        this->terms++;
    }
}

SparseMatrix SparseMatrix::Mult(SparseMatrix matrix)
{
    if(this->cols!=matrix.rows){
        throw"Incompatible matrices";
    }
    SparseMatrix tempSparseMatrix{ this->rows,matrix.cols,0};
    matrix=matrix.FastTranspose();
    for (int i = 0; i < this->terms; i++) {
        for (int j = 0; j < matrix.terms; j++) {
            if(this->termArray[i].col==matrix.termArray[j].col){
                tempSparseMatrix.InsertTerm(this->termArray[i].row, matrix.termArray[j].row, this->termArray[i].value * matrix.termArray[j].value);
            }
        }
    }
    return tempSparseMatrix;
}

三、字符串抽象数据类型

1、字符串的ADT定义

class String 
{
private:
    char* str;
public:
    String(char* init,int m);
    bool operator==(string t);      //判断*this字符串是否等于t
    bool operator!();               //若*this为空返回true
    int Length();                   //返回字符数目
    int Find(String pat);           //字符串匹配
    String Concat(String t);        //将t连接为*this字符串的后缀
    String Substr(int i,int j);     //返回i到j-i+1共计j个字符串
};

2、字符串匹配

int String::Find(String pat)
{
    for(int start=0;start<=Length()-pat.Length();start++){
        int j;
        for(j=0;j<pat.Length()&&str[start+j]==pat.str[j];j++){
            if(j==pat.Length()-1){
                return start;
            }
        }
    }
    return -1;
}

KMP(Knuth-Morris-Pratt)算法
当文本串与模式串不匹配时，无需从头重复遍历，可以直接跳转
时间复杂度为O(n+m)，其中n是文本串(this->str)的长度，m是模式串(pat.str)的长度

/*
  s ...a  b  c  a  ?  ?  ...
pat	   a  b  c  a  b  c  a  c  a  b
  i	   0  1  2  3  4  5  6  7  8  9
  f	  -1 -1 -1  0  1  2  3 -1  0  1
*/
void String::FailureFunction()	//获取失配函数
{
    this->f=new int[this->Length()];
    f[0]=-1;
    for(int i=1;i<this->Length();i++)
    {
        if(this->str[i]==this->str[f[i-1]+1]){
            this->f[i]=this->f[i-1]+1;
        }
        else{
            this->f[i]=-1;
        }
    }
}

int String::FastFind(String pat)
{
    int posP=0,posS=0;
    while(posP<pat.Length()&&posS<this->Length()){
        if(this->str[posS]==pat.str[posP])
            posS++,posP++;
        else{
            if(posP==0)
                posS++;
            else{
                posP=pat.f[posP-1]+1;
            }
        }
    }
    if(posP=pat.Length())
        return posS-posP;
    return -1;
}

四、多维数组

一维数组a[m1]
Loc[i]=a+i
二维数组a[m1][m2]
Loc[i,j]=a+i* m2+j
三维数组a[m1][m2][m3]
Loc[i,j,k]=a+i* m2* m3+j* m3+k

沙琪玛大王
关注
Chapter 1 Arrays and Strings
Geurney的专栏
07-17 566
1. 在string中是否含有重复字母 public static boolean hasUniqueChar(String string) { // Total 256 characters in ASCII if (string.length() > 256) { return false; } boolean[] count = new boolean[256]; for
java1_chapter6_array_two.zip
09-14
Arrays.stream(arr).forEach(row -> Arrays.stream(row).forEach(System.out::println)); ``` 在标签中提到的“九九乘法表和图案”，这是通过二维数组实现的一种经典应用。九九乘法表可以用二维数组表示，并用for...
java_Arrays模拟排序
m0_59605707的博客
10-10 239
java_Arrays模拟排序 这里不明白看一下以前讲的匿名内部类
CHAPTER 12 Arrays 7 2 4
CSDN_YJX的博客
06-01 184
CHAPTER 12 Arrays第七题第二题第四题 第七题 题意： 翻译： 第二题 题意： 翻译： 第四题 Programming Problems 第4 题回文（Palindrome）的判断。在本题扩展了回文的定义的情况下，从性能和算法等方面考虑该题目的进一步改进，并与第六章的实验题目对比。 题意： 译文： 代码如下： //This programm reads in a string from the KBD, AND ENDS AT reading a special CHAR
chapter_linear-networks：线性回归的简洁实现
weixin_40934238的博客
05-04 353
线性回归的简洁实现 🏷sec_linear_concise 参考动手学深度学习教材对应章节：https://zh-v2.d2l.ai/ 根据课程相关章节的Jupyter文件进行运行得到结果并导出。 在过去的几年里，出于对深度学习强烈的兴趣， 许多公司、学者和业余爱好者开发了各种成熟的开源框架。 这些框架可以自动化基于梯度的学习算法中重复性的工作。 在 :numref:sec_linear_scratch中，我们只运用了： （1）通过张量来进行数据存储和线性代数； （2）通过自动微分来计算梯度。 实际上，由于
Chapter12_Advanced_Numpy
qq_16735407的专栏
02-10 512
import numpy as np import pandas as pd import matplotlib.pyplot as plt//anaconda/lib/python2.7/site-packages/matplotlib/font_manager.py:273: UserWarning: Matplotlib is building the font cache using fc-
Chapter 4. Arrays and Pointers
weixin_30394633的博客
02-29 82
Chapter 4. Arrays and Pointers 数组 数组的定义不能用非const变量或者到运行时才知道其值的const变量,因为数组的空间分配是在代码运行之前做的事 在函数体外定义的内置数组，其元素初始化为0。在函数体内定义的内置数组，其元素无初始化。原因是函数里的变量的空间是在运行栈里分配的 指针 可以指向一个对象的地址。权限更大，更加通用。但是从安全性考虑还是不如用标准...
Chapter 4 Arrays and Pointers
Hello World
08-29 879
4.3 -- C-Style Character Strings When we allocate memory, we must eventually free it. Otherwise, memory is gradually used up and may be exhausted. When we no longer need the array, we must explici
Chapter 3: Linked Lists & Arrays
Royal_Wh1t3zZ的博客
04-22 882
This chatper mainly introduces about the linked lists and their operations.
Chapter2 : SpringBoot配置
学习技术的路上不断沉淀自己
03-12 1250
SpringBoot全局的配置文件
chapter03_对象的共享_4_不变性
captxb的博客
03-12 102
不可变对象 (1) 满足条件 1° 对象创建以后状态不能更改 2° 对象的所有域都是final类型(包括对象的字段也是final) 3° 对象被正确创建(构造函数中没有发生this引用逸出) (2) 不可变对象一定是线程安全的 (3) 不可变对象的状态可以更新, 更新的方式是通过一个保存新状态的实例来替换原有的不可变对象(例如String, Integer) final域 (1) 如果fi...
Chapter 2. Arrays and Spatial Filters_阵列信号处理_
09-29
本章“Chapter 2. Arrays and Spatial Filters”深入探讨了这一主题，特别是聚焦于阵列与空域滤波的技术。下面将详细阐述其中的知识点。 一、阵列信号处理基础 阵列信号处理涉及多个传感器或天线同时接收信号的情况...
Chapter 4- Arrays Pointers and String.rar_C++_filmhfx
09-21
本章“Chapter 4- Arrays Pointers and String”将深入探讨这些主题，尤其对于电影制作（filmhfx）领域的编程工作更是至关重要。 首先，数组是C++中的基本数据结构之一，它允许我们存储同类型的多个元素。数组定义...
数据结构严蔚敏chapter2arrays.ppt
09-28
2. **有序数组与二分查找** - 有序数组：数组中的元素按照特定规则（如数值或关键字）排序。这种结构有利于快速查找，例如通过二分查找算法，其时间复杂度为O(log n)。 - 二分查找：在有序数组中，从中间开始查找...
Chapter 4. Planar Arrays and Apertures_阵列信号处理_
10-04
本章“Chapter 4. Planar Arrays and Apertures”聚焦于平面阵列和孔径的设计与应用，这些阵列通常用于实现更精确的方向性、更高的分辨率以及增强抗干扰能力。 平面阵列，如名字所示，是指在二维平面上布置的一组...
atcoder abc372 启发式合并， dp
2201_75845839的博客
09-22 484
现在考虑如何存数据。可以用并查集合并两个集合，并且在合并的时候一定要将小的集合合并到大的集合中去，因为小集合合并到大集合中，最后的集合一定大于小集合元素数量的两倍，因此合并的时间复杂度不会超过logn。思路：判断当前变化的位置对结果是否会产生影响，在询问前先计算有多少ABC, 每次变换位置x前后扫描一下[x - 2, x + 2]范围内是否有ABC，变换前有让cnt --， 变换后有让cnt ++思路：三进制转换，可以参考二进制，先把当前可以加入的最大的3的幂次加入,这样一定可以凑出答案。
python 实现harmonic series调和级数算法
luthane的博客
09-24 844
Hn∑k1n1kHn​k1∑n​k1​其中，𝑛n 是正整数。这个级数是由调和数列（Harmonic sequence）的各元素相加所得的和。调和级数的名字源于泛音及泛音列，即一条振动的弦的泛音的波长依次是基本波长的12131421​31​41​等。调和级数的性质发散性：调和级数是一个发散的无穷级数，也就是说，它的部分和随着项数的增加而无限增长。
【优选算法】（第一篇）
最新发布
weixin_73861555的博客
09-25 953
这个⽅法是往后我们学习「快排算法」的时候，「数据划分」过程的重要⼀步。如果将快排算法拆解的话，这⼀段⼩代码就是实现快排算法的「核⼼步骤」。
【算法笔记】二分查找 红蓝染色法
weixin_51325964的博客
09-23 790
一个菜鸟的算法笔记
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值