《C++数据结构-快速拾遗》 手写链表

最新推荐文章于 2023-11-01 18:53:52 发布
最新推荐文章于 2023-11-01 18:53:52 发布
阅读量201 收藏 2
点赞数
文章标签： 链表 c++ 数据结构 java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011046017/article/details/115523715
版权

注释：吕鑫老师C++对于找工作真的是很好的教程，基本什么方面都讲的很细致，但是对于大多数人只有快进快进再快进~~

注释：基本链表信息自己百度，这里只是一个快速拾遗过程。

1.链表定义

1 typedef int DATA;//int的别名，为了便于管理
2 
3 //定义链表一个链节点
4 typedef struct SNode
5 {
6     DATA data;//数据，可以是结构体和类等，4字节
7     SNode *pNext;//指针，指向下一个节点，4字节
8 };

2.插入一个节点

 1 #include <iostream>
 2 
 3 using namespace std;
 4 
 5 //#define DATA int
 6 typedef int DATA;//int的别名，为了便于管理
 7 
 8 //定义链表一个链节点
 9 typedef struct SNode
10 {
11     DATA data;//数据，可以是结构体和类等，4字节
12     SNode *pNext;//指针，指向下一个节点，4字节
13 }; 
14 SNode* g_pHead = NULL;//第一个链表是空链表
15 //从头插入一个数据
16 void AddHead(DATA data)
17 {
18     SNode* p = new SNode;//申请一个堆空间，8字节
19     p->data  = data;
20     p->pNext = g_pHead;
21     g_pHead  = p;//把新插入的节点当做头
22 }
23 int main(int argc, char**argv[])
24 {
25     AddHead(1);
26     AddHead(2);
27     AddHead(3);
28     cout<<g_pHead->data<<endl<<g_pHead->pNext->data<<endl<<g_pHead->pNext->pNext->data<<endl;
29     return 0;
30 }

3.从尾部插入一个节点

 1 #include <iostream>
 2 
 3 using namespace std;
 4 
 5 //#define DATA int
 6 typedef int DATA;//int的别名，为了便于管理
 7 
 8 //定义链表一个链节点
 9 typedef struct SNode
10 {
11     DATA data;//数据，可以是结构体和类等，4字节
12     SNode *pNext;//指针，指向下一个节点，4字节
13 }; 
14 SNode* g_pHead = NULL;//第一个链表是空链表
15 //从尾插入一个数据
16 void AddTail(DATA data)
17 {
18     SNode* p = g_pHead;//防止改变头结点的指针
19     //建立新的节点
20     SNode* p1 = new SNode;
21     p1->data = data;
22     p1->pNext = NULL;
23     if(!p)//如果一开始就是空链表
24     {
25         g_pHead = p1;
26         return;
27     }
28     while(p->pNext)//找到最尾部的节点
29     {
30         p = p->pNext;
31     }
32     p->pNext = p1;
33 }
34 int main(int argc, char**argv[])
35 {
36 /*     AddHead(1);
37     AddHead(2);
38     AddHead(3); */
39     AddTail(11);
40     AddTail(12);
41     AddTail(13);
42     while(g_pHead)
43     {
44         cout<<g_pHead->data<<endl;
45         g_pHead = g_pHead->pNext;
46     }
47     //cout<<g_pHead->data<<endl<<g_pHead->pNext->data<<endl<<g_pHead->pNext->pNext->data<<endl;
48     return 0;
49 }

4.修改节点数据

 1 #include <iostream>
 2 
 3 using namespace std;
 4 
 5 //#define DATA int
 6 typedef int DATA;//int的别名，为了便于管理
 7 
 8 //定义链表一个链节点
 9 typedef struct SNode
