单向链表增删改查的实现

/*实现单向链表的增删改查 */
#include <malloc.h>
#include <stdio.h>
#include<stdlib.h>
#define LEN sizeof(node)

typedef struct node
{
int num;
struct node *next;
}node,*pnode;

/*在链表头进行插入,新节点成为头节点,原头节点成为新节点的下一个节点,头节点指针后伊一位*/
void insert_head(pnode *phead,int data)
{
pnode p;
p=(pnode)malloc(sizeof(LEN));
if(NULL==p)
{
perror("malloc fail");
exit(1);
}
p->num=data;
p->next=(*phead);
(*phead)=p;
}

/*在链表尾进行插入*/
void insert_tail(pnode *phead,int data)
{
pnode p; // 插入的新结点
pnode p2=(*phead); //链表中的指针初始化,否则会发生段错误
p=(pnode)malloc(sizeof(LEN));
if(NULL==p)
{
perror("malloc fail");
exit(1);
}
p->next=NULL;
p->num=data;
if(*phead)
{
while(p2->next) //遍历链表,找到鏈表末尾节点
{
p2=p2->next;
}
p2->next=p;
}

}

/*在链表头进行删除*/
void delate_head(pnode *phead)
{
if((*phead)==NULL)
{
return 0;
}else{
pnode p;
p=(*phead); //找到链表头节点,保存后释放,同时头节点指针后移一位
(*phead)=(*phead)->next;
free(p);
}

}

/*在链表尾进行删除*/
void delate_tail(pnode *phead)
{
pnode p;
pnode p1;
p=(*phead);
if(*phead)
{
while((p->next)!=NULL)
{
p1=p; //p1用来保存原来p的位置,所以应该先保存,再后移
p=p->next;
}
if(p1) //p1始终指向倒数第二个节点,但链表只有一个结点时,p1不存在,所以需要进行判断
{
free(p);
p1->next=NULL;
}else{
free(p);
}

}
}

/*根据num来匹配想要想要寻找的节点*/
struct node *find_data(pnode phead,int data)
{
pnode p;
p=phead;

while(p!=NULL && (p->num) !=data) //遍历链表
{
p=p->next;
}
if(p){ // 判断查找数据是否存在
printf(" 您想查找的數據是:%d\n",p->num);
}else{
printf("你所查找的数据不存在\n");
}
return p;
}

/*根据data来删除节点,要删除节点为p->next,要删除节点的上一节点为p,要删除节点的下一节点为q*/
void delate_data( pnode *phead,int data)
{
pnode p,q;
p=(*phead);
if((*phead)->num==data)
{
delate_head(phead);
}else{
while((p->next)!=NULL &&(( p->next)->num) !=data) //定位到要删除节点的上一节点
{
p=p->next;
}
if((p->next)==NULL){
printf("你所删除的数据不存在\n");
}else{
q=p->next->next;
free(p->next);
p->next=q;
}
}

}

/*根据节点序列号来修改链表中的数据 */
void modify_data(pnode *phead,int x,int y) //参数分别为头节点指针,修改的节点序,修改后的数据
{
int i=0;
pnode p=(*phead);
while(p){
if(i==x)
{
p->num=y;
break;
}
p=p->next;
i++;

}
if(i<x)
{
printf(" 你所输入的序列号不合法\n ");
return 0;
}

}

void printf_list(pnode head)
{

while(head)
{
printf("%d\n",head->num);
head=head->next;
}
printf("\n");
}

void main(void)
{

struct node *head=NULL;

insert_head(&head,1); //测试前插

insert_head(&head,2);
insert_head(&head,3);
insert_head(&head,4);
insert_head(&head,5);
printf("前插成功\n");

insert_tail(&head,6); //测试后插
insert_tail(&head,7);
insert_tail(&head,8);
insert_tail(&head,9);
printf("后插成功\n");

delate_head(&head);
printf("前删成功\n");

delate_tail(&head);
delate_tail(&head);
printf("后删成功\n");

find_data(head,2);
printf("查找数据成功\n");
find_data(head,10); // 查找的数据不存在

delate_data(&head,2);
printf("删除指定数据成功\n");
delate_data(&head,10); //删除的数据不存在

modify_data(&head,2,15); //测试修改
modify_data(&head,6,15); //测试修改

printf_list(head); //测试打印

printf("遍历成功\n");

}

