链表的实现

已于 2023-10-18 21:18:14 修改
阅读量157 收藏
点赞数
分类专栏： # 数据结构 文章标签： 链表 c语言 数据结构
于 2023-10-15 16:05:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57254953/article/details/133843749
版权

链表分为单链表、双链表和循环链表，这些理论知识在笔记中自然写了，这里我只写出其中的实现：

单链表的实现（c语言实现）

#include <stdio.h>
#include <stdlib.h>
#include <string.h>	

typedef struct Book {
	char bookname[20];
	char author[10];
}Book;

typedef struct Node {
	Book book;
	struct Node *next;
}Node,*LinkList;

//初始化链表 
void initChainedTable(Node **L){    //ok
	*L=(LinkList)malloc(sizeof(Node));
	(*L)->next=NULL;
}
//尾结点插入 
Node* putNodeByTail(Book book,Node *r){   //ok
	Node *node=(Node*)malloc(sizeof(Node));
	node->book= book;
	node->next=NULL;
	r->next=node;
	return node;
}
//首节点插入
void putNodeByHead(Book book,LinkList L){   //ok
	Node *node=(Node*)malloc(sizeof(Node));
	node->book=book;
	node->next=L->next;
	L->next=node;
} 
//删除其中一个结点
void deleteNode(int i,LinkList L){   //ok
	Node *node=L->next;
	int counter=1;
	if (i == 1) {
        if (node != NULL) {
            L->next = node->next;
            free(node);
        } else {
            printf("List is empty, cannot delete.\n");
        }
        return;
    }

	while(node&&counter<(i-1)){
		node=node->next;
		++counter;
	}
	if(!node||i<=0){
		printf("index is out of bound \n");
	}else{
		Node* delnode = node->next;
        if (delnode) {
            node->next = delnode->next;
            free(delnode);
        } else {
            printf("Node at index %d does not exist\n", i);
        }
	}
	
}
//向链表中插入元素
void insertNode(Book book,int i,LinkList L){   //ok
	Node *newnode=(Node*)malloc(sizeof(Node));
	Node *node=L->next;
	newnode->book=book;
	int count=1;
	while(node&&count<(i-1)){
		node=node->next;
		++count;
	}
	if(!node||i<=0){
		printf("index is out of bound\n");
	}else{
		newnode->next=node->next;
		node->next=newnode;	
	}
	
} 
//判断链表是否为空
int isEmpty(LinkList L){  //ok
	return L->next==NULL?1:0;
} 

//获取第i个结点 
Node*  getNode(int i,LinkList L){  //ok
	Node* node=L->next;
	int count=1;
	while(node&&count<i){
		node=node->next;
		++count;
	}
	if(node&&i>0) return node;
	printf("index is out of bound\n"); 
} 
//通过值获取到它的位置
int getIndex(Book book,LinkList L){  //ok
	Node* node=L->next;
	int count=1;
	while(node&&strcmp(node->book.author,book.author)&&strcmp(node->book.bookname,book.bookname)){
		node=node->next;
		++count;
	}
	if(node) return -1;
	return count;
} 
//打印链表中的数据 
void printNodeData(LinkList L){    //ok
	Node *node=L->next;
	while(node){
		printf("bookname:%s;author:%s\n",node->book.bookname,node->book.author);
		node=node->next;
	}
	if(!node) printf("你所给的是个空链表！\n"); 
}
//释放一个链表
void freeChainedTable(LinkList L){ 
	Node *p=L->next;
	Node *q;
	while(p){  
		q=p->next;
		free(p);
		p=q; 
	}
	printf("清除完成！\n");
	L->next=NULL;
}

int main(){
	LinkList L;
	initChainedTable(&L);
	Book book1={"java","zhangyu"};
	Book book2={"php","zhang"};
	Book book3={"c#","nanchengyu"};
	putNodeByHead(book1,L);
	putNodeByHead(book2,L);
	putNodeByHead(book3,L);
	Book book4={"java","zhang"};
	freeChainedTable(L);
	printNodeData(L);
	system("pause");
	return 0;
}
单链表的重要操作实现图解

单链表的实现（java语言实现）

package linearList;

/*
* 带头节点单链表的实现
* */
class Data{
    String username;
    int age;