10 {
11     DATA data;//数据，可以是结构体和类等，4字节
12     SNode *pNext;//指针，指向下一个节点，4字节
13 }; 
14 SNode* g_pHead = NULL;//第一个链表是空链表
15 //从尾插入一个数据
16 void AddTail(DATA data)
17 {
18     SNode* p = g_pHead;//防止改变头结点的指针
19     //建立新的节点
20     SNode* p1 = new SNode;
21     p1->data = data;
22     p1->pNext = NULL;
23     if(!p)//如果一开始就是空链表
24     {
25         g_pHead = p1;
26         return;
27     }
28     while(p->pNext)//找到最尾部的节点
29     {
30         p = p->pNext;
31     }
32     p->pNext = p1;
33 }
34 void Modify(DATA data, DATA newData)
35 {
36     SNode* p = g_pHead;
37     SNode* p1 = new SNode;
38     if (!p)
39     {
40         p1->data = newData;
41         p1->pNext = NULL;
42         g_pHead = p1;
43         return;
44     }
45     while(p)
46     {
47         if (p->data==data)
48         {
49             p->data = newData;
50         }
51         p = p->pNext; 
52     }
53 }
54 int main(int argc, char**argv[])
55 {
56 /*     AddHead(1);
57     AddHead(2);
58     AddHead(3); */
59     AddTail(11);
60     AddTail(12);
61     AddTail(13);
62     Modify(13,16);
63     while(g_pHead)
64     {
65         cout<<g_pHead->data<<endl;
66         g_pHead = g_pHead->pNext;
67     }
68     cout<<"hell2";
69     return 0;
70 }

5.查找和打印链表

 1 #include <iostream>
 2 
 3 using namespace std;
 4 
 5 //#define DATA int
 6 typedef int DATA;//int的别名，为了便于管理
 7 
 8 //定义链表一个链节点
 9 typedef struct SNode
10 {
11     DATA data;//数据，可以是结构体和类等，4字节
12     SNode *pNext;//指针，指向下一个节点，4字节
13 }; 
14 SNode* g_pHead = NULL;//第一个链表是空链表
15 //从尾插入一个数据
16 void AddTail(DATA data)
17 {
18     SNode* p = g_pHead;//防止改变头结点的指针
19     //建立新的节点
20     SNode* p1 = new SNode;
21     p1->data = data;
22     p1->pNext = NULL;
23     if(!p)//如果一开始就是空链表
24     {
25         g_pHead = p1;
26         return;
27     }
28     while(p->pNext)//找到最尾部的节点
29     {
30         p = p->pNext;
31     }
32     p->pNext = p1;
33 }
34 //查找某个数据
35 bool Find(DATA data)
36 {
37     SNode* p = g_pHead;
38     while(p)
39     {
40         if(p->data == data) return true;
41         p = p->pNext;    
42     }
43     return false;
44 }
45 void print()
46 {
47     SNode* p = g_pHead;
48     while(p)
49     {
50         cout<<p->data<<endl;
51         p = p->pNext;
52     }
53 }
54 int main(int argc, char**argv[])
55 {
56 /*     AddHead(1);
57     AddHead(2);
58     AddHead(3); */
59     AddTail(11);
60     AddTail(12);
61     AddTail(13);
62     //Modify(13,16);
63     print();
64     cout<<"shifou : "<<Find(10);
65     return 0;
66 }

6.删除链表节点

 1 #include <iostream>
 2 
 3 using namespace std;
 4 
 5 //#define DATA int
 6 typedef int DATA;//int的别名，为了便于管理
 7 
 8 //定义链表一个链节点
 9 typedef struct SNode
