有大佬让我重新把整个C语言学一遍

         当初在学校的时候，开的C语言的课，基本也就只是学一学if else for这些加上一些思维逻辑方面的基础的东西，现在自学单片机，一套32的入门视频下来，跟着单片机学的C，整套视频里边关于C的知识也都能看懂.指针结构体什么的还是能看简单用一用.
         结果这两天去面试，大佬给我一份基本纯C的笔试题，结果好像只能做出不到一半的题目...
         他让我回去重新把整套C学一遍直到自己能够调试到单链表的增、删、改、写 为止，有大佬有推荐哪个视频嘛！

可供参考

C语言学习资料推荐
http://www.51hei.com/bbs/dpj-198731-1.html

会结构和指针，就应该会操作单链表，不用老是浪费时间看视频，太慢了，顶多看看例程，关键是自己在脑子里多想，自己给自己出题。链表操作，无论单双还是树都是基本操作，没有技术含量。

买本C语言的书。结合视频巩固知识。

直接去b站找吧，c语言教程多的是，建议直接看书，边学边做，两三周就差不多

可以去mooc上看看浙江大学的c语言基础课程，单链表的增删查改涉及到一些数据结构的知识，可以去看一下王道考研数据结构

我给你来个程序试试
单链表的增、删

1. /*
   
2. 单链表的增、删
   
3. */
   
4. #include<stdlib.h>
   
5. #include <stdio.h>
   
6. 
   
7. void create();
   
8. void display();
   
9. void insert_begin();
   
10. void insert_end();
    
11. void insert_pos();
    
12. void delete_begin();
    
13. void delete_end();
    
14. void delete_pos();
    
15. 
    
16. 
    
17. struct node
    
18. {
    
19.         int info;
    
20.         struct node *next;
    
21. };
    
22. struct node *start=NULL;
    
23. int main()     
    
24. {
    
25.         int choice;
    
26.         while(1){
    
27.                
    
28.                 printf("n                MENU                             n");
    
29.                 printf("n 1.Create     n");
    
30.                 printf("n 2.Display    n");
    
31.                 printf("n 3.Insert at the beginning    n");
    
32.                 printf("n 4.Insert at the end  n");
    
33.                 printf("n 5.Insert at specified position       n");
    
34.                 printf("n 6.Delete from beginning      n");
    
35.                 printf("n 7.Delete from the end        n");
    
36.                 printf("n 8.Delete from specified position     n");
    
37.                 printf("n 9.Exit       n");
    
38.                 printf("n--------------------------------------n");
    
39.                 printf("Enter your choice:t");
    
40.                 scanf("%d",&choice);
    
41.                 switch(choice)
    
42.                 {
    
43.                 case 1:
    
44.                         create();
    
45.                         break;
    
46.                 case 2:
    
47.                         display();
    
48.                         break;
    
49.                 case 3:
    
50.                         insert_begin();
    
51.                         break;
    
52.                 case 4:
    
53.                         insert_end();
    
54.                         break;
    
55.                 case 5:
    
56.                         insert_pos();
    
57.                         break;
    
58.                 case 6:
    
59.                         delete_begin();
    
60.                         break;
    
61.                 case 7:
    
62.                         delete_end();
    
63.                         break;
    
64.                 case 8:
    
65.                         delete_pos();
    
66.                         break;
    
67.                        
    
68.                 case 9:
    
69.                         exit(0);
    
70.                         break;
    
71.                        
    
72.                 default:
    
73.                         printf("n Wrong Choice:n");
    
74.                         break;
    
75.                 }
    
76.         }
    
77.         return 0;
    
78. }
    
79. void create()
    
80. {
    
81.         struct node *temp,*ptr;
    
82.         temp=(struct node *)malloc(sizeof(struct node));
    
83.         if(temp==NULL)
    
84.         {
    
85.                 printf("nOut of Memory Space:n");
    
86.                 exit(0);
    
87.         }
    
88.         printf("nEnter the data value for the node:t");
    
89.         scanf("%d",&temp->info);
    
90.         temp->next=NULL;
    
91.         if(start==NULL)
    
92.         {
    
93.                 start=temp;
    
94.         }
    
95.         else
    
96.         {
    
97.                 ptr=start;
    
98.                 while(ptr->next!=NULL)
    
99.                 {
    
100.                         ptr=ptr->next;
     
101.                 }
     
102.                 ptr->next=temp;
     
103.         }
     
104. }
     
