数据结构第二章线性表学习笔记

最新推荐文章于 2021-04-24 15:55:32 发布

weixin_34007906

最新推荐文章于 2021-04-24 15:55:32 发布

阅读量146

点赞数

原文链接：http://www.cnblogs.com/dean-SunPeishuai/p/10446608.html

版权

1. C++程序设计模板（关于template的解释）【以下内容摘自百度】

函数声明格式

template <class(或typename) any(或任意符合规则的名称)>（如果还有其他类型名，就用逗号隔开）

返回类型函数名( 形参表);

函数定义和声明格式基本相同，形参表要加上形参名，分号改为函数体。

声明的例子：

1 template <class type1, class type2>
2 type1 add(type1,type2);
3 template <class type1, class type2>
4 type1 add(type1 a,type2 b)
5 {return a + (type1)b;}

也可以直接定义函数，不声明。

说明： template是一个声明模板的关键字，表示声明一个模板关键字class不能省略，如果形参类型多于一个，每个形参前都要加class <类型形参表>可以包含基本数据类型或类类。

 1 #include <iostream>
 2 using std::cout;
 3 using std::endl;
 4 //声明一个函数模版,用来比较输入的两个相同数据类型的参数的大小，class也可以被typename代替，
 5 //T可以被名称字代替，只要符合命名规则即可。
 6 template <class T>
 7 T min(T& x,T& y)
 8 { return(x<y)?x:y;}
 9 int main( )
10 {
11     int n1 = 2,n2 = 10;
12     double d1 = 1.5,d2 = 5.6;
13     cout<< "较小整数:"<<min(n1,n2)<<endl;
14     cout<< "较小实数:"<<min(d1,d2)<<endl;
15     system("PAUSE");
16     return 0;
17 }

程序运行结果：

程序分析：main()函数中定义了两个整型变量n1 , n2 两个双精度类型变量d1 , d2然后调用min( n1, n2); 即实例化函数模板T min(T x, T y)其中T为int型，求出n1,n2中的最小值．同理调用min(d1,d2)时，求出d1,d2中的最小值．

2.模板

一.模板概述

（1）模板时对具有相同特性的函数或类的再抽象，模板是一种参数化的多态性工具。

（2）所谓参数化多态性，是指将程序所处理的对象的类型参数化，使一段程序代码可以用于处理多种不同类型的对象。

（3）采用模板编程，可以为各种逻辑功能相同而数据类型不同的程序提供一种代码共享的机制。

模板实例化话：函数通过参数的实例化可以构建具体的函数或类，称为模板函数和模板类。

函数模板定义：

template<模板形参表>
返回值类型   函数名（参数表）
{
    函数体
}
函数模板实例：

template<typename T>//模板定义，T为模板参数。
T abs(T a)  //定义函数模板
{
 return a<?-a:a;
}
说明：template是模板定义的关键字。 <模板形参表>中包含一个或多个用逗号分开的模板形式参数，每一项
     关键字class或typename引导一个由用户命名的标识符，此标识符为模板参数(用来进行类型传递)
     模板参数表示一种数据类型，可以是基本数据类型或类类型。该数据类型在发生实际函数调用时将被实例化，
     即调用出的实际数据类型替代它。

类模板：
        同函数模板一样，类模板是参数化的类，即用于实现数据类型参数化的类。
        应用类模板可以使类中的数据成员  成员函数的参数及成员函数的返回值根据模
        板参数匹配情况取任意数据类型。
类模板定义：
        template<模板形参表>
        class 类模板名
         {
               成员的声明；
         }
实例：

template <typename T> //typename或class

class Square

{

 T x;

public:

Square(T xx):x(xx){ }

T fun(){return x*x;}

};

对于成员函数在类外定义的时候，有何变化：

double Rectangle::circumference( )

