首页 / 算法 / 6.4-数据结构&算法-模板/函数模板/类模板/特化

6.4-数据结构&算法-模板/函数模板/类模板/特化

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了6.4-数据结构&算法-模板/函数模板/类模板/特化，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含16068字，纯文字阅读大概需要23分钟。

内容图文

一、为什么要有模板？

将类型参数化，可以实现算法与类型的分离，编写针对类型更加抽象的函数或者类。

二、函数模板

通用定义：

template<typename 类型形参1, ...>

返回类型函数模板名 (形参表) { ... }

特化定义：

template<>

返回类型函数模板名<类型实参1, ...> (形参表) { ... }

三、类模板

通用定义：

template<typename 类型形参1, ...>

class 类模板名 { ... };

全类特化：

template<>

class 类模板名<类型实参1, ...> { ... };

成员特化：

template<>

返回类型类模板名<类型实参1, ...>::成员函数名 (形参表) { ... }

四、局部特化

五、非类型参数和缺省参数

1.非类型参数的实参仅限于常量或者常量表达式。

2.无论类型参数还是非类型参数都可以带有缺省值，而且和函数的缺省参数一样，模板的缺省参数也必须靠右。

六、有关模板的其它问题

1.从模板继承

2.向模板派生

3.模板中模板成员

1)模板型成员变量

2)模板型成员函数

3)模板型成员类型

4.模板型模板实参

七、容器和迭代器

arg.cpp

#include <iostream>
usingnamespace std;
template<typename T>
class A {
public:
    A (const T& t) : m_t (t) {}
    T m_t;
};
template<typename X, typename Z,
    template<typename T> class Y>
class B {
public:
    B (const X& i, const Z& s) :
        m_i (i), m_s (s) {}
    Y<X> m_i;
    Y<Z> m_s;
};
int main (void) {
    B<int, string, A> b (100, "hello");
    cout << b.m_i.m_t << ‘‘ << b.m_s.m_t << endl;
    return0;
}

array.cpp

#include <iostream>
usingnamespace std;
template<typename T = int, size_t S = 5>
class Array {
public:
    T& operator[] (size_t i) {
        return m_array[i];
    }
    const T& operator[] (size_t i) const {
        return const_cast<Array&> (*this) [i];
    }
    size_t size (void) const {
        return S;
    }
    friend ostream& operator<< (ostream& os,
        const Array& arr) {
        for (size_t i = 0; i < arr.size (); ++i)
            os << ‘(‘ << arr.m_array[i] << ‘)‘;
        return os;
    }
private:
    T m_array[S];
};
int main (void) {
    const/*volatile*/int x = 3, y = 7;
    Array<int, x+y> arr;
    for (size_t i = 0; i < arr.size (); ++i)
        arr[i] = i;
    cout << arr << endl;
    Array<Array<int, 4>, 3> m;
    for (size_t i = 0; i < m.size (); ++i)
        for (size_t j = 0; j < m[i].size (); ++j)
            m[i][j] = i * m[i].size () + j;
    cout << m << endl;
    Array<double> a2;
    Array<> a3;
    return0;
}

cmp.cpp

