01--数据结构——动态链表（C++）

数据结构——动态链表（C++）

定义一个节点：

[cpp] view plain copy

print?

  1. #include <iostream>
  2. using namespace std;
  3. typedef int T;
  4. struct Node{
  5. T data;
  6. Node* next;
  7. Node(const T& d):data(d), next(NULL){}
  8. operator T(){
  9. return data;
  10. }
  11. };
  12. int main(){
  13. Node a(10), b(20);
  14. cout << "a=" << a << ", b=" << b << endl;
  15. return 0;
  16. }

上面的运算符重载，先将a类型强转为T类型（也就是int),Java中的toString实际上就是类似的强转成string类型的。

输出一段简单的链表

[cpp] view plain copy

print?

  1. #include <iostream>
  2. using namespace std;
  3. typedef int T;
  4. struct Node{
  5. T data;
  6. Node* next;
  7. Node(const T& d):data(d), next(NULL){}
  8. operator T(){
  9. return data;
  10. }
  11. };
  12. int main(){
  13. Node a(10), b(20), c(30), d(40), e(50);
  14. a.next = &b;
  15. b.next = &c;
  16. c.next = &d;
  17. Node *p = &a;
  18. while(p != NULL){
  19. cout << *p << ‘ ‘;
  20. p = p->next;
  21. }
  22. cout << endl;
  23. return 0;
  24. }

给链表添加一个元素

[cpp] view plain copy

print?

  1. #include <iostream>
  2. using namespace std;
  3. typedef int T;
  4. struct Node{
  5. T data;
  6. Node* next;
  7. Node(const T& d):data(d), next(NULL){}
  8. operator T(){
  9. return data;
  10. }
  11. };
  12. //输出链表
  13. void showlist(Node* p){
  14. while(p != NULL){
  15. cout << *p << ‘ ‘;
  16. p = p->next;
  17. }
  18. cout << endl;
  19. }
  20. int main(){
  21. Node a(10), b(20), c(30), d(40), e(50);
  22. a.next = &b;
  23. b.next = &c;
  24. c.next = &d;
  25. showlist(&a);
  26. //添加一个节点
  27. Node* & p = b.next;//取b.next指针的别名
  28. e.next = p;
  29. p = &e;
  30. showlist(&a);
  31. //再添加一个节点
  32. Node* k = new Node(70);
  33. Node*& r = c.next;
  34. k->next = r;
  35. r = k;
  36. return 0;
  37. }

一个C++实现的链表如下：

[cpp] view plain copy

print?

  1. #include <iostream>
  2. using namespace std;
  3. typedef int T;
  4. class List{
  5. struct Node{
  6. T data;
  7. Node * next;
  8. //T()零初始化
  9. Node(const T& d=T()):data(d), next(0){}
  10. };
  11. Node * head; //头指针
  12. int len;
  13. public:
  14. List():head(NULL),len(0){ }
  15. //插入到任何位置
  16. //1、在链表里找到指向那个位置的指针pn
  17. //2、让新节点的next成员和pn指向同一个地方
  18. //3、再让pn指向新节点
  19. void insert(const T&d, int pos){
  20. Node*& pn = getptr(pos);
  21. Node* p = new Node(d);
  22. p->next = pn;
  23. pn = p;
  24. len++;
  25. }
  26. //返回链表长度
  27. int size()const{
  28. return len;
  29. }
  30. //尾插
  31. void push_back(const T& d){
  32. insert(d, size());
  33. }
  34. //找链表中指向指定位置的指针
  35. Node*& getptr(int pos){
  36. if(pos<0 || pos>size()) pos = 0;
  37. if(pos==0) return head;
  38. Node* p = head;
  39. for(int i=1; i<pos; i++)
  40. p = p->next;
  41. return p->next;
  42. }
  43. //前插
  44. void push_front(const T& d){
  45. insert(d, 0);
  46. }
  47. //遍历
  48. void travel()const{
  49. Node* p = head;
  50. while(p!=NULL){
  51. cout << p->data << ‘ ‘;
  52. p = p->next;
  53. }
  54. cout << endl;
  55. }
  56. //清空
  57. void clear(){
  58. while(head!=NULL){
  59. Node * p = head->next;
  60. delete head;
  61. head = p;
  62. }
  63. len = 0;
  64. }
  65. ~List(){
  66. clear();
  67. }
  68. //按照位置删除
  69. //1、找到链表中指向那个位置的指针
  70. //2、把那个指针另存一份
  71. //3、让那个指针指向下一个节点
  72. //4、释放那个指针的动态内存
  73. void erase(int pos){
  74. if(pos<0 || pos>=size()) return;
  75. Node *& pn = getptr(pos);
  76. Node * p = pn;
  77. pn = pn->next;
  78. delete p;
  79. --len;
  80. }
  81. //根据元素查找位置
  82. int find(const T& d)const{
  83. int pos = 0;
  84. Node* p = head;
  85. while(p){
  86. if(p->data==d) return pos;
  87. p = p->next;
  88. ++pos;
  89. }
  90. return -1;
  91. }
  92. //根据元素删除
  93. void remove(const T& d){
  94. int pos;
  95. while((pos = find(d)) != -1)
  96. erase(pos);
  97. }
  98. };
  99. int main(){
  100. List l;
  101. l.push_front(5);
  102. l.push_front(8);
  103. l.push_front(20);
  104. //在第2个位置插入9
  105. l.insert(9, 2);
  106. l.travel();
  107. return 0;
  108. }