    public Data(String username, int age) {
        this.username = username;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Data{" +
                "username='" + username + '\'' +
                ", age=" + age +
                '}';
    }
}
class Node{

    Data data;
    private Node next;

    public Node(Data data, Node next) {
        this.data = data;
        this.next = next;
    }

    public Node() {
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }
}
public class LinkList {
    private Node node;
    private Node cruNode;
    //初始化一个链表
    public void init(){
        Node node=new Node();
         this.node=node;
         this.cruNode=node;
    }
    //尾结点插入
    public LinkList putNodeByTail(String username,int age){
        Data data = new Data(username,age);
        Node newNode=new Node(data,null);
        cruNode.setNext(newNode);
        cruNode=newNode;
        return this;
    }
    //头节点插入
    public void putNodeByHead(String username,int age){
        Data data = new Data(username,age);
        Node newNode=new Node(data,null);
        if (node!=null){
            Node tmp=node.getNext();
            newNode.setNext(tmp);
            node.setNext(newNode);
        }
    }
    //删除其中一个结点
    public void deleteNode(int i){
        if (i==1){
            Node next = node.getNext().getNext();
            node.setNext(next);
        }else {
            int count=2;
            Node froNode=node.getNext();
            Node preNode=node.getNext().getNext();
            while (preNode!=null){
                if (count==i){
                    froNode.setNext(preNode.getNext());
                }
                froNode=preNode;
                preNode=preNode.getNext();
                ++count;
            }
        }
    }
    //向链表中插入元素
    public void insertNode(int i,String username,int age){
        Data data = new Data(username, age);
        Node newNode = new Node(data, null);
        int count=1;
        Node preNode=node.getNext();
        Node froNode=null;
        while (preNode!=null){
            if (count==i){
                froNode.setNext(newNode);
                newNode.setNext(preNode);
            }
            froNode=preNode;
            preNode=preNode.getNext();
            ++count;
        }
    }
    //判断链表是否为空
    public boolean isEmpty(){
        return node.getNext()!=null?false:true;
    }
    //获取第i个结点
    public Node getNode(int i){
        Node countNode=node.getNext();
        int count=1;
        while (countNode!=null){
            if (count==i){
                return countNode;
            }
            countNode=countNode.getNext();
            ++count;
        }
        if (countNode==null) return null;
        return countNode;
    }

    //打印链表中的数据
    public void printNodeData(){
        Node preNode=node.getNext();
        while (preNode!=null){
            System.out.println(preNode.data.toString());
            preNode=preNode.getNext();
        }
    }
}
class LinkListTest {
    public static void main(String[] args) {
        LinkList linkList = new LinkList();
        linkList.init();
        linkList.putNodeByTail("zhangshan",10).putNodeByTail("lishi",20)
                .putNodeByTail("wangwu",21).putNodeByHead("qianmian",70);
        System.out.println(linkList.isEmpty());
        linkList.printNodeData();
        linkList.deleteNode(2);
        System.out.println("--------------");
        linkList.printNodeData();
        System.out.println("--------------");
        linkList.insertNode(2,"222",11);
        linkList.printNodeData();
    }
}

双链表的实现(c语言实现)

#include <stdio.h>
#include <stdlib.h>

//这个源文件描述的是不循环双向链表

typedef struct Book {
	char bookname[20];
	char author[10];
}Book;
typedef struct doLinkList{
	Book book;
	struct doLinkList *prior,*next;
	struct doLinkList *ele;
}Node,*LinkList;
//初始化链表 
void initDoLinkList(LinkList *L){
	*L=(LinkList)malloc(sizeof(Node));
	(*L)->prior=NULL;
	(*L)->next=NULL;
	(*L)->ele=*L;
}
//向链表添加结点 
void putNode(Book book,Node *listNode){
	Node *node=(Node*)malloc(sizeof(Node));
	node->book=book;
	listNode->ele->next=node;
	node->prior=listNode->ele;
	node->next=NULL;
	listNode->ele=node;
}
//打印结点数据 
void printNodeData(LinkList list){
	if(!list->next){
		printf("你所给的是个空链表！\n"); 
		return;	
	} 
	Node *node=list->next;
	while(node){
		printf("bookname:%s;author:%s\n",node->book.bookname,node->book.author);
		node=node->next;
	}
}
//查找链表数据 
Node* getNode(int i,LinkList list){
	Node *node=list->next;
	int counter=1;
	while(node&&counter!=i&&i>0){
		node=node->next;
		++counter;
	}
	if(i<0||i>counter){
		printf("索引超出范围！\n");
		return NULL;
	}
	return node;
}

//删除链表结点
void delNode(int i,LinkList list){
	Node *p;
	if(!(p=getNode(i,list))){
		printf("并没有找到该节点！\n");
	}else if(p->next){
		p->prior->next=p->next;
		p->next->prior=p->prior;
	}else{
		p->prior->next=NULL;
	}
	free(p);
	
} 

//向双向节点中插入结点（末尾节点不可以插入） 
void insertNode(int i,Book book,LinkList list){
	Node *p;
	Node *node=(Node*)malloc(sizeof(Node));
	node->book=book;
	if(p=getNode(i,list)){
		p->prior->next=node;
		node->prior=p->prior;
		node->next=p;
		p->prior=node;
	}else {
		printf("插入失败！\n");
	}
} 

int main(){
	LinkList L;
	initDoLinkList(&L);
	Book book1={"java","zhangyu"};
	Book book2={"php","zhang"};
	Book book3={"c#","nan"};
	putNode(book1,L);
	putNode(book2,L);
//	putNode(book3,L);
	insertNode(2,book3,L);
	printNodeData(L);
	system("pause");
	return 0;
}
双链表的重要操作实现图解

双链表的实现(java语言实现)

package linearList;

import java.awt.print.Book;

/*
*带头节点的双链表实现
* */
class User{
    String username;
    int age;