#include <iostream>
#include <cstring>
usingnamespace std;
// 通用模板
template<typename T>
class Comparator {
public:
    Comparator (T x, T y) : m_x (x), m_y (y) {}
    T min (void) const {
        return m_x < m_y ? m_x : m_y;
    }
    T max (void) const {
        return m_x > m_y ? m_x : m_y;
    }
private:
    T m_x;
    T m_y;
};
/*
// 针对char*的全模板特化
template<>
class Comparator<char*> {
public:
    Comparator (char* x, char* y) :
        m_x (x), m_y (y) {}
    char* min (void) const {
        return strcmp (m_x, m_y) < 0 ? m_x : m_y;
    }
    char* max (void) const {
        return strcmp (m_x, m_y) > 0 ? m_x : m_y;
    }
private:
    char* m_x;
    char* m_y;
};
*/// 针对char*的成员函数特化
template<>
char* Comparator<char*>::min (void) const {
    return strcmp (m_x, m_y) < 0 ? m_x : m_y;
}
template<>
char* Comparator<char*>::max (void) const {
    return strcmp (m_x, m_y) > 0 ? m_x : m_y;
}
int main (void) {
    cout << "输入两个整数：" << flush;
    int nx, ny;
    cin >> nx >> ny;
    Comparator<int> cn (nx, ny);
    cout << "最小值：" << cn.min () << endl;
    cout << "最大值：" << cn.max () << endl;
    cout << "输入两个字符串：" << flush;
    string sx, sy;
    cin >> sx >> sy;
    Comparator<string> cs (sx, sy);
    cout << "最小值：" << cs.min () << endl;
    cout << "最大值：" << cs.max () << endl;
    cout << "输入两个字符串：" << flush;
    char cx[256], cy[256];
    cin >> cx >> cy;
    Comparator<char*> cc (cx, cy);
    cout << "最小值：" << cc.min () << endl;
    cout << "最大值：" << cc.max () << endl;
    return0;
}

inher.cpp

#include <iostream>
usingnamespace std;
template<typename T>
class A {
public:
    A (const T& t) : m_t (t) {}
    T m_t;
};
template<typename T, typename Y>
class B : public A<T> {
public:
    B (const T& t, const Y& y) :
        A<T> (t), m_y (y) {}
    Y m_y;
};
int main (void) {
    B<int, string> b (100, "hello");
    cout << b.m_t << ‘‘ << b.m_y << endl;
    return0;
}

inter.cpp

#include <iostream>
usingnamespace std;
template<typename T>
class A {
public:
    class B {};
};
template<typename T>
void foo (void) {
    typename A<T>::B b;
}
int main (void) {
    foo<int> ();
    return0;
}

list.cpp

#include <iostream>
#include <stdexcept>
#include <cstring>
usingnamespace std;
// 双向线性链表容器模板
template<typename T>
class List {
public:
    // 构造、析构、拷贝构造、拷贝赋值
    List (void) : m_head (NULL), m_tail (NULL) {}
    ~List (void) {
        clear ();
    }
    List (const List& that) : m_head (NULL),
        m_tail (NULL) {
        for (Node* node = that.m_head; node;
            node = node->m_next)
            push_back (node->m_data);
    }
    List& operator= (const List& that) {
        if (&that != this) {
            List list (that);
            swap (m_head, list.m_head);
            swap (m_tail, list.m_tail);
        }
        return *this;
    }
    // 获取首元素
    T& front (void) {
        if (empty ())
            throw underflow_error ("链表下溢！");
        return m_head->m_data;
    }
    const T& front (void) const {
        return const_cast<List*> (this)->front ();
    }
    // 向首部压入void push_front (const T& data) {
        m_head = new Node (data, NULL, m_head);
        if (m_head->m_next)
            m_head->m_next->m_prev = m_head;
        else
            m_tail = m_head;
    }
    // 从首部弹出void pop_front (void) {
        if (empty ())
            throw underflow_error ("链表下溢！");
        Node* next = m_head->m_next;
        delete m_head;
        m_head = next;
        if (m_head)
            m_head->m_prev = NULL;
        else
            m_tail = NULL;
    }
    // 获取尾元素
    T& back (void) {
        if (empty ())
            throw underflow_error ("链表下溢！");
        return m_tail->m_data;
    }
    const T& back (void) const {
        return const_cast<List*> (this)->back ();
    }
    // 向尾部压入void push_back (const T& data) {
        m_tail = new Node (data, m_tail);
        if (m_tail->m_prev)
            m_tail->m_prev->m_next = m_tail;
        else
            m_head = m_tail;
    }
    // 从尾部弹出void pop_back (void) {
        if (empty ())
            throw underflow_error ("链表下溢！");
        Node* prev = m_tail->m_prev;
        delete m_tail;
        m_tail = prev;
        if (m_tail)
            m_tail->m_next = NULL;
        else
            m_head = NULL;
    }
    // 删除所有匹配元素void remove (const T& data) {
        for (Node* node = m_head, *next; node;
            node = next) {
            next = node->m_next;
            if (equal (node->m_data, data)) {
                if (node->m_prev)
                    node->m_prev->m_next =
                        node->m_next;
                else
                    m_head = node->m_next;
                if (node->m_next)
                    node->m_next->m_prev =
                        node->m_prev;
                else
                    m_tail = node->m_prev;
                delete node;
            }
        }
    }
    // 清空void clear (void) {
        for (Node* next; m_head; m_head = next) {
            next = m_head->m_next;
            delete m_head;
        }
        m_tail = NULL;
    }
    // 判空bool empty (void) const {
        return ! m_head && ! m_tail;
    }
    // 获取大小
    size_t size (void) const {
        size_t count = 0;
        for (Node* node = m_head; node;
            node = node->m_next)
            ++count;
        return count;
    }
    // 插入输出流
    friend ostream& operator<< (ostream& os,
        const List& list) {
        for (Node* node = list.m_head; node;
            node = node->m_next)
            os << *node;
        return os;
    }