通过上图可以看出来，如果我们要插入一个节点，就需要找到指向该位置的指针（或者前一个结点），比如上图的p->next指针就是我们需要找到的。删除一个节点也一样，需要找到指向该节点的指针。

数据结构——动态链表（C++）

标签： 数据结构链表C++

2014-12-05 22:00 958人阅读 评论(0) 收藏 举报

 分类：

数据结构（8） 

定义一个节点：

[cpp] view plain copy

print?

  1. #include <iostream>
  2. using namespace std;
  3. typedef int T;
  4. struct Node{
  5. T data;
  6. Node* next;
  7. Node(const T& d):data(d), next(NULL){}
  8. operator T(){
  9. return data;
  10. }
  11. };
  12. int main(){
  13. Node a(10), b(20);
  14. cout << "a=" << a << ", b=" << b << endl;
  15. return 0;
  16. }

上面的运算符重载，先将a类型强转为T类型（也就是int),Java中的toString实际上就是类似的强转成string类型的。

输出一段简单的链表

[cpp] view plain copy

print?

  1. #include <iostream>
  2. using namespace std;
  3. typedef int T;
  4. struct Node{
  5. T data;
  6. Node* next;
  7. Node(const T& d):data(d), next(NULL){}
  8. operator T(){
  9. return data;
  10. }
  11. };
  12. int main(){
  13. Node a(10), b(20), c(30), d(40), e(50);
  14. a.next = &b;
  15. b.next = &c;
  16. c.next = &d;
  17. Node *p = &a;
  18. while(p != NULL){
  19. cout << *p << ‘ ‘;
  20. p = p->next;
  21. }
  22. cout << endl;
  23. return 0;
  24. }

给链表添加一个元素

[cpp] view plain copy

print?

  1. #include <iostream>
  2. using namespace std;
  3. typedef int T;
  4. struct Node{
  5. T data;
  6. Node* next;
  7. Node(const T& d):data(d), next(NULL){}
  8. operator T(){
  9. return data;
  10. }
  11. };
  12. //输出链表
  13. void showlist(Node* p){
  14. while(p != NULL){
  15. cout << *p << ‘ ‘;
  16. p = p->next;
  17. }
  18. cout << endl;
  19. }
  20. int main(){
  21. Node a(10), b(20), c(30), d(40), e(50);
  22. a.next = &b;
  23. b.next = &c;
  24. c.next = &d;
  25. showlist(&a);
  26. //添加一个节点
  27. Node* & p = b.next;//取b.next指针的别名
  28. e.next = p;
  29. p = &e;
  30. showlist(&a);
  31. //再添加一个节点
  32. Node* k = new Node(70);
  33. Node*& r = c.next;
  34. k->next = r;
  35. r = k;
  36. return 0;
  37. }