10 {
11     DATA data;//数据，可以是结构体和类等，4字节
12     SNode *pNext;//指针，指向下一个节点，4字节
13 }; 
14 SNode* g_pHead = NULL;//第一个链表是空链表
15 //从尾插入一个数据
16 void AddTail(DATA data)
17 {
18     SNode* p = g_pHead;//防止改变头结点的指针
19     //建立新的节点
20     SNode* p1 = new SNode;
21     p1->data = data;
22     p1->pNext = NULL;
23     if(!p)//如果一开始就是空链表
24     {
25         g_pHead = p1;
26         return;
27     }
28     while(p->pNext)//找到最尾部的节点
29     {
30         p = p->pNext;
31     }
32     p->pNext = p1;
33 }
34 //删除某个节点
35 bool Delete(DATA data)
36 {
37     SNode* p = g_pHead;//当前节点
38     SNode* p1 = NULL;//下一个节点
39     if(!p) return false;//空链表直接返回
40     if(p->data == data )//删除第一个节点
41     {
42         g_pHead = p->pNext;
43         delete p;
44         return true;
45     }        
46     while(p)//删除中间和结尾节点
47     {
48         if(p->data == data)
49         {
50             p1->pNext = p->pNext;
51             delete p;
52             return true;
53         }
54         p1 = p;
55         p = p->pNext;
56     }
57     return false;
58 }
59 void print()
60 {
61     SNode* p = g_pHead;
62     while(p)
63     {
64         cout<<p->data<<endl;
65         p = p->pNext;
66     }
67 }
68 int main(int argc, char**argv[])
69 {
70 /*     AddHead(1);
71     AddHead(2);
72     AddHead(3); */
73     AddTail(11);
74     AddTail(12);
75     AddTail(13);
76     //Modify(13,16);
77     Delete(13);
78     print();
79     cout<<"shifou : "<<Find(10);
80     return 0;
81 }

7.排序链表

　　以后面试再看链表外排和内排：https://chuanke.baidu.com/v1760453-135963-545032.html

 1 #include <iostream>
 2 
 3 using namespace std;
 4 
 5 //#define DATA int
 6 typedef int DATA;//int的别名，为了便于管理
 7 //定义一个结构体当做数据
 8 /* typedef struct DATA
 9 {
10     int nNumb;
11     char sName[20];
12     float fMath;
13 }; */
14 //定义链表一个链节点
15 typedef struct SNode
16 {
17     DATA data;//数据，可以是结构体和类等，4字节
18     SNode *pNext;//指针，指向下一个节点，4字节
19 }SNode; 
20 SNode* g_pHead = NULL;//第一个链表是空链表
21 //从尾插入一个数据
22 void AddTail(DATA data)
23 {
24     SNode* p = g_pHead;//防止改变头结点的指针
25     //建立新的节点
26     SNode* p1 = new SNode;
27     p1->data = data;
28     p1->pNext = NULL;
29     if(!p)//如果一开始就是空链表
30     {
31         g_pHead = p1;
32         return;
33     }
34     while(p->pNext)//找到最尾部的节点
35     {
36         p = p->pNext;
37     }
38     p->pNext = p1;
39 }
40 //打印全部节点数据
41 void print()
42 {
43     SNode* p = g_pHead;
44     while(p)
45     {
46         cout<<p->data<<endl;
47         p = p->pNext;
48     }
49 }
50 //交换数据的排序
51 void sortByNum(bool reverse = true)
52 {
53     SNode* p = g_pHead;
54     SNode* m = NULL;
55     while(p)
56     {
57         m = p->pNext;
58         while(m)
59         {
60             if(p->data > m->data && reverse)
61             {
62                 DATA midData;
63                 midData = p->data;
64                 p->data = m->data;
65                 m->data = midData;
66             }
67             else if(p->data < m->data && !reverse)
68             {
69                 DATA midData;
70                 midData = p->data;
71                 p->data = m->data;
72                 m->data = midData;
73             }
74             m = m->pNext;
75         }
76         p=p->pNext;
77     }
78 }
79 int main(int argc, char*argv[])
80 {
81 /*     AddHead(1);
82     AddHead(2);
83     AddHead(3); */
84     AddTail(11);
85     AddTail(2);
86     AddTail(13);
87     AddTail(10);
88     AddTail(14);
89     AddTail(1);
90     //Modify(13,16);
91     //Delete(13);
92     print();
93     sortByNum(false);
94     print();
95     return 0;
96 }