private:
    // 节点class Node {
    public:
        Node (const T& data = 0, Node* prev = NULL,
            Node* next = NULL) : m_data (data),
            m_prev (prev), m_next (next) {}
        friend ostream& operator<< (ostream& os,
            const Node& node) {
            return os << ‘(‘ << node.m_data << ‘)‘;
        }
        T m_data; // 数据
        Node* m_prev; // 前指针
        Node* m_next; // 后指针    };
    bool equal (const T& a, const T& b) const {
        return a == b;
    }
    Node* m_head; // 头指针
    Node* m_tail; // 尾指针public:
    // 正向迭代器class Iterator {
    public:
        Iterator (Node* head = NULL,
            Node* tail = NULL, Node* node = NULL) :
            m_head (head), m_tail (tail),
            m_node (node) {}
        booloperator== (const Iterator& it) const {
            return m_node == it.m_node;
        }
        booloperator!= (const Iterator& it) const {
            return ! (*this == it);
        }
        Iterator& operator++ (void) {
            if (m_node)
                m_node = m_node->m_next;
            else
                m_node = m_head;
            return *this;
        }
        const Iterator operator++ (int) {
            Iterator old = *this;
            ++*this;
            return old;
        }
        Iterator& operator-- (void) {
            if (m_node)
                m_node = m_node->m_prev;
            else
                m_node = m_tail;
            return *this;
        }
        const Iterator operator-- (int) {
            Iterator old = *this;
            --*this;
            return old;
        }
        T& operator* (void) const {
            return m_node->m_data;
        }
        T* operator-> (void) const {
            return &**this;
        }
    private:
        Node* m_head;
        Node* m_tail;
        Node* m_node;
        friend class List;
    };
    Iterator begin (void) {
        return Iterator (m_head, m_tail, m_head);
    }
    Iterator end (void) {
        return Iterator (m_head, m_tail);
    }
    Iterator insert (Iterator loc, const T& data) {
        if (loc == end ()) {
            push_back (data);
               return Iterator (m_head, m_tail,m_tail);
        }
        else {
            Node* node = new Node (data,
                loc.m_node->m_prev, loc.m_node);
            if (node->m_prev)
                node->m_prev->m_next = node;
            else
                m_head = node;
            node->m_next->m_prev = node;
            return Iterator (m_head, m_tail, node);
        }
    }
    Iterator erase (Iterator loc) {
        if (loc == end ())
            throw invalid_argument ("无效迭代器！");
        if (loc.m_node->m_prev)
            loc.m_node->m_prev->m_next =
                loc.m_node->m_next;
        else
            m_head = loc.m_node->m_next;
        if (loc.m_node->m_next)
            loc.m_node->m_next->m_prev =
                loc.m_node->m_prev;
        else
            m_tail = loc.m_node->m_prev;
        Node* next = loc.m_node->m_next;
        delete loc.m_node;
        return Iterator (m_head, m_tail, next);
    }
};
// 针对const char*的特化
template<>
bool List<constchar*>::equal (constchar* const& a,
    constchar* const& b) const {
    return strcmp (a, b) == 0;
}
// 测试用例int main (void) {
    try {
        List<int> list1;
        list1.push_front (20);
        list1.push_front (10);
        list1.push_back (30);
        list1.push_back (40);
        cout << list1 << endl;
        cout << list1.front () << ‘‘ <<
            list1.back () << endl;
        list1.pop_front ();
        list1.pop_back ();
        cout << list1 << endl;
        ++list1.front ();
        --list1.back ();
        cout << list1 << endl;
        list1.push_back (21);
        list1.push_back (25);
        list1.push_back (21);
        list1.push_back (21);
        cout << list1 << endl;
        list1.remove (21);
        cout << list1 << endl;
        List<int> list2 = list1;
        cout << list2 << endl;
        list2.back () = 100;
        cout << list2 << endl;
        cout << list1 << endl;
        list2 = list1;
        cout << list2 << endl;
        list2.front () = 100;
        cout << list2 << endl;
        cout << list1 << endl;
        cout << list1.size () << endl;
        list1.clear ();
        cout << list1 << endl;
        cout << boolalpha << list1.empty () << endl;
//        List<string> list3;
        List<constchar*> list3;
        list3.push_back ("beijing");
        list3.push_back ("tianjin");
        list3.push_front ("tianjin");
        list3.push_back ("shanghai");
        list3.push_back ("beijing");
        cout << list3 << endl;
        list3.remove (string ("beijing").c_str ());
        cout << list3 << endl;
        for (List<constchar*>::Iterator it =
            list3.begin (); it != list3.end ();
            ++it)
            cout << *it << ‘‘;
        cout << endl;
        List<constchar*>::Iterator it =
            list3.begin ();
        it++;
        it = list3.insert (it, "chongqing");
        cout << list3 << endl;
        list3.erase (it);
        cout << list3 << endl;
    }
    catch (exception& ex) {
        cout << ex.what () << endl;
        return -1;
    }
    return0;
}

