C语言 翁凯老师 数据结构 链表学习（2）

已于 2022-02-23 13:44:48 修改
阅读量880 收藏 5
点赞数
文章标签： 链表 数据结构 c语言
于 2022-02-21 12:23:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62338898/article/details/123042148
版权

遍历list，将链表里的数据输出

#include<stdio.h>
#include<stdlib.h>
#include"node.h"
/* typedef struct _node
{
    int value;
    struct  _node *next;
} Node; */
typedef struct _list
{
    Node* head;
    Node* tail;//永远指向最后一个节点
}List;
void * add(List *plist,int number);// 如果是void add 函数的话就要使用全局变量Node*head 但是，最好不要用全局变量，全局变量是有害的，程序只会是一次性的，只能对这一个链表有作用
void print(List *pList);/* 将链表遍历输出的子函数 */
int main()
{
    List list;
    list.head = list.tail = NULL;
    int number;
    do{
        scanf("%d",&number);
        if(number != 1){
            add(&list,number);
            // head = add(head,number);
        }
    }while (number != -1);
    printf(&list);
    return 0;
}

void * add(List *plist,int number)
{
    //add to linked-list
    Node *p = (Node*)malloc(sizeof(Node));
    p->value = number;
    p->next = NULL;
    //find the last
    Node *last = plist->tail;
    if(last){
        /* while (last->next){//遍历到last->next=NULL为止，保证数据存储在链表的最后一位
            last = last->next;
        }
        // attach */
        last->next = p;
        plist->tail = p;/* 如果前面是plist->head则没有该行 */
    }else{
        plist->head = p;
        plist->tail = p;/* 如果前面是plist->head则没有该行 */
    }
    // return head;
}
/*这就是将链表遍历输出的子函数*/
void print(List *pList)
{
	Node *p;
	for(p = pList->head; p ; p = p->next)//结束的条件是p不存在 //这就是链表的遍历，将链表里存储的东西从头输出到尾。 
	{
		printf("%d\t",p->value);
	}
    printf("\n");
}

对链表内部数据进行查找：输入一个数据，查找链表内有无此数据

#include<stdio.h>
#include<stdlib.h>
#include"node.h"
/* typedef struct _node
{
    int value;
    struct  _node *next;
} Node; */
typedef struct _list
{
    Node* head;
    Node* tail;//永远指向最后一个节点
}List;
void * add(List *plist,int number);// 如果是void add 函数的话就要使用全局变量Node*head 但是，最好不要用全局变量，全局变量是有害的，程序只会是一次性的，只能对这一个链表有作用
void print(List *pList);/* 将链表遍历输出的子函数 */
int main()
{
    List list;
    list.head = list.tail = NULL;
    int number;
    do{
        scanf("%d",&number);
        if(number != 1){
            add(&list,number);
            // head = add(head,number);
        }
    }while (number != -1);
    
    printf(&list);

    //链表的查找
    scanf("%d",&number);
    Node *p;
    int isFound = 0;
    for(p = list.head; p ;p->next){
        if(p->value == number){
            printf("find it\n");
            isFound = 1;
            break;
        }
    }
    if( !isFound ){
        printf("can't find it");
    }

    return 0;
}

void * add(List *plist,int number)
{
    //add to linked-list
    Node *p = (Node*)malloc(sizeof(Node));
    p->value = number;
    p->next = NULL;
    //find the last
    Node *last = plist->tail;
    if(last){
        /* while (last->next){//遍历到last->next=NULL为止，保证数据存储在链表的最后一位
            last = last->next;
        }
        // attach */
        last->next = p;
        plist->tail = p;/* 如果前面是plist->head则没有该行 */
    }else{
        plist->head = p;
        plist->tail = p;/* 如果前面是plist->head则没有该行 */
    }
    // return head;
}
/*这就是将链表遍历输出的子函数*/
void print(List *pList)
{
	Node *p;
	for(p = pList->head; p ; p = p->next)//结束的条件是p不存在 //这就是链表的遍历，将链表里存储的东西从头输出到尾。 
	{
		printf("%d\t",p->value);
	}
    printf("\n");
}

也可以将scanf放在主函数外，封装为另外一个搜索函数

8、删除链表中所储存的一个数。（注意这个程序所以只会删除搜索到的第一个数）