105. void display()
     
106. {
     
107.         struct node *ptr;
     
108.         if(start==NULL)
     
109.         {
     
110.                 printf("nList is empty:n");
     
111.                 return;
     
112.         }
     
113.         else
     
114.         {
     
115.                 ptr=start;
     
116.                 printf("nThe List elements are:n");
     
117.                 while(ptr!=NULL)
     
118.                 {
     
119.                         printf("%dt",ptr->info );
     
120.                         ptr=ptr->next ;
     
121.                 }
     
122.         }
     
123. }
     
124. void insert_begin()
     
125. {
     
126.         struct node *temp;
     
127.         temp=(struct node *)malloc(sizeof(struct node));
     
128.         if(temp==NULL)
     
129.         {
     
130.                 printf("nOut of Memory Space:n");
     
131.                 return;
     
132.         }
     
133.         printf("nEnter the data value for the node:t" );
     
134.         scanf("%d",&temp->info);
     
135.         temp->next =NULL;
     
136.         if(start==NULL)
     
137.         {
     
138.                 start=temp;
     
139.         }
     
140.         else
     
141.         {
     
142.                 temp->next=start;
     
143.                 start=temp;
     
144.         }
     
145. }
     
146. void insert_end()
     
147. {
     
148.         struct node *temp,*ptr;
     
149.         temp=(struct node *)malloc(sizeof(struct node));
     
150.         if(temp==NULL)
     
151.         {
     
152.                 printf("nOut of Memory Space:n");
     
153.                 return;
     
154.         }
     
155.         printf("nEnter the data value for the node:t" );
     
156.         scanf("%d",&temp->info );
     
157.         temp->next =NULL;
     
158.         if(start==NULL)
     
159.         {
     
160.                 start=temp;
     
161.         }
     
162.         else
     
163.         {
     
164.                 ptr=start;
     
165.                 while(ptr->next !=NULL)
     
166.                 {
     
167.                         ptr=ptr->next ;
     
168.                 }
     
169.                 ptr->next =temp;
     
170.         }
     
171. }
     
172. void insert_pos()
     
173. {
     
174.         struct node *ptr,*temp;
     
175.         int i,pos;
     
176.         temp=(struct node *)malloc(sizeof(struct node));
     
177.         if(temp==NULL)
     
178.         {
     
179.                 printf("nOut of Memory Space:n");
     
180.                 return;
     
181.         }
     
182.         printf("nEnter the position for the new node to be inserted:t");
     
183.         scanf("%d",&pos);
     
184.         printf("nEnter the data value of the node:t");
     
185.         scanf("%d",&temp->info) ;
     
186. 
     
187.         temp->next=NULL;
     
188.         if(pos==0)
     
189.         {
     
190.                 temp->next=start;
     
191.                 start=temp;
     
192.         }
     
193.         else
     
194.         {
     
195.                 for(i=0,ptr=start;i<pos-1;i++) { ptr=ptr->next;
     
196.                         if(ptr==NULL)
     
197.                         {
     
198.                                 printf("nPosition not found:[Handle with care]n");
     
199.                                 return;
     
200.                         }
     
201.                 }
     
202.                 temp->next =ptr->next ;
     
203.                 ptr->next=temp;
     
204.         }
     
205. }
     
206. void delete_begin()
     
207. {
     
208.         struct node *ptr;
     
209.         if(ptr==NULL)
     
210.         {
     
211.                 printf("nList is Empty:n");
     
212.                 return;
     
213.         }
     
214.         else
     
215.         {
     
216.                 ptr=start;
     
217.                 start=start->next ;
     
218.                 printf("nThe deleted element is :%dt",ptr->info);
     
219.                 free(ptr);
     
220.         }
     
221. }
     
222. void delete_end()
     