max.cpp

#include <iostream>
usingnamespace std;
int max_int (int x, int y) {
    return x > y ? x : y;
}
string max_str (string x, string y) {
    return x > y ? x : y;
}
int main (void) {
    cout << "输入两个整数：" << flush;
    int nx, ny;
    cin >> nx >> ny;
    cout << "最大值：" << max_int (nx, ny) << endl;
    cout << "输入两个字符串：" << flush;
    string sx, sy;
    cin >> sx >> sy;
    cout << "最大值：" << max_str (sx, sy) << endl;
    return0;
}

max2.cpp

#include <iostream>
#include <typeinfo>
#include <cstring>
usingnamespace std;
// 函数模板/模板函数
template<typename T>
T Max (T x, T y) {
    cout << typeid (T).name () << endl;
    return x > y ? x : y;
}
// 模板特化
template<>
char* Max<char*> (char* x, char* y) {
    return strcmp (x, y) > 0 ? x : y;
}
template<typename T>
void foo (void) {
    T t;
    cout << typeid (t).name () << endl;
}
int main (void) {
    cout << "输入两个整数：" << flush;
    int nx, ny;
    cin >> nx >> ny;
    cout << "最大值：" << Max (nx, ny) << endl;
    cout << "输入两个字符串：" << flush;
    string sx, sy;
    cin >> sx >> sy;
    cout << "最大值：" << Max (sx, sy) << endl;
    cout << "输入两个字符串：" << flush;
    char cx[256], cy[256];
    cin >> cx >> cy;
    cout << "最大值：" << Max (cx, cy) << endl;
    /*
    foo<int> ();
    foo<double> ();
    foo<string> ();
    */return0;
}