8.总链表(结构体版)

  1 #include <iostream>
  2 
  3 using namespace std;
  4 
  5 //#define DATA int
  6 typedef int DATA;//int的别名，为了便于管理
  7 //定义一个结构体当做数据
  8 /* typedef struct DATA
  9 {
 10     int nNumb;
 11     char sName[20];
 12     float fMath;
 13 }; */
 14 //定义链表一个链节点
 15 typedef struct SNode
 16 {
 17     DATA data;//数据，可以是结构体和类等，4字节
 18     SNode *pNext;//指针，指向下一个节点，4字节
 19 }SNode; 
 20 SNode* g_pHead = NULL;//第一个链表是空链表
 21 //从尾插入一个数据
 22 void AddTail(DATA data)
 23 {
 24     SNode* p = g_pHead;//防止改变头结点的指针
 25     //建立新的节点
 26     SNode* p1 = new SNode;
 27     p1->data = data;
 28     p1->pNext = NULL;
 29     if(!p)//如果一开始就是空链表
 30     {
 31         g_pHead = p1;
 32         return;
 33     }
 34     while(p->pNext)//找到最尾部的节点
 35     {
 36         p = p->pNext;
 37     }
 38     p->pNext = p1;
 39 }
 40 //从头插入一个数据
 41 void AddHead(DATA data)
 42 {
 43     SNode* p = new SNode;//申请一个堆空间，8字节
 44     p->data  = data;
 45     p->pNext = g_pHead;
 46     g_pHead  = p;//把新插入的节点当做头
 47 }
 48 //修改链表节点数据
 49 void Modify(DATA data, DATA newData)
 50 {
 51     SNode* p = g_pHead;
 52     SNode* p1 = new SNode;
 53     if (!p)
 54     {
 55         p1->data = newData;
 56         p1->pNext = NULL;
 57         g_pHead = p1;
 58         return;
 59     }
 60     while(p)
 61     {
 62         if (p->data==data)
 63         {
 64             p->data = newData;
 65         }
 66         p = p->pNext; 
 67     }
 68 }
 69 //查找某个数据
 70 bool Find(DATA data)
 71 {
 72     SNode* p = g_pHead;
 73     while(p)
 74     {
 75         if(p->data == data) return true;
 76         p = p->pNext;    
 77     }
 78     return false;
 79 }
 80 //删除某个节点
 81 bool Delete(DATA data)
 82 {
 83     SNode* p = g_pHead;//当前节点
 84     SNode* p1 = NULL;//下一个节点
 85     if(!p) return false;//空链表直接返回
 86     if(p->data == data )//删除第一个节点
 87     {
 88         g_pHead = p->pNext;
 89         delete p;
 90         return true;
 91     }        
 92     while(p)//删除中间和结尾节点
 93     {
 94         if(p->data == data)
 95         {
 96             p1->pNext = p->pNext;
 97             delete p;
 98             return true;
 99         }
100         p1 = p;
101         p = p->pNext;
102     }
103     return false;
104 }
105 //打印全部节点数据
106 void print()
107 {
108     SNode* p = g_pHead;
109     while(p)
110     {
111         cout<<p->data<<endl;
112         p = p->pNext;
113     }
114 }
115 //交换数据的排序
116 void sortByNum(bool reverse = true)
117 {
118     SNode* p = g_pHead;
119     SNode* m = NULL;
120     while(p)
121     {
122         m = p->pNext;
123         while(m)
124         {
125             if(p->data > m->data && reverse)
126             {
127                 DATA midData;
128                 midData = p->data;
129                 p->data = m->data;
130                 m->data = midData;
131             }
132             else if(p->data < m->data && !reverse)
133             {
134                 DATA midData;
135                 midData = p->data;
136                 p->data = m->data;
137                 m->data = midData;
138             }
139             m = m->pNext;
140         }
141         p=p->pNext;
142     }
143 }
144 int main(int argc, char*argv[])
145 {
146 /*     AddHead(1);
147     AddHead(2);
148     AddHead(3); */
149     AddTail(11);
150     AddTail(2);
151     AddTail(13);
152     AddTail(10);
153     AddTail(14);
154     AddTail(1);
155     //Modify(13,16);
156     //Delete(13);
157     print();
158     sortByNum(false);
159     print();
160     return 0;
161 }

