C语言线性单链表相关函数和算法的基本实现

最新推荐文章于 2023-04-07 20:13:15 发布
最新推荐文章于 2023-04-07 20:13:15 发布
阅读量2.1k 收藏 26
点赞数 7
分类专栏： C/C++ 文章标签： C语言 单链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cswfqxs_/article/details/80456840
版权

备考期间尝试写了一些基本数据结构的C语言实现，现做以下记录（基本数据元以int型为例）：

全局定义及依赖：

#include <stdio.h> 
#include <stdlib.h>
#define OK  1
#define ERROR  0
#define END NULL

链表结点定义：

typedef struct Lnode
{
	int data;
	struct Lnode *next;
}Node,*linkedList;

链表初始化：

//初始化链表 
linkedList initList()
{
	Node *L;
	L = (Node *)malloc(sizeof(Node));
	if(L==NULL)
	{
		printf("Init error!");
	}
	L->next = NULL;
	printf("Init OK!\n");
	return L;
}
头插法生成链表 即在头结点后插入新元素 ： 
//头插法生成链表 即在头结点后插入新元素 
linkedList createListH(int n)
{
	int i = 0;
	Node *L;
	L = (Node *)malloc(sizeof(Node));
	L->next = NULL;
	
	int x;
	while(i<n)
	{
		scanf("%d",&x);
		Node *p;
		p = (Node *)malloc(sizeof(Node));
		p->data = x;
		p->next = L->next;
		L->next = p;
		i++;
	}
	return L;
}
尾插法生成链表 即在尾结点后插入新元素： 
//尾插法生成链表 即在尾结点后插入新元素
linkedList createListT(int n)
{
	int i = 0;
	Node *T;
	T = (Node *)malloc(sizeof(Node));
	T->next = NULL;
	
	Node *r;
	r = T;
	int x;
	while(i<n)
	{
		scanf("%d",&x);
		Node *p;
		p = (Node *)malloc(sizeof(Node));
		p->data = x;
		r->next = p;
		r = p;
		i++;
	}
	r->next = NULL;
	return T;
}

计算链表长度：

//calculate the length
int calculateLength(linkedList L)
{
	int length = 0;
	Node *p = L;
	while(p->next)
	{
		length++;
		p = p->next;
	}
	return length;
}

在指定链表的指定索引处插入新值：

//insert element into index x
int insertElementIntoX(linkedList L,int index,int e)
{
	Node *p = L;
	int length = calculateLength(L);

	if(index<1||index>length+1){return ERROR;}
	else
	{
		for(int i = 1;i<index;i++)
		{
			p = p->next;
		}
		Node *q = (Node *)malloc(sizeof(Node));
		q->data = e;
		q->next = p->next;
		p->next = q;
		return OK;
	}
}

通过索引删除指定链表中的元素：

//delete element by index
int deleteElementByIndex(linkedList L,int index)
{
	int length = calculateLength(L);
	if(index<1||index>length){return ERROR;}
	else
	{
		Node *p = L;
		for(int i = 1;i<index;i++)
		{
			p = p->next;
		}
		Node *q = p->next;
		p->next = q->next;
		free(q);
		return OK;
	}
}

遍历并打印链表中所有结点元素：

//遍历 
void traversalList(linkedList L)
{
	Node *p = L->next;
	while(p!=END)
	{
		printf("%d ",p->data);
		p = p->next;
	}
	printf("\n");
}

对两个链表做非递减归并：

linkedList mergeDecline(linkedList La,linkedList Lb)
{
	Node *a = La->next;
	Node *b = Lb->next;
	free(La);
	free(Lb);
	linkedList Lc = initList();
	Node *temp = Lc;
	while(a!=NULL&&b!=NULL)
	{
		if(a->data<=b->data)
		{
			temp->next = a;
			a = a->next;
			temp = temp->next; 
		}
		else
		{
			temp->next = b;
			b = b->next;
			temp = temp->next;
		}
	}
	temp->next == NULL;
	if(a!=NULL){temp->next = a;}
	if(b!=NULL){temp->next = b;}
	return Lc;
}