memb1.cpp

#include <iostream>
usingnamespace std;
template<typename T>
class A {
public:
    A (const T& t) : m_t (t) {}
    T m_t;
};
template<typename T, typename Y>
class B {
public:
    B (const T& t, const Y& y) :
        m_a (t), m_y (y) {}
    A<T> m_a;
    Y m_y;
};
int main (void) {
    B<int, string> b (100, "hello");
    cout << b.m_a.m_t << ‘‘ << b.m_y << endl;
    return0;
}

memb2.cpp

#include <iostream>
usingnamespace std;
template<typename T>
class A {
public:
    A (const T& t) : m_t (t) {}
    /*
    template<typename Y>
    void print (const Y& y) {
        cout << m_t << ‘ ‘ << y << endl;
    }
    */
    template<typename Y>
    void print (const Y& y);
    T m_t;
};
template<typename T>
    template<typename Y>
void A<T>::print (const Y& y) {
    cout << m_t << ‘‘ << y << endl;
}
int main (void) {
    A<int> a (100);
    a.print<string> ("hello");
    return0;
}

memb3.cpp

#include <iostream>
usingnamespace std;
template<typename T, typename Y>
class A {
public:
    A (const T& t, const Y& y) :
        m_t (t), m_b (y) {}
    /*
    template<typename X>
    class B {
    public:
        B (const X& x) : m_x (x) {}
        X m_x;
    };
    */
    template<typename X> class B;
    T m_t;
    B<Y> m_b;
};
template<typename T, typename Y>
    template<typename X>
class A<T, Y>::B {
public:
    B (const X& x) : m_x (x) {}
    X m_x;
};
int main (void) {
    A<int, string> a (100, "hello");
    cout << a.m_t << ‘‘ << a.m_b.m_x << endl;
    return0;
}

part.cpp

#include <iostream>
usingnamespace std;
template<typename T1, typename T2>
class A {
public:
    A (void) {
        cout << "A<T1,T2>" << endl;
    }
};
template<typename T1>
class A<T1, int> {
public:
    A (void) {
        cout << "A<T1,int>" << endl;
    }
};
template<>
class A<int, int> {
public:
    A (void) {
        cout << "A<int,int>" << endl;
    }
};
template<typename T>
class B {
public:
    B (void) {
        cout << "B<T>" << endl;
    }
};
template<typename T>
class B<T*> {
public:
    B (void) {
        cout << "B<T*>" << endl;
    }
};
template<typename T>
class B<T[]> {
public:
    B (void) {
        cout << "B<T[]>" << endl;
    }
};
template<typename T1, typename T2, typename T3>
class C {
public:
    C (void) {
        cout << "C<T1,T2,T3>" << endl;
    }
};
template<typename T1, typename T2>
class C<T1, T2, T2> {
public:
    C (void) {
        cout << "C<T1,T2,T2>" << endl;
    }
};
template<typename T1>
class C<T1, T1*, T1*> {
public:
    C (void) {
        cout << "C<T1,T1*,T1*>" << endl;
    }
};
int main (void) {
    // 特化程度高的优先
    A<double, double> a1;
    A<double, int> a2;
    A<int, int> a3;
    // 针对指针和数组的特化优先
    B<char> b1;
    B<char*> b2;
    B<char[]> b3;
    // 匹配度高的特化优先
    C<char, short, long> c1;
    C<char, short, short> c2;
    C<char, char*, char*> c3;
    return0;
}

shape.cpp

