链表的插入,删除和遍历

双向链表

主文件

#include <stdio.h>
#include "./03_shuang_head.h"

int main(int argc, const char *argv[])
{
	linkList* head = create_shuang_link();
	//头插
	shuang_head_cha(head,50);
	shuang_head_cha(head,40);
	shuang_head_cha(head,30);
	shuang_head_cha(head,20);
	shuang_head_cha(head,10);
	
	//尾插
	shuang_wei_cha(head,80);
	shuang_wei_cha(head,90);
	
	//按位置插入
/*	shuang_weiz_cha(head,11,1);
	shuang_weiz_cha(head,66,6);
	shuang_weiz_cha(head,999,9);   */
	
	//头删
/*	shuang_head_delete(head,10);   */

	//尾删
/*	shuang_wei_delete(head,90);	   */
	
	//按位置删除
	shuang_weiz_delete(head,4);

	//遍历
	shuang_bianli(head);

	return 0;
}

调用的函数文件

#include <stdio.h>
#include <stdlib.h>
#include "./03_shuang_head.h"

//创建一个空的双向链表
linkList* create_shuang_link(void)
{
	linkList* head = (linkList*)malloc(sizeof(linkList));
	if(head == NULL)
	{
		printf("创建失败!\n");
		return NULL;
	}
	head->text.len = 0;
	head->next = NULL;
	head->prev = NULL;

	return head;
}

//头插
void shuang_head_cha(linkList* head, dataType num)
{
	linkList* temp = (linkList*)malloc(sizeof(linkList));
	if(temp == NULL)
	{
		printf("头插失败\n");
		return;
	}
	temp->text.data = num;
	temp->next = NULL;
	temp->prev = NULL;

	if(head->next == NULL)
	{
		temp->next = head->next;
		head->next = temp;
		
		temp->prev = head;
	}
	else
	{
		temp->next = head->next;
		head->next = temp;
		
		temp->next->prev = temp;
		temp->prev = head;
	}
	
	printf("头插成功!\n");
	head->text.len++;

	return;

}

//尾插
void shuang_wei_cha(linkList* head, dataType num)
{
	linkList* temp = (linkList*)malloc(sizeof(linkList));
	if(temp == NULL)
	{
		printf("头插失败\n");
		return;
	}
	temp->text.data = num;
	temp->next = NULL;
	temp->prev = NULL;
	
	linkList* p =head;
	while(p->next != NULL)
		p = p->next;
	temp->next = p->next;
	p->next = temp;

	temp->prev = p;

	printf("尾插成功!\n");
	head->text.len++;
}

//按位置插入
void shuang_weiz_cha(linkList* head, dataType num, int pos)
{
	linkList* temp = (linkList*)malloc(sizeof(linkList));
	if(temp == NULL)
	{
		printf("头插失败\n");
		return;
	}
	temp->text.data = num;
	temp->next = NULL;
	temp->prev = NULL;

	if(pos < 1 || pos > temp->text.len+1)
	{
		printf("插入位置非法,插入失败!\n");
		return;
	}
	linkList* p = head;
	for(int i = 0; i < pos-1; i++)
		p = p->next;
	if(p->next != NULL)
	{
		temp->next = p->next;
		p->next = temp;

		temp->next->prev = temp;
		temp->prev = p;
	}
	else
	{
		temp->next = p->next;
		p->next = temp;

		temp->prev = p;
	}
	printf("按位置插入成功!\n");
	head->text.len++;
}

//头删
dataType shuang_head_delete(linkList* head, dataType num)
{
	if(head->next == NULL)
	{
		printf("链表为空,无法删除\n");
		return -1;
	}
	linkList* p = head->next;
	if(p->next != NULL)
	{
		head->next = p->next;
		p->next->prev = head;
		dataType num = p->text.data;
		printf("头删除的节点num = %d\n", num);
		free(p);
	}
	else
	{
		head->next = p->next;
		dataType num = p->text.data;
		printf("头删除的节点num = %d\n", num);
		free(p);
	}

	head->text.data = num;
	head->text.len--;
	return num;
}

//尾删
dataType shuang_wei_delete(linkList* head, dataType num)
{
	if(head->next == NULL)
	{
		printf("链表为空,无法删除\n");
		return -1;
	}
	linkList* p = head;
	while(p->next != NULL)
		p = p->next;
	p->prev->next = NULL;
	num = p->text.data;
	printf("头删除的节点num = %d\n", num);
	free(p);

	head->text.data = num;
	head->text.len--;
	return num;

}