删除给定链表中所有重复元素（对重复元素只保留其中一个）：

//delete repeating node  
void deleteRepeatingNode(linkedList L)
{
	Node *p,*q,*r;
	p = L->next;
	if(p==NULL){return;}
	while(p->next)
	{
		q = p;
		while(q->next)
		{
			if(q->next->data==p->data)
			{
				r = q->next;
				q->next=r->next;
				free(r);
			}
			else
			{
				q = q->next;
			}
		}
		p = p->next;
	}
}

将链表中的元素按从小到大进行排序：

//sort from small to large
int sortFSL(linkedList L)
{
	if(L->next==NULL){return ERROR;}
	else
	{
		Node *r = L;
		Node *p = r->next;
		Node *q = p->next;
		while(p->next)
		{
			while(q)
		    {
			  if(p->data>q->data)
			  {
				   int e = p->data;
				   p->data = q->data;
				   q->data = e;
				   q = q->next;
			  }
			
			  else
			  {
				  q = q->next;
			  }
		    }
		    
		    r = r->next;
		    p = p->next;
		    q = p->next;
		}
		return OK;
	}
	
}

删除链表中所有元素值大于x的结点：

int deleteAGTX(linkedList L,int x) 
{
	if(L->next==NULL){return ERROR;}
	else{
		Node *p = L;
		while(p->next)
		{
			if(p->next->data>x)
			{
				Node *temp = p->next;
				p->next = p->next->next;
				free(temp);
			}
			else{
				p = p->next;
			}
		}
		return OK;
	}
}

将链表中所有负数前置并排序：

//负数在前排序 
int negativePriority(linkedList L)
{
	if(L->next==NULL){return ERROR;}
	else{
		Node *p = L;
		while(p->next)
		{
			if(p->next->data<0)
		    {
			  Node *temp = p->next;
			  p->next = temp->next;
			  temp->next = L->next;
			  L->next = temp;
		    }
		    else{p = p->next;}
		}
		return OK;
	}
}

南京航空航天大学922部分真题：

//2014真题-数据结构6
int _2014_T6(linkedList L)
{
	if(L->next==NULL){return ERROR; }
	else{
		Node *p = L;
		Node *t = NULL;
		Node *s = NULL;
		int count = 1;
		while(p->next)
		{
			if(count%2==0)
			{
				t = p->next;
				p->next = p->next->next; //关键步骤 
				t->next = s;
				s = t;
			}
			else{
				p = p->next;
			}
			count++;
		}
		p->next = s;
		return OK;
	}
} 

//2015真题数据结构6
int _2015_T6(linkedList L)
{
	if(L->next==NULL){return ERROR; }
	else{
		Node *p = L->next;
		Node *q = L->next;
		Node *t = L;
		Node *top = NULL;
		while(p->next)
		{
			while(q->next)
			{
				if(q->next->data>p->data)
				{
					p = q->next;
					t = q;
					q = q->next;
				}
				else{
					q = q->next;
				}
			}
			t->next = t->next->next;
			p->next = top;
			top = p;
			t = L;
			p = q = L->next;
		}
		p->next = top;
		return OK;
	}
} 

//2013真题数据结构6
int _2013_T6(linkedList La,linkedList Lb)
{
	if(La->next==NULL){return ERROR;}
	else{
		Node *a = La;
		Node *b = Lb;
		int element;
		while(a->next)
		{
			element = a->next->data;
			while(b->next)
			{
				if(b->next->data==element){break;}
				else{b = b->next;}
			}
			
			if(b->next==NULL)
			{
				Node *t = a->next;
				a->next = a->next->next;
				free(t);
			}
			else{a = a->next;} 
			b = Lb;
		}
		
		a = La;
		while(a->next)
		{
			Node *p = La->next;
			int e;
			while(p->next)
			{
				if(p->next->data>a->next->data)
				{
					e = a->next->data;
					a->next->data = p->next->data;
					p->next->data = e;
				}
				p = p->next;	
			}
			a = a->next;
		}
		return OK;
	}
}