223. {
     
224.         struct node *temp,*ptr;
     
225.         if(start==NULL)
     
226.         {
     
227.                 printf("nList is Empty:");
     
228.                 exit(0);
     
229.         }
     
230.         else if(start->next ==NULL)
     
231.         {
     
232.                 ptr=start;
     
233.                 start=NULL;
     
234.                 printf("nThe deleted element is:%dt",ptr->info);
     
235.                 free(ptr);
     
236.         }
     
237.         else
     
238.         {
     
239.                 ptr=start;
     
240.                 while(ptr->next!=NULL)
     
241.                 {
     
242.                         temp=ptr;
     
243.                         ptr=ptr->next;
     
244.                 }
     
245.                 temp->next=NULL;
     
246.                 printf("nThe deleted element is:%dt",ptr->info);
     
247.                 free(ptr);
     
248.         }
     
249. }
     
250. void delete_pos()
     
251. {
     
252.         int i,pos;
     
253.         struct node *temp,*ptr;
     
254.         if(start==NULL)
     
255.         {
     
256.                 printf("nThe List is Empty:n");
     
257.                 exit(0);
     
258.         }
     
259.         else
     
260.         {
     
261.                 printf("nEnter the position of the node to be deleted:t");
     
262.                 scanf("%d",&pos);
     
263.                 if(pos==0)
     
264.                 {
     
265.                         ptr=start;
     
266.                         start=start->next ;
     
267.                         printf("nThe deleted element is:%dt",ptr->info  );
     
268.                         free(ptr);
     
269.                 }
     
270.                 else
     
271.                 {
     
272.                         ptr=start;
     
273.                         for(i=0;i<pos;i++) { temp=ptr; ptr=ptr->next ;
     
274.                                 if(ptr==NULL)
     
275.                                 {
     
276.                                         printf("nPosition not Found:n");
     
277.                                         return;
     
278.                                 }
     
279.                         }
     
280.                         temp->next =ptr->next ;
     
281.                         printf("nThe deleted element is:%dt",ptr->info );
     
282.                         free(ptr);
     
283.                 }
     
284.         }
     
285. }
     

复制代码

我觉得学C看书蛮快的，我觉得视频比较拖，耽误时间，楼主已经有基础来了。看书完全可以胜任

看大佬的意思不是说你c语言不行，而是没看过《数据结构》这种编程基础知识。

推荐The_C_Programming_Language这本书，有电子中文版的

慕课里就有

要快。我觉得边做题边学更好。去乐扣刷题。不会的就研究。有点基础的话不怕

看书加看视频 效果更好

c的primer 书就可以了。C语言有技术，再重新学一下也很快 。但不重学的话，知识不全。其实有针对性的，学不会的就好

angmall 发表于 2021-6-2 08:28
我给你来个程序试试
单链表的增、删

哈哈，半年后才重新回来看帖子...粗略的看了一下，虽然这半年也没怎么写程序，但是结构体指针这些都还算能接受了...主要还是需要多看看别人代码...

sdarling 发表于 2021-12-23 04:09
哈哈，半年后才重新回来看帖子...粗略的看了一下，虽然这半年也没怎么写程序，但是结构体指针这些都还算 ...

你以为你懂了，其实没有，程序是写出来的不是看出来的

对源程序做一些修改，看自己能否再独立写出完整的程序

你去慕课上看各大高校的课

会结构和指针，就应该会操作单链表，基本上哔哩哔哩可以自学

都会指针了，好强。  我写单片机逻辑业务简单的 ，从来不用指针。  看多一个多级菜单程序用过指针。看了好久才明白怎么回事。

数据结构而已，本质还是结构体与指针

直接去B站找郝斌C语言和数据结构，你现在是ifelseswitch， 那么你缺的是精华部分->指针，内存，数据结构的链表队列，算法里面的排序、滤波，代码规范、再来点实际应用的PID,wifi这些就基本就差不多

建议看C Primer，这本书对学习C语言新手有帮助的。而且，常用的代码函数会在这本书上找，还可以当作查字典。

买书，买学习版，看例程，自己开发多实操练练就上手快。