//按位置删除
dataType shuang_weiz_delete(linkList* head, int pos)
{
	linkList* p = head;
	for(int i = 0; i < pos; i++)
		p = p->next;
	if(p->next != NULL)
	{
		p->prev->next = p->next;
		p->next->prev = p->prev;
		dataType num = p->text.data;
		printf("按位置删除的节点num = %d\n", num);
		free(p);
	}
	else
	{
		p->prev->next = p->next;
		dataType num = p->text.data;
		printf("按位置删除的节点num = %d\n", num);
		free(p);
	}
	dataType num = head->text.data;
	head->text.len--;
	return num;
}

//遍历
void shuang_bianli(linkList* head)
{
	linkList* p = head;
	while(p->next != NULL)
	{
		p = p->next;
		printf("%d ",p->text.data);
	}
	printf("\n");

	return;
}









头文件

#ifndef __shuang_h__
#define __shuang_h__
typedef int dataType; //由于应用中不一定为int类型,所以重名为dataTppe

//使用联合体存储数据域信息
union msg{
    dataType data;  //有效数据节点
    int len;        //头结点的表长
};

//由于节点中的指针域要指向下一个节点,所以必须使用有名结构体
typedef struct node{
    //数据域: 若是头结点,则使用text里的len,
    //        若是有效数据节点,则使用text里的data
    union msg text;                                                  
    struct node* next; //指针域,存储下一个节点的地址
	struct node* prev; //指针域,存储上一个节点的地址
}linkList;

//创建一个空的双向链表
linkList* create_shuang_link(void);
//头插
void shuang_head_cha(linkList* head, dataType num);
//遍历
void shuang_bianli(linkList* head);
//尾插
void shuang_wei_cha(linkList* head,dataType num);
//按位置插入
void shuang_weiz_cha(linkList* head, dataType num, int pos);
//头删
dataType shuang_head_delete(linkList* head, dataType num);
//尾删
dataType shuang_wei_delete(linkList* head, dataType num);
//按位置删除
dataType shuang_weiz_delete(linkList* head, int pos);

#endif

单向循环链表

主文件

#include <stdio.h>
#include "./33_xunhuan_head.h"
int main(int argc, const char *argv[])
{
	linkList* head = create_xunh_link();
	//头插
	xunh_link_head_charu(head,55);
	xunh_link_head_charu(head,44);
	xunh_link_head_charu(head,33);
	xunh_link_head_charu(head,22);
	xunh_link_head_charu(head,11);
	
	//尾插
	xunh_link_wei_cha(head,66);
	xunh_link_wei_cha(head,77);
	xunh_link_wei_cha(head,88);
	
	//头删
	xunh_head_delete(head);

	//尾删
	xunh_wei_delete(head);

	//遍历
	xunh_link_bianli(head);

	return 0;
}

调用的函数文件

#include <stdio.h>
#include <stdlib.h>
#include "./33_xunhuan_head.h"

//创建空的单向循环链表
linkList* create_xunh_link(void)
{
    //头结点
    linkList* head = (linkList*)malloc(sizeof(linkList));
    if(head == NULL)
    {
        printf("头结点为空,创建链表失败!\n");
        return NULL;
    }

    head->text.len = 0;  //初始化头结点的表长为0
    head->next = head;   //初始化指针域为空

    return head;
}                                                        

//单项循环链表头插
void xunh_link_head_charu(linkList* head,dataType num)
{
	linkList* temp = (linkList*)malloc(sizeof(linkList));
	if(temp == NULL)
	{
		printf("创建节点失败\n");
		return;
	}
	//初始化
	temp->text.data = num;
	temp->next = NULL;
	//头插
	temp->next = head->next;
	head->next = temp;

	head->text.len++;
	printf("单向循环链表头插成功\n");

	return;
}

//单项循环链表尾插
void xunh_link_wei_cha(linkList* head,dataType num)
{
	linkList* temp = (linkList*)malloc(sizeof(linkList));
	if(temp == NULL)
	{
		printf("创建节点失败\n");
		return;
	}	
	temp->text.data = num;
	temp->next = NULL;
	//尾插
	linkList* p = head;
	while(p->next != head)
	{
		p = p->next;
	}
	temp->next = head;
	p->next =temp;

	head->text.len++;
	printf("单向循环链表尾插成功!\n");

	return;
}