//2011真题-数据结构24
int _2011_T24(linkedList L)
{
    if(L->next == NULL){return ERROR;}
    else{
    		Node *p = L;
	        int element = p->next->data;
	        while(p->next)
	        {
		       if(element>p->next->data)
		       {
			      element = p->next->data;
		       }
		       p = p->next;
	        }
	        p = L;
	        while(p->next)
	        {
	        	if(p->next->data==element)
	        	{
	        		Node *t = p->next;
	        		p->next = p->next->next;
	        		free(t);
	        		break;
	        	}
	        	p = p->next;
	        }
	        return OK;
    }
}

使用单链表实现数制转换（1-10进制）：

//数制转换（1-10进制）
void transCodeR(int num,int r)
{
	linkedList L = initList();
	L->data = -1;
	Node *top = NULL;
	int i;
	while(num>0)
	{
		i = num%r;
		top = (Node *)malloc(sizeof(Node));
		top->data = i;
		top->next = L;
		L = top;
		num = num/r;
	}
	printf("The result is: ");
	while(top->data!=-1)
	{
		printf("%d ",top->data);
		top = top->next;
	}	
}

测试：

int main()
{
	int n = 0;
	
	printf("Please enter the length:\n");
	scanf("%d",&n);
	linkedList La = createListT(n);
	printf("Traversal the list a:\n");
	traversalList(La);
	
	printf("Please enter the length:\n");
	scanf("%d",&n);
	linkedList Lb = createListT(n);
	printf("Traversal the list b:\n");
	traversalList(Lb);

    traversalList(mergeDecline(La,Lb)); //Merge
    
    printf("Please enter the length:\n");
	scanf("%d",&n);
	linkedList Ld = createListT(n);
	traversalList(Ld);
    deleteRepeatingNode(Ld);  //delete repeating node
    traversalList(Ld);
    
    int index,element;
    printf("Please enter the length:\n");
	scanf("%d",&n);
	linkedList Le = createListT(n);
	traversalList(Le);
	printf("Please enter the index:\n");
	scanf("%d",&index);
	printf("Please enter the element:\n");
	scanf("%d",&element);
	insertElementIntoX(Le,index,element);  //insert element into index x
	traversalList(Le);
	
	int index;
	printf("Please enter the length:\n");
	scanf("%d",&n);
	linkedList Lf = createListT(n);
	traversalList(Lf);
	printf("Please enter the index:\n");
	scanf("%d",&index);
	deleteElementByIndex(Lf,index);  //delete element by index
	traversalList(Lf);
	
    printf("Please enter the length:\n");
	scanf("%d",&n);
	linkedList Lg = createListT(n);
	traversalList(Lg);
	sortFSL(Lg);         //sort from small to large
	traversalList(Lg);
    
    int x;
    printf("Please enter the length:\n");
	scanf("%d",&n);
	linkedList Lh = createListT(n);
	traversalList(Lh);
	printf("Please enter the value:\n");
	scanf("%d",&x);
	deleteAGTX(Lh,x);         //P3-3-2-3-1 删除所有元素值大于x的结点
	traversalList(Lh);
	
    printf("Please enter the length:\n");
	scanf("%d",&n);
	linkedList Li = createListT(n);
	traversalList(Li);
	negativePriority(Li);         //负数在前排序
	traversalList(Li);
	
	printf("Please enter the length:\n");
	scanf("%d",&n);
	linkedList Lj = createListT(n);
	traversalList(Lj);
	_2014_T6(Lj);         //2014真题-数据结构6
	traversalList(Lj);
	
	printf("Please enter the length:\n");
	scanf("%d",&n);
	linkedList Lk = createListT(n);
	traversalList(Lk);
	_2015_T6(Lk);         //2015真题-数据结构6
	traversalList(Lk);
	
	printf("Please enter the length:\n");
	scanf("%d",&n);
	linkedList Ll = createListT(n);
	traversalList(Ll);
	printf("Please enter the length:\n");
	scanf("%d",&n);
	linkedList Lm = createListT(n);
	traversalList(Lm);
	_2013_T6(Ll,Lm);         //2013真题-数据结构6
	traversalList(Ll);
	
    printf("Please enter the length:\n");
	scanf("%d",&n);
	linkedList Ln = createListT(n);
	traversalList(Ln);
	_2011_T24(Ln);
	traversalList(Ln);  //2011真题-数据结构24
	
	int num;
	printf("Please enter the num:\n");
	scanf("%d",&num);
	printf("Please enter the r:\n");
	scanf("%d",&n);
	transCodeR(num,n);
	
	return 0;
}


