无头单链表的各种操作

最新推荐文章于 2022-12-19 16:16:33 发布
最新推荐文章于 2022-12-19 16:16:33 发布
阅读量165 收藏 2
点赞数
分类专栏： C 文章标签： c++ c语言 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39208237/article/details/112853549
版权

SList无头单链表

链表链表是一种物理结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。

链表可分为以下3类：
1.单向、双向
2.带头、不带头
3.循环、非循环
组合起来就有8种链表结构。

但常用的基本就两种：
在这里插入图片描述

实现目标

利用无头单链表，并实现以下功能：
Slist

代码实现

//Sysutil.h
#ifndef __SYSUTIL_H___
#define __SYSUTIL_H___

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include <stdbool.h>
#pragma warning(disable:4996)


#endif


//SList.h
#pragma once
#include "Sysutil.h"

#define ElemType int

//无头单链表
typedef struct SListNode
{
	ElemType data;//数据域
	struct SListNode* next;//指针域
}SListNode;

typedef struct SList 
{
	SListNode* head;
}SList;

void SListMenu();
void SListInit(SList* plist);
static SListNode* BuyNode();
void SListPushBack(SList* plist, ElemType x);
void SListShow(SList* plist);
void SListPushFront(SList* plist, ElemType x);
int SListLength(SList* plist);
void SListPopBack(SList* plist);
void SListPopFront(SList* plist);
SListNode* SListFind(SList* plist, ElemType key);
void SListClear(SList* plist);
void SListDeleteByVal(SList* plist, ElemType x);
void SListPushByVal(SList* plist, ElemType key);
void SListReverse(SList* plist);
void SListPopAllSame(SList* plist, ElemType key);
void SListPushPos(SList* plist, int pos, ElemType x);
void SListPopPos(SList* plist, int pos);
void SListDestroy(SList* plist);

/
void SListMenu()
{
	printf("*******************************************\n");
	printf("*****   [1]显示长度     [2]头部插入   *****\n");
	printf("*****   [3]尾部插入     [4]按值插入   *****\n");
	printf("*****   [5]打印所有     [6]头部删除   *****\n");
	printf("*****   [7]尾部删除     [8]按值删除   *****\n");
	printf("*****   [9]按值查找     [10]销毁链表  *****\n");
	printf("*****   [11]元素翻转    [12]同值删除  *****\n");
	printf("*****   [13]按位插入    [14]按位删除  *****\n");
	printf("*****   [15]清除内容    [0]退出       *****\n");
	printf("*******************************************\n");
}

void SListInit(SList* plist)
{//初始化:无头单链表
	plist->head = NULL;
}

static SListNode* BuyNode() 
{
	SListNode* p = (SListNode*)malloc(sizeof(SListNode));//申请节点
	assert(p != NULL);
	p->data = 0;//节点初始化
	p->next = NULL;
	return p;
}

void SListPushBack(SList* plist, ElemType x)
{
	assert(plist);//合法检查
	SListNode* p = plist->head;
	SListNode* s = BuyNode(); //创建新节点，存储数据
	s->data = x;
	if (NULL == p) {//空表，链接
		plist->head = s;
	}
	else {//非空，尾插
		while (NULL != p->next) {//找到表尾
			p = p->next;
		}
		p->next = s;//链接
	}
}

void SListShow(SList* plist)
{
	assert(plist);
	SListNode* p = plist->head;//继承head
	while (NULL != p) {//打印
		printf("%d-->",p->data);
		p = p->next;
	}
	printf("end\n");//结束指示
}

void SListPushFront(SList* plist, ElemType x)
{
	assert(plist);//合法检查
	SListNode* s = BuyNode(); //创建新节点，存储数据
	s->data = x;
	s->next = plist->head;//继承 head->next
	plist->head = s;//链接
}

int SListLength(SList* plist)
{
	assert(plist);
	int cnt = 0;
	SListNode* p = plist->head;
	while (NULL != p) {//遍历求长度
		p = p->next;
		cnt++;
	}
	return cnt;
}