#include <iostream>
usingnamespace std;
template<typename BASE>
class Shape : public BASE {
public:
    void draw (void) const {
        BASE::draw ();
    }
};
class Rect {
public:
    void draw (void) const {
        cout << "绘制矩形..." << endl;
    }
};
class Circle {
public:
    void draw (void) const {
        cout << "绘制圆形..." << endl;
    }
};
int main (void) {
    Shape<Rect> shape1;
    shape1.draw ();
    Shape<Circle> shape2;
    shape2.draw ();
    return0;
}

原文：https://www.cnblogs.com/xuxaut-558/p/10028385.html

内容总结

以上是互联网集市为您收集整理的6.4-数据结构&算法-模板/函数模板/类模板/特化全部内容，希望文章能够帮你解决6.4-数据结构&算法-模板/函数模板/类模板/特化所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1270091.html

来源：【匿名】

【下一篇】浅谈php实现映射的两种方法（链表和二叉树）

更多 ►

【6.4-数据结构&算法-模板/函数模板/类模板/特化】教程文章相关的互联网学习教程文章

6.4-数据结构&算法-模板/函数模板/类模板/特化【代码】

一、为什么要有模板？将类型参数化，可以实现算法与类型的分离，编写针对类型更加抽象的函数或者类。二、函数模板通用定义：template<typename 类型形参1, ...>返回类型函数模板名 (形参表) { ... }特化定义：template<>返回类型函数模板名<类型实参1, ...> (形参表) { ... } 三、类模板通用定义：template<typename 类型形参1, ...>class 类模板名 { ... };全类特化：template<>class 类模板名<类型实参1, ...> { ... };成员特...

数据结构算法【代码】【图】

在待排序的文件中，若存在多个关键字相同的记录，经过排序后这些具有相同关键字的记录之间的相对次序保持不变，该排序方法是稳定的；若具有相同关键字的记录之间的相对次序发生改变，则称这种排序方法是不稳定的。即所有相等的数经过某种排序方法后，仍能保持它们在排序之前的相对次序，则说这种排序算法是稳定的，反之，就是不稳定的。、一、冒泡排序冒泡排序（BubbleSort）的基本概念是：个人理解就是将待排序的元素看作...

7, java数据结构和算法: 八皇后问题分析和实现 , 递归回溯【代码】【图】

什么是八皇后问题: 指的是,在一个8 * 8的棋盘中, 放置8个棋子, 保证这8个棋子相互之间, 不在同一行,同一列,同一斜线, 共有多少种摆法? 游戏连接: http://www.4399.com/flash/42643.htm#search3 直接上代码:public class QueueLv8 {int maxSize =8;int[] array = new int[maxSize];static int count = 0;//正解次数static int okCount = 0;//判断次数public static void main(String[] args){//8皇后问题: 指的是,在一个8 * 8的棋盘...

常见python内置数据结构算法

数据结构/算法语言内置内置库线性结构list/tuplearry/collections.namedtuple链式结构collections.deque（双端队列）字典结构dictcollections. Counter/OrderedDict集合结构set/frozenset排序算法sorted二分算法bisect模块堆算法heapq模块缓存算法functools.lru_cache原文：https://blog.51cto.com/12080420/2389067

数据结构2-关于链表的插入算法自己的思考

链表的插入初始条件：1.带有头结点的链表 2.插入位置 i 3.插入的节点Node基本操作：假设p指向某个节点 q指向被插入的节点则可以执行的是在p之后插入节点初始化：1.p=L 指向头结点 2.j=1寻找第i-1个结点：　　　　while（j<i）{　　　　　　p=p->next;　　　　　　j++;　　　　}这样最终指向的是第i-1个结点；i的不同情况：1.i<1 直接跳出 2.1<=i<=length 可以正常执行 3.i=length+1 在链表末尾插入数据 4.i>length+1 出现空指针异...

数据结构&算法（二）_算法基础之前传（递归、时间复杂度、空间复杂度、二分查找）【代码】【图】