#include<stdio.h>
#include<stdlib.h>
#include"node.h"
/* typedef struct _node
{
    int value;
    struct  _node *next;
} Node; */
typedef struct _list
{
    Node* head;
    Node* tail;//永远指向最后一个节点
}List;
void * add(List *plist,int number);// 如果是void add 函数的话就要使用全局变量Node*head 但是，最好不要用全局变量，全局变量是有害的，程序只会是一次性的，只能对这一个链表有作用
void print(List *pList);/* 将链表遍历输出的子函数 */
int main()
{
    List list;
    list.head = list.tail = NULL;
    int number;
    do{
        scanf("%d",&number);
        if(number != 1){
            add(&list,number);
            // head = add(head,number);
        }
    }while (number != -1);

    printf(&list);

    //链表的查找
    scanf("%d",&number);
    Node *p;
    int isFound = 0;
    for(p = list.head; p ;p->next){
        if(p->value == number){
            printf("find it\n");
            isFound = 1;
            break;
        }
    }
    if( !isFound ){
        printf("can't find it\n");
    }

    Node *q;
    for(q = NULL,p = list.head; p ;q=p,p->next){
        if(p->value == number){
            if( q )
            {
                q->next = p->next;
            }else{
                list.head = p->next;
            }
            free(p);
            break;
        }
    }

    return 0;
}

void * add(List *plist,int number)
{
    //add to linked-list
    Node *p = (Node*)malloc(sizeof(Node));
    p->value = number;
    p->next = NULL;
    //find the last
    Node *last = plist->tail;
    if(last){
        /* while (last->next){//遍历到last->next=NULL为止，保证数据存储在链表的最后一位
            last = last->next;
        }
        // attach */
        last->next = p;
        plist->tail = p;/* 如果前面是plist->head则没有该行 */
    }else{
        plist->head = p;
        plist->tail = p;/* 如果前面是plist->head则没有该行 */
    }
    // return head;
}
/*这就是将链表遍历输出的子函数*/
void print(List *pList)
{
	Node *p;
	for(p = pList->head; p ; p = p->next)//结束的条件是p不存在 //这就是链表的遍历，将链表里存储的东西从头输出到尾。 
	{
		printf("%d\t",p->value);
	}
    printf("\n");
}

若将其封装为查找和删除函数：

#include<stdio.h>
#include<stdlib.h>
#include"node.h"
/* typedef struct _node
{
    int value;
    struct  _node *next;
} Node; */
typedef struct _list
{
    Node* head;
    Node* tail;//永远指向最后一个节点
}List;
void * add(List *plist,int number);// 如果是void add 函数的话就要使用全局变量Node*head 但是，最好不要用全局变量，全局变量是有害的，程序只会是一次性的，只能对这一个链表有作用
void print(List *pList);/* 将链表遍历输出的子函数 */
int main()
{
    List list;
    list.head = list.tail = NULL;
    int number;
    do{
        scanf("%d",&number);
        if(number != 1){
            add(&list,number);
            // head = add(head,number);
        }
    }while (number != -1);

    printf(&list);

    found(&list);//链表的查找

    delete(&list);//链表的删除
    return 0;
}

void * add(List *plist,int number)
{
    //add to linked-list
    Node *p = (Node*)malloc(sizeof(Node));
    p->value = number;
    p->next = NULL;
    //find the last
    Node *last = plist->tail;
    if(last){
        /* while (last->next){//遍历到last->next=NULL为止，保证数据存储在链表的最后一位
            last = last->next;
        }
        // attach */
        last->next = p;
        plist->tail = p;/* 如果前面是plist->head则没有该行 */
    }else{
        plist->head = p;
        plist->tail = p;/* 如果前面是plist->head则没有该行 */
    }
    // return head;
}
/*这就是将链表遍历输出的子函数*/
void print(List *pList)
{
	Node *p;
	for(p = pList->head; p ; p = p->next)//结束的条件是p不存在 //这就是链表的遍历，将链表里存储的东西从头输出到尾。 
	{
		printf("%d\t",p->value);
	}
    printf("\n");
} 

void found(List *flist){
    int number = 0;
    scanf("%d",&number);
    Node *p;
    int isFound = 0;
    for(p = flist->head; p ;p->next){
        if(p->value == number){
            printf("find it\n");
            isFound = 1;
            break;
        }
    }
    if( !isFound ){
        printf("can't find it\n");
    }

}