9.总链表(类版本)

  1 #include <iostream>
  2 
  3 using namespace std;
  4 /*
  5 typedef struct DATA
  6 {
  7     int sNum;
  8     char sName[20];
  9 }DATA;
 10 */
 11 typedef int DATA;
 12 typedef struct SNode
 13 {
 14     DATA data;
 15     SNode* pNext;
 16 }SNode;
 17 class CList
 18 {
 19 public:
 20     CList();
 21     ~CList();
 22     CList(CList&p);
 23     void AddTail(DATA data);
 24     void AddHead(DATA data);
 25     void Modify(DATA data, DATA newData);
 26     bool Find(DATA data);
 27     bool Delete(DATA data);
 28     void print();
 29     void sortByNum(bool reverse = true);
 30 private:
 31     SNode* m_pHead;
 32 };
 33 
 34 int main(int argc,char*argv[])
 35 {
 36     CList list1, list2;
 37     list1.AddHead(10);
 38     list1.AddHead(6);
 39     list1.AddHead(11);
 40     list1.AddHead(8);
 41     list1.AddHead(10);
 42     list1.AddHead(1);
 43     list1.print();
 44 
 45     list1.sortByNum();
 46     list1.print();
 47     list2 = list1;
 48     list2.print();
 49     return 0;
 50 }
 51 
 52 CList::CList()
 53 {
 54     m_pHead = NULL;//
 55 }
 56 
 57 CList::~CList()
 58 {//析构函数，C++自动清除堆空间数据
 59 }
 60 CList::CList(CList& p)
 61 {
 62     memcpy(this,&p,sizeof(p));//拷贝构造函数
 63 }
 64 //从尾插入一个数据
 65 void CList::AddTail(DATA data)
 66 {
 67     SNode* p = m_pHead;//防止改变头结点的指针
 68                        //建立新的节点
 69     SNode* p1 = new SNode;
 70     p1->data = data;
 71     p1->pNext = NULL;
 72     if (!p)//如果一开始就是空链表
 73     {
 74         m_pHead = p1;
 75         return;
 76     }
 77     while (p->pNext)//找到最尾部的节点
 78     {
 79         p = p->pNext;
 80     }
 81     p->pNext = p1;
 82 }
 83 //从头插入一个数据
 84 void CList::AddHead(DATA data)
 85 {
 86     SNode* p = new SNode;//申请一个堆空间，8字节
 87     p->data = data;
 88     p->pNext = m_pHead;
 89     m_pHead = p;//把新插入的节点当做头
 90 }
 91 //修改链表节点数据
 92 void CList::Modify(DATA data, DATA newData)
 93 {
 94     SNode* p = m_pHead;
 95     SNode* p1 = new SNode;
 96     if (!p)
 97     {
 98         p1->data = newData;
 99         p1->pNext = NULL;
100         m_pHead = p1;
101         return;
102     }
103     while (p)
104     {
105         if (p->data == data)
106         {
107             p->data = newData;
108         }
109         p = p->pNext;
110     }
111 }
112 //查找某个数据
113 bool CList::Find(DATA data)
114 {
115     SNode* p = m_pHead;
116     while (p)
117     {
118         if (p->data == data) return true;
119         p = p->pNext;
120     }
121     return false;
122 }
123 //删除某个节点
124 bool CList::Delete(DATA data)
125 {
126     SNode* p = m_pHead;//当前节点
127     SNode* p1 = NULL;//下一个节点
128     if (!p) return false;//空链表直接返回
129     if (p->data == data)//删除第一个节点
130     {
131         m_pHead = p->pNext;
132         delete p;
133         return true;
134     }
135     while (p)//删除中间和结尾节点
136     {
137         if (p->data == data)
138         {
139             p1->pNext = p->pNext;
140             delete p;
141             return true;
142         }
143         p1 = p;
144         p = p->pNext;
145     }
146     return false;
147 }
148 //打印全部节点数据
149 void CList::print()
150 {
151     SNode* p = m_pHead;
152     while (p)
153     {
154         cout << p->data << endl;
155         p = p->pNext;
156     }
157 }
158 //交换数据的排序
159 void CList::sortByNum(bool reverse)
160 {
161     SNode* p = m_pHead;
162     SNode* m = NULL;
163     while (p)
164     {
165         m = p->pNext;
166         while (m)
167         {
168             if (p->data > m->data && reverse)
169             {
170                 DATA midData;
171                 midData = p->data;
172                 p->data = m->data;
173                 m->data = midData;
174             }
175             else if (p->data < m->data && !reverse)
176             {
177                 DATA midData;
178                 midData = p->data;
179                 p->data = m->data;
180                 m->data = midData;
181             }
182             m = m->pNext;
183         }
184         p = p->pNext;
185     }
186 }