什么是算法：　　间而言之算法（Algorithm）：一个计算过程，解决问题的方法递归的两个特点：　　调用自身　　结束条件递归示例：def func(x):if x==0:print("我的小鲤鱼",end=‘‘)else:print("抱着",end=‘‘)func(x-1)print("的我",end="")func(5)递归示例一：我的小鲤鱼‘‘‘ 112358132134 输出长度为 n 的斐波那契数列 ‘‘‘ #方式一：while 循环 def fibo(num):a=1b=1i=1while i<=num:print(a,end="")a,b = b,a+bi+=1 # ...

algorithm---算法设计，数据结构基本概念-之我的归纳 by whb_咸菜---圣斗士啊斌斌斌斌

算法的定义从广泛上来说，可以说是完成一件事情的方法或步骤。在计算机的角度说，算法是一组有限的指令集组成的过程。 -- 有限的。算法有五个特性：确定性，可行性，有穷性，and 输入，输出！必须指出的是，算法可以改变我们程序的运行时间，好的算法可以节省我们很多时间，使我们的程序运行起来更行云流水，得心应手。但是算法不是影响我们程序运行效果的唯一因为，受其他因为影响，比如机器质量，语言，编译程序，程序员的...

数据结构和算法

数据结构：数据之间存在某种关系；算法：对问题求解的步骤描述，在计算机中表现为一些列指令和操作算法五个特性：输入（输入参数），输出（得到的结果），确定性（步骤是有意义的无歧义的），可行性（每个步骤都是可行的）正确性（除前面的特性外，还还具有反映出问题的需求并得到正确的答案）算法效率度量：事后计算：测试方法和算法要一对一；事前估算：时间复杂度（执行的次数），空间复杂度原文：http://www.cnblogs.com/stra...

算法总结（2）数据结构【图】

数据结构（Data Structure) 是指相互之间具有（存在）一定联系（关系）的数据元素的集合。元素之间相互关系称为逻辑结构。数据之间的逻辑结构有四种基本类型集合：结构中的数据元素除了“同属于一个集合”外，没有其它关系。线性结构：结构中的数据元素之间存在一对一的关系。树形结构：结构中的数据元素之间存在一对多的关系。图状结构或网状结构：结构中的数据元素之间存在多对多的关系。数据结构的存储方式数据结构在计...

数据结构和算法-回溯算法

参考：https://www.cnblogs.com/xiaobaidashu/p/10724789.html 一、什么是回溯算法回溯算法实际上一个类似枚举的搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就“回溯”返回，尝试别的路径。许多复杂的，规模较大的问题都可以使用回溯法，有“通用解题方法”的美称。回溯算法实际上一个类似枚举的深度优先搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就“...

数据结构之二叉树树结构练习——排序二叉树的中序遍历（排序建树+中序遍历）【代码】

树结构练习——排序二叉树的中序遍历Time Limit: 1000MS Memory limit: 65536K题目描述在树结构中，有一种特殊的二叉树叫做排序二叉树，直观的理解就是——(1).每个节点中包含有一个关键值 (2).任意一个节点的左子树（如果存在的话）的关键值小于该节点的关键值 (3).任意一个节点的右子树（如果存在的话）的关键值大于该节点的关键值。现给定一组数据，请你对这组数据按给定顺序建立一棵排序二叉树，并输出其中序遍历的结果。输入...

浅谈算法和数据结构: 二基本排序算法【代码】【图】

<P style=‘font: 14px/22px "Lucida Grande", "Lucida Sans Unicode", Helvetica, Arial, Verdana, sans-serif; margin: 15px auto 10px; padding: 0px; text-align: justify; color: rgb(68, 68, 68); text-transform: none; text-indent: 0px; letter-spacing: normal; word-spacing: 0px; white-space: normal; orphans: 2; widows: 2; font-size-adjust: none; font-stretch: normal; background-color: rgb(255, 255, 255); ...