void delete(List *flist)
{
    int number;
    scanf("%d",&number);
    Node *p,*q;
    for(q = NULL,p = flist->head;p;q=p,p=p->next){
        if(p->value == number){
            if(q){//保证q是可操作的而不是NULL，如果没有这个if，当所要删除的数是在第一个位置时，将会出现错误。 
                q->next = p->next;
            }else{
                flist->head = p->next;
            }
            free(p);
            break;
        }
    }
}

缺点是无法在删除之后输出链表，需要重新输出一下

链表的释放和清除

开辟了一片存储链表的空间，在最后要把这片空间给释放掉

#include<stdio.h>
#include<stdlib.h>
#include"node.h"
/* typedef struct _node
{
    int value;
    struct  _node *next;
} Node; */
typedef struct _list
{
    Node* head;
    Node* tail;//永远指向最后一个节点
}List;
void * add(List *plist,int number);// 如果是void add 函数的话就要使用全局变量Node*head 但是，最好不要用全局变量，全局变量是有害的，程序只会是一次性的，只能对这一个链表有作用
void print(List *pList);/* 将链表遍历输出的子函数 */
void found(List *flist);/* 链表元素的查找子函数 */
void delete(List *flist);/* 链表元素的删除子函数 */
void Free(List *flist);
int main()
{
    List list;
    list.head = list.tail = NULL;
    int number;
    do{
        scanf("%d",&number);
        if(number != 1){
            add(&list,number);
            // head = add(head,number);
        }
    }while (number != -1);

    print(&list);//将链表遍历输出

    found(&list);//链表的查找

    delete(&list);//链表元素的删除

    Free(&list);

    return 0;
}

void * add(List *plist,int number)
{
    //add to linked-list
    Node *p = (Node*)malloc(sizeof(Node));
    p->value = number;
    p->next = NULL;
    //find the last
    Node *last = plist->tail;
    if(last){
        /* while (last->next){//遍历到last->next=NULL为止，保证数据存储在链表的最后一位
            last = last->next;
        }
        // attach */
        last->next = p;
        plist->tail = p;/* 如果前面是plist->head则没有该行 */
    }else{
        plist->head = p;
        plist->tail = p;/* 如果前面是plist->head则没有该行 */
    }
    // return head;
}
/*这就是将链表遍历输出的子函数*/
void print(List *pList)
{
	Node *p;
	for(p = pList->head; p ; p = p->next)//结束的条件是p不存在 //这就是链表的遍历，将链表里存储的东西从头输出到尾。 
	{
		printf("%d\t",p->value);
	}
    printf("\n");
} 

void found(List *flist){
    int number = 0;
    scanf("%d",&number);
    Node *p;
    int isFound = 0;
    for(p = flist->head; p ;p->next){
        if(p->value == number){
            printf("find it\n");
            isFound = 1;
            break;
        }
    }
    if( !isFound ){
        printf("can't find it\n");
    }

}

void delete(List *flist)
{
    int number;
    scanf("%d",&number);
    Node *p,*q;
    for(q = NULL,p = flist->head;p;q=p,p=p->next){
        if(p->value == number){
            if(q){//保证q是可操作的而不是NULL，如果没有这个if，当所要删除的数是在第一个位置时，将会出现错误。 
                q->next = p->next;
            }else{
                flist->head = p->next;
            }
            free(p);
            break;
        }
    }
}

void Free(List *flist){
    Node *p,*q;
    for(p = flist->head; p;p = q){
        q = p->next;
        free(p);
    }
}

即上述的Free函数，也可以直接卸载主函数的最后部分。