{ //普通类的成员函数在类外定义

return 2*length*width;

template<class T>

T Rectangle<T>::circumference( )

{ //类模板的成员函数在类外的定义

return 2*length*width;

n 设计函数模板，实现求解两个数的最小值：

#include<bits/stdc++.h>
using namespace std;
template <typename T>
T minn(T a,T b)
{
    return a>b?b:a;
}
int main()
{
    int a,b;
    double c,d;
    cin>>a>>b;
    cin>>c>>d;
    cout<<minn(a,b)<<endl;
    cout<<minn(c,d);
    return 0;
}

View Code

n 设计函数模板，实现对一组数据求和（数据放在一维数组中）：

#include<bits/stdc++.h>
using namespace std;
template <typename T>
T add(T a[],int n)
{
    T ans=0;
    for(int i=0;i<n;i++)
    {
        ans+=a[i];
    }
    return ans;
}
int main()
{
    int a[5]={0,1,2,3,4};
    double b[5]={1.1,2.2,3.3,4.4,5.5};
    cout<<add(a,5)<<endl;
    cout<<add(b,5)<<endl;
    return 0;
}

View Code

n 设计一个关于正方形的类模板，类的成员函数包括计算正方形的面积、周长、边长等函数，并且有带参的构造函数，类的成员函数需要在类的外部实现：

#include<bits/stdc++.h>
using namespace std;
template <typename T>
class Square{
    private:
        T length;
    public:
        Square(T x);
        ~Square(){};
        T area();
        T Perimeter();
};
template <class T>
Square<T>::Square(T x)///此处不应该返回void
{
    length=x;
}
template <class T>
T Square<T>::area()
{
    return length*length;
}
template <class T>
T Square<T>::Perimeter()
{
    return length*4;
}
int main()
{
    Square<int> intx(5);
    cout<<intx.area()<<endl;
    cout<<intx.Perimeter()<<endl;
    Square<double> doublex(2.5);
    cout<<doublex.area()<<endl;
    cout<<doublex.Perimeter()<<endl;
    return 0;
}

View Code

补充：指针

在存储空间里存放的信息可以通过两种方式访问（目前我所知道的）：

①通过定义的变量名称进行访问。例如：int a=5；那么可以通过变量名称a进行访问存储空间里的信息。

②通过指针变量进行访问：

#include<iostream>
using namespace std;
int main()
{
    int a=5;
    int *p=&a;///此处即为定义一个整型的指针变量，
///然后将变量a的地址通过&取址符赋值给*p,注意p只是一个指针变量也可以改变p的值
                
    cout<<p<<endl;///此处输出的仅为a的地址结果为  0x69fef8
    cout<<*p<<endl;///*为指针变量所指向的地址。   5
    return 0;
}

指针：一个变量的地址称为该变量的指针。

指针变量：一个特殊的变量，专门存放另一个变量地址的变量。（指针变量的值是一个地址）

区分指针和指针变量：

（1）一个指针是一个地址，是一个常量。

（2）一个指针变量却可以被赋予不同的指针值，是一个变量。

除此之外还有指向结构体变量的指针以及指向结构体数组的指针。

数据结构中涉及到：结构体变量的指针

可以通过：（*指针变量）.成员名

也可以直接：指针变量-->成员名

关于指针的内容依然很多，这里就不详细写了，只是回顾一下而已。

线性表的链式存储:

#include<bits/stdc++.h>///单链表的实现
using namespace std;
template<typename T>
struct Node
{
    T date;
    Node<T> *next;///此处的T可以省略
};
template<typename T>
class Linklist
{
public:
      Linklist(){first=new Node;first->NULL;}///无参构造函数建立空链表
      Linklist(T a[],int n);///有
      ~Linklist();
      //int Length;///通过一次遍历可得 长度
      T Get(int i);///返回链表第i个元素
      int Find(T x);
     // int Locate(T x);///返回元素X在链表中的位置
     void Insert(int i,T x);///插入元素
      T Delete(int i);
      void PrintList();
private:
    Node<T> *first;///单链表的头指针
}; 
/*      /*  头插法  *////每次插入到头指针的后面
template<typename T>
Linklist<T>::Linklist(T a[],int n)
{
    first=new Node;first->next=NULL;///
    Node<T>*s;            ///定义一个结构体指针
    for(int i=0;i<n;i++)
    {
        s=new Node<T>;s->date=a[i];///申请一个新的节点
        s->next=first->next;
        first->next=s;
    }
}
*/
/* 尾插法*////需要借助尾指针的辅助
template<typename T>
Linklist<T>::Linklist(T a[],int n)
{
    first=new Node;first->next=NULL;
    Node<T>*s;Node<T>*r;
    for(int i=0;i<n;i++)
    {
        s=new Node<T>;s->date=a[i];
        r->next=s;r=s;
    }
    r->next=NULL;
}
/*单链表的遍历*/
template<typename T>
Linklist<T>::PrintList()
{
   Node<T>*p;
   p=first->next;
   while(p)
   {
       cout<<p->date<<endl;
       p=p->next;
   }
}
/*查找第i个位置的值*/
template<typename T>
T Linklist<T>::Get(int i)
{
    
    Node<T>*p;
    p=first->next;int count=1;
    while(p&&count<i)
    {
      p=p->next;
      count++:
    }
    if(p) return p->date;
    else throw"位置";
}
/*按值查找算法 */
template<typename T>
int Linklist<T>::Find(T x)
{
    Node<T>*p;
    p=first;int j=0;
    while(p)
    {
        p=p->next;
        j++;
        if(p->data==x)
        {
            return j;
        }
    }
    return 0;
}
/*删除链表中第i个元素*/
template<typename T>
T Linklist<T>::Delete(int i)
{
    Node<T>*p;
    p=first;int j=0,x;
    while (p&&&j<i-1)
    {
        p=p->next;
        j++;
    }
    if(p==NULL||p->next==NULL) throw"位置";
    else
    {
        Node<T>*q;
        q=p->next;
        x=p->date;
        p->next=p->next->next;
        delete q;
        return x;
    }
    
}
 
    
/*按位置插入*/
template<typename T>
T Linklist<T>::Insert(int i,T x)
{
    Node<T>*p;
    p=first;int j=0;
    while(p&&j<i-1)
    {
        p=p->next;
        j++;
    }
    if(p) throw"位置";
    else
    {
       Node<T>*s;
       s->date=x;
       s->next=p->next;
       p->next=s;
    }
}

template<typename T>
Linklist<T>::~Linklist()
{
    Node<T>*p;
    while(first)
    {
        p=first;
        first=first->next;
        delete p;
    }
}
int main()
{
    
  
}

View Code

转载于:https://www.cnblogs.com/dean-SunPeishuai/p/10446608.html

weixin_34007906

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
数据结构第二章线性表学习笔记

1. C++程序设计模板（关于template的解释）【以下内容摘自百度】函数声明格式template <class(或typename)any(或任意符合规则的名称)>（如果还有其他类型名，就用逗号隔开）返回类型函数名(形参表);函数定义和声明格式基本相同，形参表要加上形参名，分号改为函数体。声明的例子： 1 template...
复制链接

扫一扫