    public User(String username, int age) {
        this.username = username;
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", age=" + age +
                '}';
    }
}
class doNode{
    User data;
    private doNode next;
    private doNode pre;

    public doNode(User user, doNode next,doNode pre) {
        this.data = user;
        this.next = next;
        this.pre=pre;
    }

    public doNode() {
    }

    public doNode getNext() {
        return next;
    }

    public doNode getPre() {
        return pre;
    }

    public void setNext(doNode next) {
        this.next = next;
    }
    public void setPre(doNode pre){
        this.pre=pre;
    }
}

public class doLinkList {
    private doNode node;
    private doNode cruNode;
    //初始化链表
    void initDoLinkList(){
        doNode doNode = new doNode();
        node=doNode;
        cruNode=doNode;
    }
    //向链表添加结点
    doLinkList putNode(String username,int age){
        User user = new User(username, age);
        doNode doNode = new doNode(user,null,cruNode);
        cruNode.setNext(doNode);
        cruNode=doNode;
        return this;
    }
    //打印结点数据
    void printNodeData(){
        if (node.getNext()==null){
            System.out.println("链表为空");
            return;
        }else{
            doNode NodePointer=node.getNext();
            while (NodePointer!=null){
                User user=NodePointer.data;
                System.out.println(user.toString());
                NodePointer=NodePointer.getNext();
            }
        }
    }
    //删除链表结点
    void delNode(int i){
        doNode node=this.node.getNext();
        doNode preNode=this.node;
        int count=1;
        while(node!=null){
            if (count==i){
                preNode.setNext(node.getNext());
                node.getNext().setPre(preNode);
            }
            ++count;
            preNode=node;
            node=node.getNext();
        }
    }
    //向双向节点中插入结点（末尾节点不可以插入）
    void insertNode(String username, int age,int i){
        User user = new User(username, age);
        doNode newNode = new doNode(user,null,null);
        doNode preNode=this.node;
        doNode creNode=preNode.getNext();
        int count=1;
        while (creNode!=null){
            if (count==i){
                creNode.setPre(newNode);
                newNode.setPre(preNode);
                preNode.setNext(newNode);
                newNode.setNext(creNode);
                return;
            }
            preNode=creNode;
            creNode=cruNode.getNext();
            ++count;
        }
        if (creNode==null){
            System.out.println("并不能在末尾节点不可以插入");
        }
    }
}

class DoLinkListTest {
    public static void main(String[] args) {
        doLinkList doLinkList = new doLinkList();
        doLinkList.initDoLinkList();
        doLinkList.putNode("zhangshan",10).putNode("lishi",20).putNode("wangwu",21);
        doLinkList.delNode(1);
        doLinkList.insertNode("lihua",20,2);
        doLinkList.printNodeData();
    }
}

循环链表的实现(c语言实现)

#include <stdio.h>
#include <stdlib.h>

//这个源代码设计的是循环链表，包括设计的尾指针，两个循环链表的组合，但是链表的其他操作我们在这就不去写了
// 设计这个尾指针的目的是在对表的首尾部分进行操作的时候可以降低时间复杂度
typedef struct Book {
	char bookname[20];
	char author[10];
}Book;

typedef struct Node{
	Book book;
	struct Node *next;
}Node;

typedef struct LoopLinkList{
	Node *headNode;
	Node *tailNode;
} *LoopList;
//初始化循环列表 
void initLoopLinkList(LoopList *L){  //ok
	Node *headNode=(Node*)malloc(sizeof(Node));
	*L=(LoopList)malloc(sizeof(LoopList));
	(*L)->headNode=headNode;
	(*L)->tailNode=headNode;
}
//向循环链表中添加结点 
void putNode(Book book,LoopList L){   //ok
	Node *node=(Node*)malloc(sizeof(Node));
	node->book=book;
	L->tailNode->next=node;
	L->tailNode=node;
	node->next=L->headNode;
}

//将第二个循环链表添加到第一个循环链表后
LoopList  connectTable(LoopList L1,LoopList L2){   //0k
	L1->tailNode->next=L2->headNode->next;
	free(L2->headNode);
	L2->tailNode->next=L1->headNode;
	L1->tailNode=L2->tailNode;
	return L1;
}

//打印链表中的数据 
void printNodeData(LoopList L){      //ok
	Node *node=L->headNode->next;
	while(node!=L->headNode){
		printf("bookname:%s;author:%s\n",node->book.bookname,node->book.author);
		node=node->next;
	}
	if(!node) printf("你所给的是个空链表！\n"); 
}
//获取循环列表的长度 
int getSize(LoopList L){    //ok
	Node *node=L->headNode->next;
	int counter=0;
	while(L->headNode!=L->tailNode&&node!=L->headNode){
		node=node->next;
		++counter;
	}
	return counter;
}

int main(){
	LoopList L;
	initLoopLinkList(&L);
	Book book1={"java","zhangyu"};
	Book book2={"php","zhang"};
	Book book3={"c#","nan"};
	putNode(book1,L);
	putNode(book2,L);
	putNode(book3,L);
	printf("表1：\n");
	printNodeData(L);
	LoopList L2;
	initLoopLinkList(&L2);
	Book book4={"jaa","hangyu"};
	Book book5={"ph","zhng"};
	Book book6={"c","an"};
	putNode(book4,L2);
	putNode(book5,L2);
	putNode(book6,L2);
	printf("表2：\n");
	printNodeData(L2);
	LoopList list=connectTable(L,L2);
	printf("连接后的表：\n");
	printNodeData(list);
	system("pause");
	return 0;
}
单链表的重要操作实现图解

循环链表的实现(java语言实现)

package linearList;

/*
* 循环链表的实现
* */
class Book{
    String bookname;
    int Bookid;