9.改进版

影醉阏轩窗
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++手写链表（头插法和尾插法）
m0_72470311的博客
04-25 162
/第一步是将p的下一个节点置为空（就是尾节点），然后第二步往后就是将新节点的下一个值指向老节点。//将p的下一个置为空，一直要保证p可能为最后一个节点。//尾指针指向头指针,记住现在还没有节点。//不能调用头指针，调用尾指针。//LNode,*LinkList均为LNode的别名，//先将头节点开辟空间，l->next = p;void out_list(lnode *L)//输出链表。
【原】手写链表（C++）
diaopi5937的博客
12-08 334
1、链表基本概念以及注意事项 a、构造函数与析构函数 b、插入 c、重载运算符[] 2、打印链表 3、删除链表节点 4、链表中倒数第k个节点 5、反转链表 6、合并两个排序的链表 7、两个链表当中的第一个公共节点 【查看之前笔记】 在编写函数之前，请务必注意以下三点： i、输入的指针、各类容器可能是空的 ii、输入的...
学生成绩管理系统（C语言）（链表）
m0_62057925的博客
12-13 3153
学生成绩管理系统
08-FMath 数学函数的基本使用 UE4 C++
ChaoChao66666的博客
10-10 584
设置物体位置中z轴的值随着帧的增加而做正弦变化。
【C++知识点】链表（整理）
weixin_40968046的博客
03-23 235
链表的创建 链表的遍历 链表节点的添加 链表节点的删除 链表的创建 SNode* pNewNode = new SNode(); //创建新节点 cout << "请输入ID和名字" << endl; cin >> pNewNode->nID >> pNewNode->strName; pTailNode->pNext = pNewNode; //把创建的节点接到尾部（接） pTailNode = pNewNode; .
c/c++数据结构-线性表-链表
04-26
数据结构实验线性表当中的链表结构实现，带有详细注释，小白也能看得懂
数据结构-循环链表-C语言实现循环链表功能-数据结构学习
最新发布
05-26
C语言实现的数据结构中的循环链表 包含源码（.c文件），linux环境下编译生成的可执行文件，头文件 用于C语言以及数据结构的学习，熟练对循环链表边界的判定 实现了以下功能： 创建无头循环链表 向循环链表中插入...
数据结构-图书管理系统-链表
11-11
数据结构——图书管理系统
链表_数据结构--链表_
10-01
在windows端利用python实现链表的相关功能
数据结构-链表.pdf
04-15
数据结构-链表 单向链表，双向链表、循环链表等
基于C语言的学生成绩管理系统
m0_70861645的博客
06-10 449
该学生管理系统利用C语言管理学生成绩，高效处理学生信息，主要功能为录入、打印学生信息，对学生信息进行保存和读取，统计学生人数，查找学生信息，修改和删除学生信息等。
C语言图书管理系统
weixin_58371661的博客
07-20 214
临近期末选到个这个题目，直接去世，当时还有结构体和链表老师都没讲。 通了两个宵把它赶出来了。 #include <stdio.h> #include <conio.h> #include <stdlib.h> /*定义一个学生*/ typedef struct _Student { char name[20]; int StuNum; double HigherMathematic; double CollegeEnglish; double Co..
单向链表的反序
wanghh1016的专栏
05-09 478
void ReList() { SNode* p = g_pHead; SNode* q = p->pNext; SNode* g = q->pNext; while(g) { q->pNext = p;                 p = q; q = g; g = g->pNext; } q->pNext = p; g_pHead ->pNext =NULL;
c语言实现酒店管理系统
xienda的博客
11-01 702
if (g_pHead == NULL) //判断该头节点是否为NULL，如果为真，头节点为新创建的节点，如果为假，新节点指向头节点，头节点为新节点。while(fread(&Guest,1,sizeof(Guest),fp)) //读取信息。printf("入住总人数：%d\n",Sumguest());printf("**********功能选择********\n");printf("*****宾馆客房管理系统*****\n");printf("*******宾馆客房管理*******\n");
c语言结构体编辑学生成绩管理,C语言利用结构体数组实现学生成绩管理系统
weixin_30632267的博客
05-17 4379
要求：某班有最多不超过30人(具体人数由键盘输入)参加期末考试，最多不超过6门(具体门数由键盘输入)。定义结构体类型描述学生信息，每个学生信息包括：学号、姓名、多门课的成绩、总成绩和平均成绩。用结构体数组作为函数参数，编程实现如下菜单驱动的学生成绩管理系统。(1) 录入每个学生的学号、姓名和各科考试成绩。(2) 计算每门课程的总分和平均分。(3) 计算每个学生的总分和平均分。(4) 按每个学生的总...
链表作为函数参数传递，Node* head, or Node** pHead(无法把指针变量本身传递给一个函数)?
intfreedom的博客
06-03 4955
链表作为函数参数传递，Node head, or Node* pHead?** 1.C语言，函数形参是值传递，当函数形参是，如果函数内部对这个形参做了修改，在函数返回后，不会改变这个形参的值; 1.1以上这点，很容易明白，但当这个形参本身是一个变量时，就容易产生迷惑，我传的是一个指针，把指针作为函数参数，函数返回时，一定会修改改变一些东西。很容易想到修改的是形参本身(本身是个指针)。 1.2如函数void add(Node* head, int number);如果你想在函数返回时，head被修改，你一定要
数据结构（不带头结点的头插法和尾插法）
qq_40835329的博客
05-28 2650
不带头指针的插入操作比较繁琐，尤其是尾插法，每次需要遍历链表找到尾节点，然后执行插入操作 typedef int DATA; struct SNode { DATA data; SNode *pNext; }; SNode *g_pHead = NULL; /* 不带头结点的尾插法和头插法 */ void AddHead(DATA d) { SNode *p = (SNode *)malloc(sizeof(SNode)); p->data.
东华oj-进阶题第38题-修理牛棚
qq_41409120的博客
03-02 513
38 修理牛棚 作者: xxx时间限制: 1S章节: 一维数组 问题描述 : 在一个暴风雨的夜晚，农民约翰的牛棚的屋顶、门被吹飞了。 好在许多牛正在度假，所以牛棚（牛棚的总数S:1<= S<=200）没有住满。 剩下的牛一个紧挨着另一个被排成一行安置在有屋顶的牛棚来过夜。 所以有些牛棚里有牛，有些没有。 所有的牛棚有相同的宽度，且宽度设为1。 因为有些门遗失，农民约翰需要架起新的木...
C语言实训
mzy1711231996的博客
05-22 750
C语言实训 2020春C语言实训 下面直接上代码， 我用的是Dev-c编译的。 不知道在VS2017上会不会跑起来， Dev-c是肯定可以的。 #include<stdio.h> #include<stdlib.h> #include<string.h> //定义一个学生 typedef struct _Student { char name[20]; int age; int id; int score; } Student; //节点 typedef..
数据结构----单向链表
03-27
单向链表是一种常见的数据结构，它由一系列节点组成，每个节点包含两部分：数据和指向下一个节点的指针。每个节点只知道下一个节点的位置，而不知道前一个节点的位置。 单向链表的特点是插入和删除操作的效率较高，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值