时间: 2024-11-06 10:01:29

单向链表增删改查的实现的相关文章

java实现单链表增删改查

package 数据结构算法.链表; /* *定义节点 * 链表由节点构成 */ public class Node<E> { private E e; //数据data private Node<E> next; //指向下一个节点 public Node() { } public Node(E e) { this.e = e; } public Node<E> getNext() { return next; } public void setNext(Node&l

C链表一——链表增删改查以及初始化的头插法与尾插法

线性表的链式存储又称为链表(物理实现方式): 链式存储是最常用的存储方式之一.它不仅可以用来表示线性表,而且可以用来表示各种非线性的数据结构: 链表又可分为单链表.双链表.循环链表等. 一:单链表 所谓单链表是指数据结点是单向排列的.它包括两个域,一个信息域用于存放数据,一个指针域用于存放下个结点的地址: 单链表中结点类型的描述如下: struct Node { ElemType data_; Node *next_; }; 利用单链表可以解决顺序表需要大量的连续的存储空间的缺点,但是单链表附加

动态链表增删改查及排序功能

主要功能的实现: #include "SeqList.h" void InitSeqList(SeqList * pSeq)//初始化 { assert(pSeq); pSeq->array = (DataType*)malloc(sizeof(DataType)*DEFAULT_CAPICITY); pSeq->size = 0; pSeq->capicity = DEFAULT_CAPICITY; } void PrintSeqList(SeqList* pSeq

Java描述数据结构之链表的增删改查

链表是一种常见的基础数据结构,它是一种线性表,但在内存中它并不是顺序存储的,它是以链式进行存储的,每一个节点里存放的是下一个节点的"指针".在Java中的数据分为引用数据类型和基础数据类型,在Java中不存在指针的概念,但是对于链表而言的指针,指的就是引用数据类型的地址. 链表和数组都是线性的数据结构,对于数组而言其长度是固定的,由于在内存中其是连续的,因此更适合做查找与遍历,而链表在内存中是并不是顺序存储的,但是由于其是通过"指针"构成的,因此在插入.删除时比较数

【C】利用单链表数据结构实现通讯录,链表的增删改查

C语言中实现链表,是需要利用到C语言中比较难的结构体与指针才能实现. 结构体中放一个指向后接节点的指针与每一个结点应该存放的信息. 下面做一个命令行的通讯录来说明链表的增删改查这个问题. 一开始让用户输入链表,按1可以输出,按3可以删除. 可以修改: 可以插入. 按0则可以退出: 代码如下: #include<stdio.h> #include<stdlib.h> typedef struct Linklist{ char name[10];//存放名字 char num[10];

链表的基本操作之_增删改查

<span style="font-size:32px;"><strong style="background-color: rgb(51, 255, 51);">链表的基本操作之_增删改查</strong></span> #include<stdio.h> #include<string.h> #include<stdlib.h> typedef struct Node { int

数据结构 线性结构(数组[列表] ,链表 单链表的增删改查**, 线性结构的应用 队列 栈[函数的调用**]),非线性结构 树

数据结构 参考:http://lupython.gitee.io/ 线性结构 就是能够用一根线串起来的数据结构 数组 (列表) 问:申请数组的前提条件是啥? a[12]?内存需要满足的条件? 答:内存必须有一块连续的内存空间 int a[7] : 声明一个数组,这个数组的数组名是 a, 数组的大小是 7, 数组元素的类型是整型. int a[7] = array(1,2,3,4,5,6,7) 问:如何申请内存? 答:C,C++语言,申请:mallco (28).释放:free(28) 问:int

单向链表的增删查改

链表(Linked List) 链表是有序的列表 链表是以节点的方式来存储,是链式存储 每个节点包含data域,next域:指向下一个节点 链表的各个节点不一定是连续存储 链表分带头节点的链表和没有头节点的链表,根据实际需求来确定 单链表的增删改查 package linkedlist; import javax.swing.plaf.synth.SynthSeparatorUI; public class SingleLinkedListDemo { public static void ma

java-jdbc-mysql:实现数据库表的增删改查

以数据库test下数据表student(sno,sname,ssex,sage,sdept)为例: student表中的已有的所有记录: Java代码对表test.student的操作: 创建student类,包含String sno,String sname,String ssex,int sage,String sdept: 1 package jdbcTest; 2 3 public class Student { 4 private String sno,sname,ssex,sdept