此生无分起相思
关注
  • 7
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用C语言实现的常见数据结构和算法.zip
10-09
这个名为"使用C语言实现的常见数据结构和算法.zip"的压缩包很可能包含了多种常用的数据结构及其相关的算法实现，旨在帮助学习者通过C语言提升自己的编程技能。 数据结构是组织、存储和管理数据的方式，它允许我们...
C语言实现单链表（带头结点）的基本操作.zip
最新发布
10-19
通过分析和理解这些函数，开发者可以学习如何在C语言中有效地管理和操作单链表，这对于理解和编写更复杂的数据结构和算法至关重要。熟悉这些基本操作对于提升编程能力，尤其是处理动态数据集合的场景，如实现高效...
数据结构：线性表（链表的实现）
qq_59325159的博客
03-03 694
顺序存储与链式存储的优缺点 链表操作 单链表(带头结点)的代码实现
数据结构-线性表（链表的实现）
qq_58969626的博客
04-07 552
单链表只能通过前驱结点（previous -> prev）找到后继结点（next），无法通过后继结点找到前驱结点。在单链表中第一个结点是最重要的，称为头结点（head）；最后一个结点称为尾结点（last）。
一文解决用C语言实现一个链表（全都是细节）
胡坚涛的博客
01-06 1704
链表是指数据使用一个一个的结点连接起来的数据结构，这样的数据结构中不像顺序表一样，顺序表中不同的数据在内存中的存储空间是相邻的，链表中的相邻结点在内存中的存储位置是没有任何关系的，每一个链表都是由许多的结点组成的，而一个链表，我们需要一个对应的头指针来管理这个链表，也就是说，如果我们拥有一个链表的头指针，那么我们就可以拿到这个链表中的所有的结点，在此基础上，如果我们还学会对链表中的结点进行一些常见的操作（增删查改），那么我们就可以熟练使用链表来解决现实中的问题了
【笔记】C++链表实现线性表基本操作
西木的博客
10-19 2014
c++链表实现线性表的基本操作，包括顺序、逆序构建线性表等
线性链表的操作实现
qq_55109560的博客
01-02 1310
一、上机实验的问题和要求： 线性表链式存储结构下基本操作的实现（初始化、赋值、取值、插入、删除、等）。 二、基本思想，原理和算法描述： 首先基于线性表的链式存储结构建一个单链表（下面的程序实现的是通过头插法逆序建表），在此基础上实现对单链表的赋值、取值、插入、删除以及两个表的归并，需要注意的是插入（删除）过程中指针的修改。 源程序及注释 //线性表链式存储结构下基本操作的实现（初始化、建表、取值、插入、删除、归并等） #include<iostream> usingnamespac.
用C语言来实现数据结构和算法.zip
10-09
标题"用C语言来实现数据结构和算法"暗示我们将探讨如何利用C语言来构建和实现各种数据结构（如数组、链表、栈、队列、树、图等）以及基本的算法（如排序、搜索、递归等）。这包括但不限于以下几个方面： 1. **数组*...
C语言版本 单链表实现，亲测可用
04-25
总结来说，这个C语言实现的单链表提供了全面的操作，对于学习数据结构和C语言编程的初学者来说，是一个很好的实践案例。它涵盖了链表的基本概念、结构体定义、指针操作以及动态内存管理，这些都是C语言编程的核心...
C语言实现单链表的增删查改
03-25
本篇文章将深入探讨如何用C语言实现单链表的增、删、查、改四种基本操作。 ### 1. 单链表的基本结构 首先，我们需要定义一个链表节点结构体，如下所示： ```c typedef struct Node { int data; // 数据域，这里...
线性链表的基本操作（C语言）
10-24
线性链表的基本操作; 插入 删除 排序 初始化 判空 销毁 求长度...，都是些基本操作
线性链表的实现
03-06
具有链接存储结构的线性表，它用一组地址任意的存储单元存放线性表中的数据元素，逻辑上相邻的元素在物理上不要求也相邻，不能随机存取。一般用结点描述：结点（表示数据元素） =数据域（数据元素的映象） + 指针域（指示后继元素存储位置）
数据结构之线性表的链式存储实现（附完整代码）
热门推荐
玥玥的博客博客博客
08-10 2万+
顺序表插入、删除时需要通过移动数据来实现，影响了执行效率。 而链表不要求逻辑上相邻的两个数据元素物理上也相邻，因此对线性表的插入、删除不需要移动数据元素，只需要修改链。 下面介绍带头结点的链式表： 数据结构： typedef int ElementType; typedef struct LNode * PtrToLNode; struct LNode{ ElementType Dat...
用C语言实现单链表操作
xuzhougeng blog
02-02 6595
用C写一个链表 链表(Linked List)是一种非连续的线性数据结构，相对于数组，它允许数据在内存中非连续存储，但是不支持随机读取。 链表 链表由一个个节点(Node)组成，每个节点除了记录数据以外，还需要记录下一个节点的位置（如果是双向链表，还需要记录上一个节点的位置） struct _Node; typedef struct _Node Node; struc...
线性表的链式实现(单链表)
tecoes的博客
05-24 1299
单链表的定义 为了表示每个数据元素与其直接后续元素之间的逻辑关系，每个元素除了存储本身的信息外，还需要存储指示其直接后续的信息，即每个结点存放本身的数据元素和下一个元素的地址。n个结点连接成一个链式线性表的结构我们叫做链表，当每个结点只包含一个指针域时，叫做单链表。 首先给出一个线性表，存放数据元素，a1到 an有这样的线性逻辑关系。单链表在存储空间上是这样存放的，它是存放在任意位置的，这个任意位置表示它们不一定要连续。如图所示的 a2、a3与 a3、a4。 第二个很明显的差别是单链表在存...
数据结构——C语言实现链表
theonly_Love的博客
05-22 1万+
一. 链表的概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。在这里介绍链表中的两种结构
c语言线性表的链式表示和实现
tellsummer的博客
12-26 7073
/*线性表的链式存储实现*/ #include<stdio.h> #include<stdlib.h> #include<malloc.h> typedef struct node{ int data; struct node *next; }Node,*pNode; //创建一个带头节点的空单链表 pNode CreateListHead(void){ pNode L =
单链表操作
面朝大海，春暖花开
04-08 692
//////////////////////////////////////////// //单链表的初始化，建立，插入，查找，删除。// //Author:Wang Yong          //  //Date: 2010.8.19          // //////////////////////////////////////////// #include "stdafx.h
C语言实现队列(链表实现)
y6df7的博客
07-13 1万+
队列 (Queue) :也是运算受限的线性表。是一种先进先出 (First In First Out ,简称 FIFO) 的线性表。只允许在表的一端进行插入,而在另一端进行删除。  队首 (front) :允许进行删除的一端称为队首。    队尾 (rear) :允许进行插入的一端称为队尾。   代码： #include &lt;stdio.h&gt; #include &lt;std...
线性方程组的数值算法C语言实现(附代码).docx
05-30
除了基本的线性方程组求解算法，C语言还提供了丰富的数学库函数和线性代数库函数，例如math.h和lapack.h等，这些库函数提供了大量的数学计算和矩阵运算函数，可以帮助我们更加方便地实现线性方程组的数值计算。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值