翁凯C语言笔记（枚举----链表完结篇）
m0_72900498的博客
12-08 917
翁凯C语言笔记（枚举----链表完结篇）
浙大版《C语言程序设计（第3版）》 - 翁恺 - 学习笔记
热门推荐
Henry1991back的博客
03-30 3万+
2.1.1.2 计算机和编程语言：计算机的思维方式 程序的执行 解释：借助一个程序，那个程序能试图理解你的程序，然后按照你的要求执行。 编译：借助一个程序，就像一个翻译，把你的程序翻译成计算机真正能懂的语言——机器语言——写的程序，然后，这个机器语言写的程序就能直接执行了。 11.2.1.3 变量：变量赋值与初始化 如果变量没有初始化，就直接拿到右边去用，会出现什么呢？ 得到...
中国大学MOOC-翁恺-C语言程序习题第三周
Phenixfate的专栏
01-19 3515
03-0. 超速判断(10) 模拟交通警察的雷达测速仪。输入汽车速度，如果速度超出60 mph，则显示“Speeding”，否则显示“OK”。 输入格式： 输入在一行中给出1个不超过500的非负整数，即雷达测到的车速。 输出格式： 在一行中输出测速仪显示结果，格式为：“Speed: V - S”，其中V是车速，S或者是Speeding、或者是OK。 输入样例1： 40 输出样
C语言 翁凯老师 数据结构 链表学习（1）
weixin_62338898的博客
02-20 682
大一学生的链表学习记录
数据结构~新学期寄予~你怎么知道我被翁凯虐惨了
moomooi的专栏
08-23 3498
新学期还有10天就开始了，你准备好了吗？^_^ 如果你学过翁恺老师的“C语言程序设计”并且被他的期末考试虐到心塞，“陈越姥姥”跟你握个手 —— 咱们是同学啊！（刚学完C就教数据结构我也是醉了……）如果你读过高等教育出版社出的《C语言程序设计（第2版）》这本教材，何钦铭老师跟你握个手 —— 写这本书不容易，欢迎多提意见，挑错有奖啊！话说第3版刚出来，要不要去看看…… ^_^ 神马
C语言学习笔记（浙大翁恺版）第十一周 结构（2）
m0_56661338的博客
08-01 547
想记录抽象物体的一连串数据，我们不想一个一个定义，此时就可以用到C语言的结构类型一个结构就是一个复合类型，其中可以包含许多不同类型的成员变量。
【看课必备】MOOC C语言进阶——翁恺 结构类型笔记
weixin_62633072的博客
12-05 1259
MOOC 翁恺的C语言程序设计进阶笔记，快进来看一看吧！
C语言学习笔记（浙大翁恺版）第十四周 链表
m0_56661338的博客
08-07 801
解决方法：设立函数库，几个函数分别实现不同功能。
C语言学习-翁凯（目录总章）
qq_43104872的博客
11-05 7209
C语言学习 本内容仅为个人看视频记录的随手笔记，部分内容可能不全面，比如第十四章内容并未单独整理出来一章，可以作为学习翁凯老师视频之后进行复习巩固使用。 C语言学习-翁凯（第二章） C语言学习-翁凯（第三章） C语言学习-翁凯（第四章） C语言学习-翁凯（第五章） C语言学习-翁凯（第六章） C语言学习-翁凯（第七章） C语言学习-翁凯（第八章） C语言学习-翁凯（第九章） C语言学习-翁凯（第十章） C语言学习-翁凯（第十一章） C语言学习-翁凯（第十二章） C语言学习-翁凯（第十三章） 第二章 2.1
C语言程序设计进阶-视频教程（完）.rar
02-08
7. **高效算法与数据结构**：结合C语言特点，讲解常见数据结构（如链表、树、图等）的实现和算法（如排序、查找）的应用。 8. **错误处理与调试技巧**：介绍如何使用调试工具，理解并处理运行时错误，编写健壮的...
浙江大学-翁凯-C++课件+源代码（10）
06-05
浙江大学计算机系翁凯老师面向对象编程语言（oop）课件，采用英文原版教材《thinking in c++》，课件+源代码
单链表_翁恺
Rrrrya
11-13 345
还没搞懂的东西，果然是菜鸡 #include <iostream> #include <cstdio> #include <stdlib.h> using namespace std; typedef struct _node{ int value; struct _node *next; } Node; typedef struct _l...
链表复习——《C语言程序设计》浙江大学mooc翁恺
weixin_45041379的博客
05-21 663
链表——《C语言程序设计》浙江大学mooc翁恺理解最初的链表**一、理解最初的链表****二、 链表的函数**链表的基本操作 理解最初的链表 非常啰嗦的一篇笔记 一开始的代码： 一、理解最初的链表 定义节点： #include <stdio.h> #include <stdlib.h> typedef struct _node{ int data; struct _node *next; }Node; 注： 不可以这么写： 1. typedef struct _node{
C语言学习-翁凯（第十一章笔记）
qq_43104872的博客
10-15 806
C语言学习-翁凯（第十一章笔记） C语言第十一章 11.1.1 枚举 常量符号化 #include<stdio.h> const int red=0; const int yellow=1; const int green=2; int main(int argc,char const *argv[]) { int color=-1; char *colorName=NULL; printf("请输入你喜欢的颜色的代码："); scanf("%d",
数据结构MOOC|队列
笔记本
05-15 309
课程内容来自：http://www.icourse163.org/learn/ZJU-93001?tid=1002654021#/learn/content?type=detail&amp;id=1003620979队列：受限的线性表，一端插入（front），一端删除（rear），即FIFO。操作集：长度MaxSize的队列Q，队列元素item是ElementType类型。涉及操作：1.Queue...
简单单链表的实现—C语言
Aidan Dai
11-21 656
本例简单实现了单链表，并附上调试（VS2013）过程，有助于深刻理解单链表 链表是一种常见的重要的数据结构，它是动态的进行内存存储分配的一种结构。用数组存放数据时，必须事先定义固定的长度（即元素个数），但是事先难以确定有多少个元素时，则必须把数组定义的足够大，以保证成功。无疑，这会造成内存浪费，然而，链表则没有这种缺点，它可以根据需要，动态开辟内存单元。链表中的各个元素在内存中是可以不是连续存放
C语言的学习日志2.19
X2573671311的博客
02-20 1984
链表： 链表是一种基础数据结构，采用动态分配储存单元的方式进行储存分配。结构体指针在这上面得到了充分的运用。换句话说，链表是一个功能极为强大的数组，他可以在节点中定义多种数据类型，还可以根据需要随意增添，删除，插入节点。 创建链表: 首先，要先构造一个结构体，构造结构体一般都用typedef函数，这样方便结构体变量的命名。 typedef struct _node{ int value; struct _node *next; }Node; ...
c语言链表
weixin_46919419的博客
01-13 270
目录 c语言暂时更新完毕 链表实现 链表改进及其函数 补充知识volatile关键字 链表实现 #include <stdio.h> #include "node.h" #include <stdlib.h> //node头文件内容： //typedef struct _node{ // int value; // struct _node *next; //}Node; typedef struct test{ int a; }Test; .
链表
hongmeipopo73的博客
01-29 279
#include #include typedef struct node{ int value; struct node *next; }Node; int main(){ int number; Node *head=NULL; do{ scanf("%d",&number); if(number!=-1){//add to linked-list Node *p=(N
tic-tac-toe游戏c语言翁凯
最新发布
10-25
Tic Tac Toe，也称为井字棋，是一个经典的两人对战策略游戏，玩家轮流在3x3的网格上放置他们的标记（通常是X和O）。在C语言中，翁凯版本可能会涉及到二维数组、循环控制、条件判断以及用户输入处理。 以下是创建一个简单的Tic Tac Toe游戏的基本步骤： 1. 定义一个3x3的二维字符数组，代表游戏板。 2. 创建一个函数`drawBoard()`来显示当前的游戏状态。 3. `playGame()`函数负责游戏的主要流程，包括接收玩家输入，更新游戏板，并检查是否获胜或平局。 4. 使用嵌套循环遍历游戏板，让两个玩家交替操作。 5. 添加条件判断来检测胜利（行、列、对角线上的三个同色格子），并提示赢家。 6. 如果没有赢家并且所有位置都被填满，判定为平局。 下面是一个非常简化的C语言Tic Tac Toe游戏示例（仅包含核心部分，不包含完整的源码）： ```c #include <stdio.h> #define SIZE 3 // 检查某一行/列/对角线上是否有连续的符号 int checkWin(char board[SIZE][SIZE], char symbol) { for (int i = 0; i < SIZE; ++i) { if (board[i][0] == symbol && board[i][1] == symbol && board[i][2] == symbol) return 1; if (board[0][i] == symbol && board[1][i] == symbol && board[2][i] == symbol) return 1; if (board[0][0] == symbol && board[1][1] == symbol && board[2][2] == symbol) return 1; if (board[0][2] == symbol && board[1][1] == symbol && board[2][0] == symbol) return 1; } return 0; } void drawBoard(char board[SIZE][SIZE]) { // 打印游戏板 //... } int main() { char board[SIZE][SIZE] = { {' ' } }; int player = 'X'; while (true) { drawBoard(board); printf("Player %c's turn: ", player); int row, col; scanf("%d%d", &row, &col); // 输入坐标 if (board[row][col] != ' ') continue; board[row][col] = player; if (checkWin(board, player)) { printf("Player %c wins!\n", player); break; } // 切换玩家 player = (player == 'X') ? 'O' : 'X'; } return 0; } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

某石油中专在读坐牢2021级本科生

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值