void SListPopBack(SList* plist)
{
	assert(plist);
	SListNode* p = plist->head;
	if (NULL != p) {
		if (p->next == NULL) {//只有一个节点
			plist->head = NULL;
		}
		else {//多个节点
			SListNode* pre = BuyNode();
			while (p->next != NULL) {//寻找最后一个节点
				pre = p;//前一个节点
				p = p->next;
			}
			pre->next = NULL;
		}
		free(p);
	}
	else {
		printf("空SList!\n");
	}
}
	
void SListPopFront(SList* plist)
{
	assert(plist);
	SListNode* p = plist->head;
	if (NULL != p) {
		plist->head = p->next;//指向下一节点
		free(p);
	}
}

SListNode* SListFind(SList* plist, ElemType key)
{
	assert(plist);
	SListNode* p = plist->head;
	//非空表，遍历寻找
	while (NULL != p && p->data != key)
	{
		p = p->next;
	}
	return p;
}

void SListClear(SList* plist)
{
	assert(plist);
	SListNode* p = plist->head;
	while (NULL != p){
		plist->head = p->next;
		free(p);
		p = plist->head; //指向下个节点
	}
}

void SlistDestroy(SList* plist)
{
	assert(plist);
	SListClear(plist);

}
	
void SListDeleteByVal(SList* plist, ElemType x)
{
	assert(plist);
	SListNode* p = plist->head;
	SListNode* pre = NULL;
	while (p != NULL && p->data != x) {
		pre = p;
		p = p->next;
	}
	if (p != NULL) {
		if (pre == NULL)//第一个节点
			plist->head = p->next;
		else//中间节点
			pre->next = p->next;
		free(p);
	}
}

void SListPushByVal(SList* plist, ElemType key)
{
	assert(plist);
	SListNode* p = BuyNode();
	p->data = key;
	if (NULL == plist->head) 
		plist->head = p;
	else {
		SListNode* s = plist->head;
		SListNode* pre = NULL;
		while (s != NULL && key > s->data) {
			pre = s;
			s = s->next;
		}
		if (NULL == pre) {
			p->next = s;
			plist->head = p;
		}
		else {
			p->next = pre->next;
			pre->next = p;
		}
	}
}

void SListReverse(SList* plist) 
{
	assert(plist);
	if (NULL == plist->head->next || NULL == plist->head)//不需要转置
		return;
	SListNode* p = plist->head->next;//继承当前SList的第二个节点
	plist->head->next = NULL;//断开与第二个节点的链接
	SListNode* q = p; //
	while (NULL != q) {//头插
		q = q->next; 
		p->next = plist->head; 
		plist->head = p;
		p = q;
	}
}

void SListPopAllSame(SList* plist, ElemType key) 
{
	assert(plist);
	SListNode* p = plist->head;
	SListNode* pre = NULL;
	while (p != NULL) {
		while (p != NULL && p->data != key) {
			pre = p;
			p = p->next;
		}
		if (p != NULL) {
			if (pre == NULL)//第一个节点
				plist->head = p->next;
			else//中间节点
				pre->next = p->next;
			free(p);//释放data=key的节点
		}
		if (NULL != pre)//
			p = pre->next;
		else
			p = plist->head;//从头开始
	}
}

void SListPushPos(SList* plist, int pos, ElemType x)
{
	assert(plist);
	int len = SListLength(plist);
	if (pos<1 || pos>len) {
		printf("插入位置非法!\n");
		return;
	}
	SListNode* s = BuyNode();
	s->data = x;
	int cnt = 1;
	SListNode* p = plist->head;
	while (cnt != pos) {
		p = p->next;
		cnt++;
	}
	s->next = p->next;
	p->next = s;
}

void SListPopPos(SList* plist, int pos)
{
	assert(plist);
	int len = SListLength(plist);
	if (pos<1 || pos>len) {
		printf("输入位置非法!\n");
		return;
	}
	int cnt = 1;
	SListNode* p = plist->head;
	SListNode* pre = NULL;
	while (p != NULL && cnt != pos) {
		pre = p;
		p = p->next;
		cnt++;
	}
	if (p != NULL) {
		if (pre == NULL)//第一个节点
			plist->head = p->next;
		else//中间节点
			pre->next = p->next;
		free(p);
	}
}