一个C++实现的链表如下：

[cpp] view plain copy

print?

  1. #include <iostream>
  2. using namespace std;
  3. typedef int T;
  4. class List{
  5. struct Node{
  6. T data;
  7. Node * next;
  8. //T()零初始化
  9. Node(const T& d=T()):data(d), next(0){}
  10. };
  11. Node * head; //头指针
  12. int len;
  13. public:
  14. List():head(NULL),len(0){ }
  15. //插入到任何位置
  16. //1、在链表里找到指向那个位置的指针pn
  17. //2、让新节点的next成员和pn指向同一个地方
  18. //3、再让pn指向新节点
  19. void insert(const T&d, int pos){
  20. Node*& pn = getptr(pos);
  21. Node* p = new Node(d);
  22. p->next = pn;
  23. pn = p;
  24. len++;
  25. }
  26. //返回链表长度
  27. int size()const{
  28. return len;
  29. }
  30. //尾插
  31. void push_back(const T& d){
  32. insert(d, size());
  33. }
  34. //找链表中指向指定位置的指针
  35. Node*& getptr(int pos){
  36. if(pos<0 || pos>size()) pos = 0;
  37. if(pos==0) return head;
  38. Node* p = head;
  39. for(int i=1; i<pos; i++)
  40. p = p->next;
  41. return p->next;
  42. }
  43. //前插
  44. void push_front(const T& d){
  45. insert(d, 0);
  46. }
  47. //遍历
  48. void travel()const{
  49. Node* p = head;
  50. while(p!=NULL){
  51. cout << p->data << ‘ ‘;
  52. p = p->next;
  53. }
  54. cout << endl;
  55. }
  56. //清空
  57. void clear(){
  58. while(head!=NULL){
  59. Node * p = head->next;
  60. delete head;
  61. head = p;
  62. }
  63. len = 0;
  64. }
  65. ~List(){
  66. clear();
  67. }
  68. //按照位置删除
  69. //1、找到链表中指向那个位置的指针
  70. //2、把那个指针另存一份
  71. //3、让那个指针指向下一个节点
  72. //4、释放那个指针的动态内存
  73. void erase(int pos){
  74. if(pos<0 || pos>=size()) return;
  75. Node *& pn = getptr(pos);
  76. Node * p = pn;
  77. pn = pn->next;
  78. delete p;
  79. --len;
  80. }
  81. //根据元素查找位置
  82. int find(const T& d)const{
  83. int pos = 0;
  84. Node* p = head;
  85. while(p){
  86. if(p->data==d) return pos;
  87. p = p->next;
  88. ++pos;
  89. }
  90. return -1;
  91. }
  92. //根据元素删除
  93. void remove(const T& d){
  94. int pos;
  95. while((pos = find(d)) != -1)
  96. erase(pos);
  97. }
  98. };
  99. int main(){
  100. List l;
  101. l.push_front(5);
  102. l.push_front(8);
  103. l.push_front(20);
  104. //在第2个位置插入9
  105. l.insert(9, 2);
  106. l.travel();
  107. return 0;
  108. }

通过上图可以看出来，如果我们要插入一个节点，就需要找到指向该位置的指针（或者前一个结点），比如上图的p->next指针就是我们需要找到的。删除一个节点也一样，需要找到指向该节点的指针。

时间： 2024-11-09 02:17:27

01--数据结构——动态链表（C++）的相关文章

数据结构——动态链表（C++）

定义一个节点: #include <iostream> using namespace std; typedef int T; struct Node{ T data; Node* next; Node(const T& d):data(d), next(NULL){} operator T(){ return data; } }; int main(){ Node a(10), b(20); cout << "a=" << a <&l

数据结构——动态链表