数据结构-排序算法原理和Python实现【代码】【图】

排序算法概览插入排序基本思想是每次讲一个待排序的记录，按其关键字大小插入到前面已拍好的子序列中，直到全部完成。直接插入排序讲元素L(i)插入到有序序列L[1,…,i-1]中，执行以下操作： 1. 查找出L(i)在L[1,…,i-1]中的插入位置k。 2. 将L[k,…,i-1]中所有元素全部后移一位。 3. 将L(i)复制到L(k)def InsertSort(array_a, n):for i in range(1, n):temp = array_a[i]j = i - 1while temp < array_a[j] and j >= 0:array_a[j + 1...

省选算法学习-数据结构-splay【代码】【图】

于是乎，在丧心病狂的noip2017结束之后，我们很快就要迎来更加丧心病狂的省选了-_-||所以从写完上一篇博客开始到现在我一直深陷数据结构和网络流的漩涡不能自拔今天终于想起来写博客（只是懒吧......）言归正传。省选级别的数据结构比NOIP要高到不知道哪里去了。noip只考一点线段树啊st表啊并查集啊之类的简单数据结构，而且应用范围很窄但是省选里面对数据结构，尤其是高级数据结构的要求就高了很多，更有一些题目看着就是数据结...

数据结构和算法-单链表排序【代码】

参考：https://leetcode-cn.com/problems/sort-listhttps://blog.csdn.net/Jacketinsysu/article/details/52472364?utm_source=blogkpcl7 148. 排序链表给你链表的头结点 head ，请将其按升序排列并返回排序后的链表。进阶：你可以在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序吗？示例 1：输入：head = [4,2,1,3]输出：[1,2,3,4]/** * Definition for singly-linked list. * public class ListNode { * ...

数据结构 - 相关标签

数据结构导论数据结构是什么数据结构习题数据结构严蔚敏数据结构与算法分析

算法 - 最热教程

浅谈SQLServer查询优化器中的JOIN算法有没那种可逆算法是密文比明文短的呢？...javascript-类似Excel里面的NORMDIST函...C++中的分治算法及常见题目汇总压缩感知重构算法综述-学习笔记 c++中内置函数qsort（快速排序）和bsea...一、fpga图像处理算法整合基于遗传算法（deap）的非线性函数寻优...集成学习-Bagging集成学习算法随机森林...机器学习笔记（九）聚类算法及实践（K-...

首页 / 算法 / 6.4-数据结构&算法-模板/函数模板/类模板/特化

6.4-数据结构&算法-模板/函数模板/类模板/特化

内容导读

内容图文

内容总结

内容备注

内容手机端

【6.4-数据结构&算法-模板/函数模板/类模板/特化】教程文章相关的互联网学习教程文章

6.4-数据结构&算法-模板/函数模板/类模板/特化【代码】

数据结构算法【代码】【图】

7, java数据结构和算法: 八皇后问题分析和实现 , 递归回溯【代码】【图】

常见python内置数据结构算法

数据结构2-关于链表的插入算法自己的思考

数据结构&算法（二）_算法基础之前传（递归、时间复杂度、空间复杂度、二分查找）【代码】【图】

algorithm---算法设计，数据结构基本概念-之我的归纳 by whb_咸菜---圣斗士啊斌斌斌斌

数据结构和算法

算法总结（2）数据结构【图】

数据结构和算法-回溯算法

数据结构之二叉树树结构练习——排序二叉树的中序遍历（排序建树+中序遍历）【代码】

浅谈算法和数据结构: 二基本排序算法【代码】【图】

数据结构-排序算法原理和Python实现【代码】【图】

省选算法学习-数据结构-splay【代码】【图】

数据结构和算法-单链表排序【代码】

数据结构 - 相关标签

函数 - 相关标签

算法 - 相关标签

算法 - 最新教程

算法 - 最热教程