void SListDestroy(SList* plist)
{
	assert(plist);
	SListClear(plist);
}

#include "SlistNode.h"

int main()
{
	SList mylist;
	SListInit(&mylist);
	int choice;
	int quit = 0;
	int pos = 0;
	ElemType item;
	while (!quit) {
		SListMenu();
		printf("请输入你的选择#");
		scanf("%d", &choice);
		switch (choice) {
		case 1:
			printf("Slist长度为[%d]\n", SListLength(&mylist)); 
			break;
		case 2:
			printf("请输入想要插入的数据(-1结束)#");
			while (scanf("%d", &item), item != -1) {
				SListPushFront(&mylist, item);
			}
			SListShow(&mylist); break;
		case 3:
			printf("请输入想要插入的数据(-1结束)#");
			while (scanf("%d", &item), item != -1) {
				SListPushBack(&mylist, item);
			}
			SListShow(&mylist);
			break;
		case 4:
			printf("请输入想要插入的数据#");
			scanf("%d", &item);
			SListPushByVal(&mylist, item);
			SListShow(&mylist);
			break; SListShow(&mylist);break;
		case 5:SListShow(&mylist); break;
		case 6:SListPopFront(&mylist); SListShow(&mylist); break;
		case 7:SListPopBack(&mylist); SListShow(&mylist); break;
		case 8:
			printf("请输入想要删除的数据#");
			scanf("%d", &item);
			SListDeleteByVal(&mylist, item);
			SListShow(&mylist);
			break;
		case 9:
			printf("请输入想要查找的数据)#");
			scanf("%d", &item);
			SListNode* p = SListFind(&mylist, item);
			if (NULL != p) {
				printf("[%d]的物理存储地址为[%p]\n", item, &p);
			}
			else
				printf("[%d]不存在于SList中!\n", item);
			break;
		case 10:SlistDestroy(&mylist); break;
		case 11:SListReverse(&mylist); SListShow(&mylist); break;
		case 12:
			printf("请输入想要全部删除的同一数据)#");
			scanf("%d", &item);
			SListPopAllSame(&mylist, item);
			break;
		case 13:
			if (SListLength(&mylist) == 0) {
				printf("空表!请使用其他选项加入数据!\n");
				break;
			}
			printf("请输入想要插入的位置及数据(1-%d)#",SListLength(&mylist));
			scanf("%d %d", &pos, &item);
			SListPushPos(&mylist, pos,item);
			SListShow(&mylist);
			break;
		case 14:
			if (SListLength(&mylist) == 0) {
				printf("空表!\n");
				break;
			}
			printf("请输入想要删除的位置(1-%d)#", SListLength(&mylist));
			scanf("%d", &pos);
			SListPopPos(&mylist, pos);
			break;
		case 15:SListClear(&mylist); break;
		case 0:printf("再见!\n");SlistDestroy(&mylist); quit = 1; break;
		default:printf("输入错误!请重新输入#"); break;
		}
	system("pause");
	system("cls");
	}
	return 0;
}
明月本无心
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
有头的单链表的基本操作
f_shell_x的博客
09-24 326
对于单链表的基本操作有 初始化，销毁，以及头部插入，尾部插入，头部删除，尾部删除以及计算单链表的长度。 我这里的初始化函数，因为有一个链表头，所以malloc的时候，是从第二个空间进行空间开辟的。并且在释放的时候，也是从第二个空间开始释放的。并且头部的插入和删除，也都是第二个位置的删除与插入，如果需要修改头的值，就需要调用另外一个函数。这个我会在别的博客里面写清楚。 具体实现并不难，咋们直接...
无头单链表及其操作.zip
02-20
当我们开始学习数据结构时，我们都是从链表开始学习，在我刚开始学的时候觉得很有意思，分享给大家，这里面包括了数据结构中链表的创建，插入，删除，销毁及其一些小操作
二叉搜索树的删除_LeetCode109.有序链表转换二叉搜索树
weixin_39897015的博客
12-14 86
点击上方“蓝字”，发现更多精彩。01PART二叉搜索树二叉查找树又称二叉搜索树或者二叉排序树；它可以是一个空树或者是一个二叉树，既有链表的快速插入与删除的特点，又有数组快速查找的优势。具有以下性质：①．若左子树非空，则左子树所有节点均小于根节点的值；②．若右子树非空，则右子树所有节点均大于根节点的值；③．左右子树也是二叉查找树；④．没有键值相等的节点。02PART双指针快慢指针是两个指针...
无头链表的两种实现方法
qq_53144086的博客
06-05 449
无头链表的两种实现方法 1.利用二级指针实现 思路：创建一个指针list = NULL；该指针永远指向新的节点。 1.1创建结构体 struct Node { int Data; struct Node* next; }; 1.2初始化新的节点 struct Node* CreateNode(int data) { struct Node* NewNode = (struct Node*)malloc(sizeof(struct Node)); NewNode->next = NULL;
【数据结构】无头和有头单链表基本操作的实现与比较（C语言）
weixin_42263122的博客
12-27 403
typedef int DataType; typedef struct SListNode{//结点 struct SListNode* next; DataType data; }SListNode,*PListNode; int main(){ PListNode Phead; } 区别： （1）尾插操作：因为如果链表为空，无头链表需要对头指针Phead进行赋值所以传参时，需要...
单循环链表（不带表头）的C语言实现（详细）
qq_983030560的博客
12-19 1682
单循环链表（不带表头）的C语言实现，非常详细
链表(1)C语言实现 单链表 无头结点 基本操作 无头结点单链表的基本操作 详解 链表的概念及结构 数据结构
weixin_63666347的博客
04-28 2463
3.链表 3.1 链表的概念及结构 概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表 中的指针链接次序实现的 注意： 1.从上图可看出，链式结构在逻辑上是连续的，但是在物理上不一定连续 2.现实中的结点一般都是从堆上申请出来的 3.从堆上申请的空间是按照一定的策略来分配的，两次申请的空间可能连续也可能不连续 3.2 链表的分类 1. 单向或者双向 2. 带头或者不带头 3. 循环或者非循环 3.3 单链表的实现 ...
建立学生信息无头结点单链表C语言版.pdf
06-10
"建立学生信息无头结点单链表C语言版" 本文档介绍了使用 C ...本文档介绍了使用 C 语言建立学生信息无头结点单链表的实现，包括单链表的定义、初始化、销毁、清空、判空、长度、元素访问、前驱、后驱和插入等操作。
Java之单链表篇！！！ （无头单向非循环链表实现打印、头插、尾插、任意插入、查找、删除某一关键字、删除所有所选关键字、清空单链表等基本操作）
12-21
首先对单链表的结构进行介绍，单链表是由很多个节点一个接一个串接起来的，每个节点包含两部分，数据部分和地址部分，我们这里讲的是无头的单链表，所以没有头节点，每个节点存储的是本身的数据和下一个节点的地址。...
单链表基本操作
08-06
可以实现基本的增删改查和反转。对面试很有帮助
《剑指Offer》14. 链表中倒数第k个结点
Coder Yang
02-15 136
题目：14. 链表中倒数第k个结点 知识点：链表、鲁棒性 题目描述： 输入一个链表，输出该链表中倒数第k个结点。 解题思路： 解题的思路比较简单，解法一和解法二都是通过双指针的方法来进行解题的，需要注意的是对一些错误输入的处理，比如： （1）输入的 pListNode 为空指针； （2）输入的以 pListNode 为头结点的链表的结点总数少于 k ； （3）输入的参数 k 为 0...
【剑指Offer】15、链表中倒数第k个结点
qq_41996818的博客
03-31 74
题目描述： 输入一个链表，输出该链表中倒数第k个结点。 剑指offer思路： 第一层：遍历链表两次，第一次统计出链表中节点的个数，第二次找到倒数第k个节点。 第二层：只遍历一次链表，通过两个指针实现，第一个指针先从头开始遍历到第k个节点（走k-1步），从第k步开始第二个指针和第一个指针也开始遍历。 增强代码的鲁棒性： 1.输入的pListHead为空指针 2.输入的以pListHead为头节点的链...
使用双向链表
幸福村的人
04-25 823
 链表在程序设计中是最为基本的数据结构，也是相对最容易出错环节。在C++中，我们能够使用标准的STL链表，以达到软件开发的快速性，重用性和强壮性。那么，我们在C语言中如何达到这样的效果呢？嗯，…，好像ANSC C库暂时还没有吧。现在不妨让我们自己来尝试做一个可重用的双向链表吧J。首先，让我们先浏览一下下面简单演示代码，然后再逐个仔细分析。
（C语言）干货满满！！！面试必备OJ题：链表篇（一）
博主qq1077644249
08-07 1073
这篇博客总结了几个比较常见的有关单链表的面试题，个人觉得题目比较好也比较经典，特地拿出来与小伙伴们分享。
面试题：链表中倒数第k个节点
穷B光头
01-29 156
输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。例如，一个链表有6个节点，从头节点开始，它们的值一次是1、2、3、4、5、6。这个链表的倒数第3个节点是值为4的节点。链表定义如下： struct ListNode {  int m_nValue; ListrNode* m_pNext; }; 思路：双指针循
C++算法之 找出两个链表的公共节点
CppPlayer
12-11 3190
题目：输入两个链表，找出它们第一个公共节点。链表节点定义如下： struct ListNode ｛         int    m_nKey;         ListNode*   m_pNext; ｝     方法1：在第一个链表上顺序遍历每一个节点，没遍历一个节点，在第二个链表上顺序遍历每个节点。  O(n^2) 方法2：找到两个链表的长度差，先遍历长链表到短链表的长度处
链表的建立、头指针、初始化等操作
weixin_40711045的博客
07-30 2387
下面代码主要实现输出指针中倒数k个链表 #include<iostream> #include<cstdio> #include<vector> #include<queue> using namespace std; struct ListNode { int val; struct ListNode *next; ListNode(int...
list_head用法(一)
tanyjin的博客
07-24 2536
list_head用法经常在Linux的kernel里面经常看见，所以记录用法以来备忘 (1)list.h文件在include/linux/list.h#ifndef _LIST_H #define _LIST_H#define _INLINE_ static inlinestruct list_head { struct list_head *next, *prev; };#define
线性表的基本操作：插入、删除、查找等操作在顺序存储结构和链接存储结构上的算法
zxl2016的博客
07-28 8552
第 1次授课  授课时间2006年3月22日 3学时04级541--542班 教案完成时间 2006年2月5日   课程名称 数据结构 专业名称 授课教师/职称 xxx 授课方式（合、小班）   授课题目（章、节）   教材及参考书目 张世和．数据结构．北
java 无头单链表
最新发布
08-26
无头单链表是一种常见的链表数据结构，在 Java 中可以使用自定义的节点类来实现。以下是一个简单的无头单链表的实现示例： ```java class Node { int data; Node next; public Node(int data) { this.data = data; this.next = null; } } class LinkedList { Node head; public LinkedList() { this.head = null; } // 在链表头部插入一个新节点 public void insertAtHead(int data) { Node newNode = new Node(data); newNode.next = head; head = newNode; } // 在链表尾部插入一个新节点 public void insertAtTail(int data) { Node newNode = new Node(data); if (head == null) { head = newNode; return; } Node current = head; while (current.next != null) { current = current.next; } current.next = newNode; } // 打印链表元素 public void printList() { Node current = head; while (current != null) { System.out.print(current.data + " "); current = current.next; } System.out.println(); } } public class Main { public static void main(String[] args) { LinkedList list = new LinkedList(); list.insertAtHead(3); list.insertAtHead(2); list.insertAtHead(1); list.printList(); // 输出: 1 2 3 list.insertAtTail(4); list.insertAtTail(5); list.printList(); // 输出: 1 2 3 4 5 } } ``` 在上述示例中，`Node` 类表示链表节点，包含一个整型数据 `data` 和一个指向下一个节点的引用 `next`。`LinkedList` 类表示链表本身，包含一个指向链表头部的引用 `head`。链表的操作包括在头部插入节点（`insertAtHead`）、在尾部插入节点（`insertAtTail`）和打印链表元素（`printList`）。在 `main` 方法中，我们创建一个链表实例并演示了插入节点和打印链表的操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值