说明:严蔚敏的<数据结构>(C语言版)学习笔记,记录一下,以备后面查看. #include <stdio.h> #include <malloc.h> const int OK = 1; //定义正确返回 const int ERROR = -1; //定义错误的返回 const int OVERFLOW = -2; //定义溢出 //定义元素类型 typedef int ElemType; //定义返回类型 typedef int Status; typedef st

vc++基础班[28]---动态数组及动态链表的讲解

C++中也有相应的动态数组.动态链表.映射表的模板类,就是STL中的:vector.list.map 他们属于C++标准中的一部分,对于程序的移植性来说也是不错的,但是在MFC编程中使用 CArray.CList.CMap 会更方便一些! CArray.CList.CMap 的由来?…… ①.数组的基本说明: 数组是固定大小的,相同数据类型的元素的顺序集合,每个元素在数组中有一个固定的位置. 将10个数放入数组中,假设数组的名称为number,可以称数组中第一个元素为 number[0],第二个

数据结构--单向链表

C语言中,我们在使用数组时,会需要对数组进行插入和删除的操作,这时就需要移动大量的数组元素,但在C语言中,数组属于静态内存分配,数组在定义时就必须指定数组的长度或者初始化.这样程序一旦运行,数组的长度就不能再改变,若想改变,就只能修改源代码.实际使用中数组元素的个数也不能超过数组元素的最大长度,否则就会发生下标越界的错误(这是新手在初学C语言时肯定会遇到的问题,相信老师也会反复强调!!!但这种问题肯定会遇到,找半天找不到错误在哪,怪我咯???).另外如果数组元素的使用低于最大长度,又会造成系统资

c语言：写一个函数建立一个有3名学生数据的单向动态链表

写一个函数建立一个有3名学生数据的单向动态链表. 解:程序: #include<stdio.h> #include<stdlib.h> #define LEN sizeof(struct Student) struct Student { long num; float score; struct Student *next; }; int n; struct Student *creat(void)//定义函数返回一个指向链表头的指针 { struct Student *head

使用C语言描述静态链表和动态链表

静态链表和动态链表是线性表链式存储结构的两种不同的表示方式. 静态链表的初始长度一般是固定的,在做插入和删除操作时不需要移动元素,仅需修改指针,故仍具有链式存储结构的主要优点. 动态链表是相对于静态链表而言的,一般地,在描述线性表的链式存储结构时如果没有特别说明即默认描述的是动态链表. 下面给出它们的简单实现,关于线性表更为详尽的C语言的实现,可以参考 http://www.cnblogs.com/choon/p/3876606.html 静态链表 #define _CRT_SECURE_NO_

基本数据结构：链表（list）

copy from:http://www.cppblog.com/cxiaojia/archive/2012/07/31/185760.html 基本数据结构:链表(list) 谈到链表之前,先说一下线性表.线性表是最基本.最简单.也是最常用的一种数据结构.线性表中数据元素之间的关系是一对一的关系,即除了第一个和最后一个数据元素之外,其它数据元素都是首尾相接的.线性表有两种存储方式,一种是顺序存储结构,另一种是链式存储结构. 顺序存储结构就是两个相邻的元素在内存中也是相邻的.这种存储方式的优点是

数据结构之链表单向操作总结

链表是数据结构的基础内容之一,下面就链表操作中的创建链表.打印链表.求取链表长度.判断链表是否为空.查找结点.插入结点.删除结点.逆转链表.连接链表.链表结点排序等进行总结. 1.创建表示结点的类,因为链表操作中需要比较结点,因此结点需要实现comparable接口. public class Node implements Comparable<Node> { private Object data; private Node next; //构造函数 public Node() { thi

C++ 动态链表

C++ 动态链表 用类写的 头文件代码: 1 #include<iostream> 2 #include<string> 3 //动态创建链表 4 using namespace std; 5 class LNode { 6 private: 7 string StudentNum; 8 string Name; 9 int age; 10 LNode *next; 11 public: 12 LNode() {}//构造函数 13 ~LNode() {}//析构函数 14 voi