//循环链表遍历
void xunh_link_bianli(linkList* head)
{
	linkList* p = head;
	while(p->next != head)
	{
		p = p->next;
		printf("%d ",p->text.data);
	}
	printf("\n");

	return;
}

//头删
dataType xunh_head_delete(linkList* head)
{
	if(head->next == head)
	{
		printf("链表为空,无法删除\n");
		return -1;
	}
	linkList* temp = head->next;
	head->next = temp->next;

	dataType num = temp->text.data;
	printf("头删除的节点num = %d\n", num);
	free(temp);
	temp = NULL;
	
	head->text.len--;
	return num;
}

//尾删
dataType xunh_wei_delete(linkList* head)
{
	if(head->next == head)
	{
		printf("链表为空,无法删除\n");
		return -1;
	}
	linkList* p = head;
	while(p->next->next != head)
	{
		p = p->next;
	}
	dataType num = p->next->text.data;
	printf("尾删除的节点num = %d\n",num);
	free(p->next);
	p->next = head;

	head->text.len--;

	return num;
}














头文件

#ifndef __xunhuanlink_h__
#define __xuanhuanlink_h__

typedef int dataType; //由于应用中不一定为int类型,所以重名为dataTppe

//使用联合体存储数据域信息
union msg{
    dataType data;  //有效数据节点
    int len;        //头结点的表长
};

//由于节点中的指针域要指向下一个节点,所以必须使用有名结构体
typedef struct node{
    //数据域: 若是头结点,则使用text里的len,
    //        若是有效数据节点,则使用text里的data
    union msg text;                                                  
    struct node* next; //指针域,存储下一个节点的地址
}linkList;

//创建空的单向循环链表
linkList* create_xunh_link(void);
//单向循环链表头插
void xunh_link_head_charu(linkList* head,dataType num);
//单向循环链表头删
void xunh_link_wei_cha(linkList* head,dataType num);
//循环链表遍历
void xunh_link_bianli(linkList* head);
//头删
dataType xunh_head_delete(linkList* head);
//尾删
dataType xunh_wei_delete(linkList* head);


#endif

  • 2
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
链表是一种常见的数据结构,它由若干个节点组成,每个节点中包含了一个数据元素和一个指向下一个节点的指针。链表可以用来实现栈、队列等数据结构。 以下是链表插入遍历、查找和删除操作的具体实现: 插入操作: 在链表插入一个新的节点通常需要以下步骤: 1. 创建一个新的节点,赋值为要插入的数据。 2. 找到要插入的位置,即在哪两个节点之间插入新节点。 3. 将新节点的指针指向下一个节点,并将前一个节点的指针指向新节点。 代码实现: ```python class Node: def __init__(self, data=None): self.data = data self.next = None class LinkedList: def __init__(self): self.head = None def insert(self, data): new_node = Node(data) if self.head is None: self.head = new_node return current_node = self.head while current_node.next is not None: current_node = current_node.next current_node.next = new_node ``` 遍历操作: 遍历链表通常需要以下步骤: 1. 从头节点开始,依次遍历每个节点。 2. 对于每个节点,执行相应的操作,例如打印节点中的数据。 代码实现: ```python class LinkedList: def __init__(self): self.head = None ... def traverse(self): if self.head is None: print("Linked list is empty") return current_node = self.head while current_node is not None: print(current_node.data) current_node = current_node.next ``` 查找操作: 在链表中查找一个节点通常需要以下步骤: 1. 从头节点开始,依次遍历每个节点。 2. 对于每个节点,判断其包含的数据是否与要查找的数据相等。 3. 如果找到了相等的节点,返回该节点;否则,返回 None。 代码实现: ```python class LinkedList: def __init__(self): self.head = None ... def search(self, data): if self.head is None: return None current_node = self.head while current_node is not None: if current_node.data == data: return current_node current_node = current_node.next return None ``` 删除操作: 在链表删除一个节点通常需要以下步骤: 1. 找到要删除的节点,即在哪两个节点之间删除节点。 2. 将前一个节点的指针指向后一个节点。 代码实现: ```python class LinkedList: def __init__(self): self.head = None ... def delete(self, data): if self.head is None: return if self.head.data == data: self.head = self.head.next return current_node = self.head while current_node.next is not None: if current_node.next.data == data: current_node.next = current_node.next.next return current_node = current_node.next ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值