    public Book(String bookname, int bookid) {
        this.bookname = bookname;
        Bookid = bookid;
    }

    public String getBookname() {
        return bookname;
    }

    public void setBookname(String bookname) {
        this.bookname = bookname;
    }

    public int getBookid() {
        return Bookid;
    }

    public void setBookid(int bookid) {
        Bookid = bookid;
    }

    @Override
    public String toString() {
        return "Book{" +
                "bookname='" + bookname + '\'' +
                ", Bookid=" + Bookid +
                '}';
    }
}
class LpNode {
    Book book;
    LpNode next;

    public LpNode(Book book, LpNode next) {
        this.book = book;
        this.next = next;
    }

    public void setNext(LpNode next) {
        this.next = next;
    }

    public LpNode getNext() {
        return next;
    }
}
public class LoopLinkList {
    LpNode head;
    LpNode tail;

    //初始化循环列表
    void initLoopLinkList(){
        this.head=null;
        this.tail=null;
    }
    //向循环链表中添加结点
    LoopLinkList putNode(String bookname,int booid){
        Book book = new Book(bookname, booid);
        LpNode newNode = new LpNode(book,this.tail);
        if (this.head==null){
            this.head=newNode;
            this.tail=newNode;
        }else{
            this.tail=newNode;
            this.head.setNext(this.tail);
        }
        return this;
    }
    //将第二个循环链表添加到第一个循环链表后
    void connectTable(LoopLinkList linkList){
        linkList.head.setNext(this.tail);
        this.head.setNext(linkList.tail);
    }
    //打印链表中的数据
    int printNodeData(){
        LpNode tmppoint=this.head;
        int count=0;
        do {
            System.out.println(tmppoint.book.toString());
            tmppoint=tmppoint.getNext();
            ++count;
        }while (tmppoint!=this.head);
        return count;
    }
}

class LoopLinkListTest {
    public static void main(String[] args) {
        LoopLinkList loopLinkList = new LoopLinkList();
        loopLinkList.initLoopLinkList();
        loopLinkList.putNode("java入土",10).putNode("php",1).putNode("kl",10);
        loopLinkList.printNodeData();
        System.out.println("--------------");
        LoopLinkList loopLinkList1 = new LoopLinkList();
        loopLinkList1.putNode("lp",00).putNode("kk",10);
        loopLinkList.connectTable(loopLinkList1);
        loopLinkList.printNodeData();


    }
}

@张小鱼
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
再探C语言链表—TypeDef Struct模式声明链表节点
去流浪
10-10 2112
0.序 之前看到的网上的书上的都是Struct直接创建节点。 我记得typedef struct是大学时候数据结构课本上用来声明链表结点的方法，这个方法让人容易操作链表。后来书本扔了，再买了盗版书不知道是版本问题还是什么问题，包括网上大多数博客都是直接struct声明。struct直接声明对后面链表的增删改查都稍微增加了难度。 今天在查资料时候突然看到这个写法，操作了一遍发现很容易实现链表的一些基本操作，因此完善一下贴上来 1.代码 代码比较简单，重要的地方注释了 #include &lt..
链表中typedef引出的结构体问题，以及双重指针（有关头指针，工作指针变量的问题）
qq_42235617的博客
10-14 632
链表中typedef引出的结构体问题，以及双重指针（有关头指针，工作指针变量的问题） typedef是类型定义的意思。typedef struct 是为了使用这个结构体方便。 1 首先： 在C中定义一个结构体类型要用typedef: typedef struct Student { int a; }Stu; 于是在声明变量的时候就可：Stu stu1; 如果没有typedef就必须用struct ...
浅析 typedef struct 和 struct在定义结构体和链表中的作用
谜题未解
09-20 5943
       因为我是从C++入门的，对于C语言中很多知识不是很了解，所以经常会遇到在C++中没见过的表达形式，在这里记录一下学习历程，同时也希望能够帮助到后来者。关于typedef struct 和 struct 的区分网上有很多，但是都说得错综复杂，感觉没有get到正确的点。通过资料的整理，我认为它们之间的区分只需要记住下面几点即可： typedef是C语言中的关键字，作用是为一种数据类型定...
数据结构— —单链表
最新发布
m0_65635427的博客
10-18 774
数据结构——单链表
链表详解（C语言）
爱她就要努力
03-16 652
https://www.cnblogs.com/ariel-dreamland/p/10469696.html 链表是一种常见的基础数据结构，结构体指针在这里得到了充分的利用。 链表可以动态的进行存储分配，也就是说，链表是一个功能极为强大的数组，他可以在节点中定义多种数据类型，还可以根据需要随意增添，删除，插入节点。 链表都有一个头指针，一般以head来表示，存放的是一个地址。链表中的节点分为两类...
链表实现单词本管理.docx
12-23
C语言链表实现单词本管理 本文档主要介绍了使用C语言实现单词本管理系统的设计和实现过程。该系统使用链表结构来存储单词及其对应的中文解释，并提供了插入、删除、查找和输出单词的功能。 1. 链表结构的实现 在...
链表实现集合运算 链表实现集合交并差运算
12-27
链表实现集合运算 链表实现集合交并差运算
C语言学生考试系统（链表实现）
05-25
《C语言学生考试系统——链表实现》 在信息技术领域，C语言作为一种基础且强大的编程语言，被广泛用于系统编程、软件开发以及教学实训。本项目“C语言学生考试系统”便是利用C语言来实现的一个简易考试管理工具，其...
python双向链表实现实例代码
12-25
python双向链表实现代码： 复制代码 代码如下:#!/usr/bin/python# -*- coding: utf-8 -*- class Node(object): def __init__(self,val,p=0): self.data = val self.next = p self.prev = p class LinkList...
用数据结构-链表实现通讯录管理系统
04-12
本项目以"用数据结构-链表实现通讯录管理系统"为主题，通过C语言实现了这一功能，旨在帮助用户管理他们的联系人信息。下面我们将深入探讨这个系统所涉及的主要知识点。 首先，我们来了解**链表**这一数据结构。链表...
链表初始化typedef struct LNode{}LNode,*linklist的理解
qq_44805265的博客
07-15 2826
typedef是对可以理解为各现有的数据类型起了一个新名字。 typedef struct LNode{ }LNode； 相当于给struct LNode{}起了一个新名字Lnode{} 比如在声明变量时，如果没有用typedef声明，自己定义变量时是这样子 struct LNode 变量名 如果用了typedef则变成 Lnode 变量名 简单来说就是更方便了。 当然如果不用typedef struct LNode{ }； 声明变量也可以 直接 LNode 变量名，或者LNo
数据结构与算法——线性表（链表篇）
热门推荐
小田是个程序员的博客欢迎你的到来呀~
06-20 2万+
本篇文章，主要详细解读和总结线性表的链式存储结构——链表，包括单链表、双链表、静态链表以及循环链表，讲解较为全面，图文并茂，总结各链表的特性以及基本操作，干货满满，各位小伙伴们请细细品读，你会收获你想要的知识的！.........
1.（1）数据结构之链表-typedef的用法
爱打羽毛球的程序员
07-21 1425
C语言typedef的用法，定义。typedef 关键字来定义自己习惯的数据类型名称，来替代系统默认的基本类型名称、数组类型名称、指针类型名称与用户自定义的结构型名称、共用型名称、枚举型名称等。.........
【数据结构】typedef struct 和 struct在链表中的应用
小菜一枚
05-04 2213
(1) struct{ int x; int y; }test1; 定义了 结构 test1， test1.x 和 test1.y 可以在语句里用了。 (2) struct test {int x; int y; }test1; 定义了 结构 test1， test1.x 和 test1.y 可以在语句里用了。 与 1 比，1里面省写 了 test (3) typedef struct
数据结构03——单链表/创建struct时前面的typedef
weixin_43288757的博客
08-05 1081
定义单链表节点类型 struct LNode{ //定义单链表节点类型 ElemType data; //数据域，每个节点存放一个数据 struct LNode *next; //指针域 指针指向下一个节点 }; struct LNode *p=(struct LNode *) malloc(sizeof(struct LNode)) ; //增加一个新的 节点：在内存中申请一个节点所需空间，并用指针P指向这个节点 typedef关键字——数据类型重命名 用法： typedef &l
链表里的struct
tianyexing2008的博客
02-11 1071
最近在看代码的时候，发现有一个链表有点奇怪，一下子没看出来个所以，于是好奇地认真的看了下，于是记录下了这篇博文。 首先看使用情况： void threadProc() { ListNode *node = sFdList.head; while(node) { ReactorSocket *reactor = (ReactorSocket*)node; //to do printf("socket fd ...
typedef struct和struct的区别（学习数据结构的单链表过程中遇到的问题）
qq_31239371的博客
05-05 600
最近在学数据结构时，有一些疑惑，在下图中： 可以看到，在定义单链表时，对next指针的定义方式是struct Lnode *next，表示next是指向Lnode类型的一个指针。在定义指向节点p的指针的时候，用的是Lnode *p，注意此处没有struct。因此很好奇，为什么同样是指向结构体的指针，一个在定义的时候要加上struct，一个不用呢？ 对于定义指向节点p的指针，用的是Lnode...
单链表的创建 测长和打印
u014636580的专栏
03-09 460
面试宝典中第13章，实现单链表的建立测长和打印 #include #include #include #include using namespace std; //单链表结构体 typedef struct student { int data; struct student *next; }node; //建立单链表 node *create() { node *head
链表实现多项式及运算
本篇内容将详细解释如何利用链表实现这一功能。 首先，我们需要定义一个链表节点结构，通常称为`node`，包含多项式的系数（`tak`）和指数（`fin`），以及指向下一个节点的指针。链表的头部是一个特殊的节点，它的`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值