数据结构二线性表的链式实现

最新推荐文章于 2022-12-29 21:18:01 发布
最新推荐文章于 2022-12-29 21:18:01 发布
阅读量475 收藏 3
点赞数 1
文章标签： 数据结构 链表 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/nonabird/article/details/121726436
版权
本文展示了几个关于链表的操作实例，包括创建链表、按输入顺序存储整数、排序、合并及去重。程序实现了从键盘输入10个整数并保持输入顺序的链表，随机生成100个整数并按升序排序的链表，以及合并两个已排序链表并去重。此外，还涵盖了将链表分为正负数两类以及在循环双向链表中按序和逆序输出整数的方法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1、从键盘输入10个整数放入链表，要求链表中的元素与输入顺序一致，然后输出该链表。

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
struct node{
	int data;
	struct node* next;
};


struct node* createlist()
{
	struct node* headnode =(struct node*)malloc(sizeof(struct node));
	headnode->next=NULL;
	return headnode;
}

struct node* createnode(int data)
{   
   struct node* newnode=(struct node*)malloc(sizeof(struct node));
   newnode->data=data;
   newnode->next=NULL;
   return newnode;
}
void printlist(struct node* headnode)
{ 
  struct node* pmove=headnode->next;
  while (pmove)
  {
  	printf("%d ",pmove->data);
  	pmove=pmove->next;
  }
  printf("\n");
}


void charu(struct node* lastnode,int data)
{
	struct node* newnode=createnode(data);
	struct node* posnode=lastnode;
	while(posnode->next!=NULL)
	{
	posnode=posnode->next;
	}
	posnode->next=newnode;
}



int main(){
	int i,n;
	
	struct node* list=createlist();
	for(i=0;i<10;i++){  
	scanf("%d",&n);                           
	charu(list,n);}
	printlist(list);
	return 0;
}

2、随机生成100个随机整数并放入一个链表中，要求链表中的元素按从小到大顺序排列，然后输出该链表。

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
struct node{
	int data;
	struct node* next;
};


struct node* createlist()
{
	struct node* headnode =(struct node*)malloc(sizeof(struct node));
	headnode->next=NULL;
	return headnode;
}

struct node* createnode(int data)
{   
   struct node* newnode=(struct node*)malloc(sizeof(struct node));
   newnode->data=data;
   newnode->next=NULL;
   return newnode;
}
void printlist(struct node* headnode)
{ 
  struct node* pmove=headnode->next;
  while (pmove)
  {
  	printf("%d ",pmove->data);
  	pmove=pmove->next;
  }
  printf("\n");
}


void charu(struct node* lastnode,int data)
{
	struct node* newnode=createnode(data);
	struct node* posnode=lastnode;
	while(posnode->next!=NULL)
	{
	posnode=posnode->next;
	}
	posnode->next=newnode;
}
void paixucharu(struct node* l,int x)
{
	struct node* newnode=createnode(x);
	struct node* p=l;
	while(p->next!=NULL&&p->next->data<=x)
	{
	p=p->next;
	}
	newnode->next=p->next;
	p->next=newnode;
	
}


int main(){
	int i,n;
	srand((int)time(NULL)); 
	struct node* list=createlist();
	for(i=0;i<100;i++){                              //2.随机数排序 
	n=rand()%100;
	paixucharu(list,n);}
	printlist(list);
	return 0;
}

3、将两个从小到大排列的链表合并为一个新链表（仍然有序排列），输出合并前的两个链表，输出合并后的链表，检查合并是否成功。

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
struct node{
	int data;
	struct node* next;
};


struct node* createlist()
{
	struct node* headnode =(struct node*)malloc(sizeof(struct node));
	headnode->next=NULL;
	return headnode;
}

struct node* createnode(int data)
{   
   struct node* newnode=(struct node*)malloc(sizeof(struct node));
   newnode->data=data;
   newnode->next=NULL;
   return newnode;
}
void printlist(struct node* headnode)
{ 
  struct node* pmove=headnode->next;
  while (pmove)
  {
  	printf("%d ",pmove->data);
  	pmove=pmove->next;
  }
  printf("\n");
}


void charu(struct node* lastnode,int data)
{
	struct node* newnode=createnode(data);
	struct node* posnode=lastnode;
	while(posnode->next!=NULL)
	{
	posnode=posnode->next;
	}
	posnode->next=newnode;
}
void paixucharu(struct node* l,int x)
{
	struct node* newnode=createnode(x);
	struct node* p=l;
	while(p->next!=NULL&&p->next->data<=x)
	{
	p=p->next;
	}
	newnode->next=p->next;
	p->next=newnode;
	
}
void hebing(struct node* l1,struct node* l2,struct node* l3){
	while(l2->next!=NULL)
	{
	l2=l2->next;
	paixucharu(l3,l2->data);
	}

	while(l1->next!=NULL)
	{
	l1=l1->next;
	paixucharu(l3,l1->data);
	}
	
	
}

int main(){
	int i,n;
	srand((int)time(NULL)); 
	struct node* list1=createlist();
	struct node* list2=createlist();
	struct node* list3=createlist();
	for(i=0;i<5;i++){
	n=rand()%100;
	paixucharu(list1,n);}
	for(i=0;i<5;i++){
	n=rand()%100;
	paixucharu(list2,n);}                 //3.合并链表 
	
	hebing(list1,list2,list3);
	printlist(list1);
	printlist(list2);
	printlist(list3);
	return 0;
}

4、将两个从小到大排列的链表合并为一个新链表（仍然有序排列），若遇到相同的元素，则在合并时去掉重复元素。输出合并前的两个链表，输出合并后的链表，检查合并是否成功。

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
struct node{
	int data;
	struct node* next;
};


struct node* createlist()
{
	struct node* headnode =(struct node*)malloc(sizeof(struct node));
	headnode->next=NULL;
	return headnode;
}

struct node* createnode(int data)
{   
   struct node* newnode=(struct node*)malloc(sizeof(struct node));
   newnode->data=data;
   newnode->next=NULL;
   return newnode;
}
void printlist(struct node* headnode)
{ 
  struct node* pmove=headnode->next;
  while (pmove)
  {
  	printf("%d ",pmove->data);
  	pmove=pmove->next;
  }
  printf("\n");
}


void charu(struct node* lastnode,int data)
{
	struct node* newnode=createnode(data);
	struct node* posnode=lastnode;
	while(posnode->next!=NULL)
	{
	posnode=posnode->next;
	}
	posnode->next=newnode;
}

void paixucharu(struct node* l,int x)
{
	struct node* newnode=createnode(x);
	struct node* p=l;
	while(p->next!=NULL&&p->next->data<=x)
	{
	p=p->next;
	}
	newnode->next=p->next;
	p->next=newnode;
	
}
int paixucharu2(struct node* l,int x)
{
	struct node* newnode=createnode(x);
	struct node* p=l;
	while(p->next!=NULL)
	{
	p=p->next;
	if(p->data==x)
	return 0;
	}
	p=l;
	while(p->next!=NULL&&p->next->data<x)
	{
	p=p->next;
	}
	newnode->next=p->next;
	p->next=newnode;
	
}
void hebing2(struct node* l1,struct node* l2,struct node* l3){
	
	
	
	while(l1->next!=NULL)
	{
	l1=l1->next;
	paixucharu2(l3,l1->data);
	}
	while(l2->next!=NULL)
	{
	l2=l2->next;
	paixucharu2(l3,l2->data);
	}

}


int main(){
	int i,n;
	srand((int)time(NULL)); 
	struct node* list1=createlist();
	struct node* list2=createlist();
	struct node* list3=createlist();
	for(i=0;i<5;i++){
	n=rand()%100;
	paixucharu(list1,n);}
	for(i=0;i<5;i++){
	n=rand()%100;
	paixucharu(list2,n);}                 //4.合并链表并且清除重复的数 
	
	hebing2(list1,list2,list3);
	printlist(list1);
	printlist(list2);
	printlist(list3);
	return 0;
}

5、随机生成100个整数存入链表，整数范围在[-100, 100]之间，输出该链表。将该链表分为两个，一个存放所有负整数，另一个存放所有非负整数，输出这两个链表。

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
struct node{
	int data;
	struct node* next;
};


struct node* createlist()
{
	struct node* headnode =(struct node*)malloc(sizeof(struct node));
	headnode->next=NULL;
	return headnode;
}

struct node* createnode(int data)
{   
   struct node* newnode=(struct node*)malloc(sizeof(struct node));
   newnode->data=data;
   newnode->next=NULL;
   return newnode;
}
void printlist(struct node* headnode)
{ 
  struct node* pmove=headnode->next;
  while (pmove)
  {
  	printf("%d ",pmove->data);
  	pmove=pmove->next;
  }
  printf("\n");
}


void charu(struct node* lastnode,int data)
{
	struct node* newnode=createnode(data);
	struct node* posnode=lastnode;
	while(posnode->next!=NULL)
	{
	posnode=posnode->next;
	}
	posnode->next=newnode;
}

void paixucharu(struct node* l,int x)
{
	struct node* newnode=createnode(x);
	struct node* p=l;
	while(p->next!=NULL&&p->next->data<=x)
	{
	p=p->next;
	}
	newnode->next=p->next;
	p->next=newnode;
	
}


void fenlei(struct node* l1,struct node* l2,struct node* l3){
	while(l1->next!=NULL)
	{
	l1=l1->next;
	if(l1->data<0)
	paixucharu(l2,l1->data);
	else
	paixucharu(l3,l1->data);
	}
}


int main(){
	int i,n;
	srand((int)time(NULL)); 
	struct node* list1=createlist();
	struct node* list2=createlist();
	struct node* list3=createlist();
	for(i=0;i<5;i++){
	n=rand()%200-100;
	paixucharu(list1,n);}
                                //5.正负数分类 
	
	fenlei(list1,list2,list3);
	printlist(list1);
	printlist(list2);
	printlist(list3);
	return 0;
}

6、随机生成10个整数存入一个循环双向链表中，然后按序输出这些整数和逆序输出这些整数。

#include <stdio.h>
#include <stdlib.h>
#include<time.h>
typedef struct DNode
{
    int data;
    struct DNode *next,*Previous;
}Node,*LinkList;

void InitList(LinkList *L)
{
    *L=(LinkList)malloc(sizeof(DNode));
      (*L)->data=0;
    (*L)->next=(*L)->Previous=*L;
}

void CreateLink(LinkList L,int n)
{   srand((int)time(NULL)); 
     
    LinkList p=L,q;
    while(n--)
    {   int x=rand()%200-100;
        q=(LinkList)malloc(sizeof(DNode));
        q->data=x;
        p->next=q;
        q->Previous=p;
        q->next=L;//尾插法
        L->Previous=q;
        p=q;
    }
}

void TraverseList(LinkList L,int i)
{   int x=0;
    LinkList p=L->Previous;
    LinkList q=L->next;
    while(x<i)
    {
        printf("%d ",p->data);
        p=p->Previous;
        x++;
    }
    printf("\n");
    x=0;
    while(x<i)
    {
        printf("%d ",q->data);
        q=q->next;
        x++;
    }
}

int main()
{
	srand((int)time(NULL)); 
    int n;
    LinkList L;
    InitList(&L); 
    CreateLink(L,10);  //0代表头节点的值，改变TraverseList的值改变输出的值
    TraverseList(L,10);
    return 0;
}
nonabird
关注
学习记录：第二章 线性表的链式存储_单链表_插入删除查找三种基本操作以及求表长（代码、图示、C++）
weixin_45790081的博客
05-09 2032
本文给出了单链表的插入和删除两种基本操作的代码及相应图示助于理解，代码实现使用的是C语言在线工具。无概念解释，初学者建议配合书本食用。
实验二线性表综合实验2
wujiancai1163的博客
10-21 492
一．实验目的      巩固线性表的数据结构的存储方法和相关操作，学会针对具体应用，使用线性表的相关知识来解决具体问题。 二．.实验内容 1.建立一个由n个学生成绩的顺序表，n的大小由自己确定，每一个学生的成绩信息由自己确定，实现数据的对表进行插入、删除、查找等操作。分别输出结果。 要求如下： 2）用单链表来实现。 三、源代码 #inclu
C 链表 从原始到进阶
qq_59193771的博客
01-17 359
#include <stdio.h> #include <stdlib.h> struct Node { int data; struct Node* next; }; int main() { //创建头指针 struct Node* headNode = (struct Node*)malloc(sizeof(struct Node)); headNode->next = NULL; //插入值 //先创建一格并...
单链表笔记（c语言实现）
m0_73705305的博客
12-29 725
一般结构体指针在存储空间中互不干扰，每一个变量的下一个节点都指向NULL（空）之前的是静态的单链表，要制作动态的单链表，需要结构体指针变量。用动态内存申请malloc函数，申请一块动态内存。将结构体变量和结构体变量通过结构体指针连接在一起。如何将结构体指针（节点）变成一个变量呢？节点一般情况下是由数据域和指针域结合。创建链表（创建一个表头表示整个链表）为了插入，删除节点等操作的进行。动态内存申请+模块化设计。删除节点（指定位置删除）打印/遍历链表（测试）从第二个节点开始打印。
初识动态链表
weixin_53616401的博客
05-05 418
什么是链表？链表是结构体变量与结构体变量链接在一起，通过结构体指针链接在一起 如何动态创建链表：动态内存申请+模块化设计 1.创建链表 如何从结构体指针变成结构体变量我们需要动态内存申请 这句代码 struct Node* headnod = (struct Node*)malloc(sizeof(struct Node)); 就是把结构体指针变成结构体变量 malloc是库函数，作用是分配所需内存空间 struct Node { int date; struct Node* next
C语言 数字实现字母表 链表实现字母表
qq_50119037的博客
01-11 1025
数组 #include<stdio.h> int main() { char a[26] = {0}; char* p = a; char temp = 97; for (int i = 0; i < 26; i++) { *p = temp; temp += 1; p++; } for (int i = 0; i < 26; i++) { printf("%c", a[i]); } } 链表 #include<stdio.h> #
c程序设计语言考试题,计算机二级考试-c程序设计语言-上机题库.doc
weixin_28698129的博客
05-17 511
计算机二级考试-c程序设计语言-上机题库.doc第一套填空给定程序的功能是调用fun函数建立班级通顺录。通讯录中记录每位学生的编号、姓名和电话号码。班级的人数和学生的信息从键盘读入，每个人的信息作为一个数据块写到名为myfile5.dat的二进制文件中。1、STYPE 2、FILE 3、fp改错先将在字符串S中的字符按正序存放到t串中，然后把s中的字符按逆序连接到t串的后面。例如当s中的字符串为“...
《数据结构》实验指导：线性表的顺序与链式存储
实验二线性表涉及的是数据结构中的核心概念——线性表。线性表是一个包含n（n>=0）个数据元素的集合，这些元素之间具有逻辑上的线性关系，即每个元素都有一个前驱元素和一个后继元素，除了第一个元素没有前驱，最后...
设置一个学生信息管理系统，实现对学生信息的一下操作，应以线性表的顺序，存储结构，创建学生信息顺序表 二线性表的历史存储结构单链表，创建学生信息代列表，三在这两种存储结构上实现学生数据的数插入展出和按序号查找的算法
最新发布
10-19
1. 存储结构：使用数组作为底层数据结构，学生信息通过索引直接访问。 ```java public class StudentInfoManager { private Student[] students; private int size; public void init(int capacity) { students...
数据结构实验报告：线性表到图的操作
实验旨在通过编程实践掌握数据结构中的核心概念，包括线性表的顺序存储和链式存储、二叉树的遍历、哈夫曼编码的构建以及图的深度遍历、广度遍历和最小生成树算法。" 实验报告详细内容： 1. 实验一线性表的基本操作...
c语言之单链表的创建与应用
m0_59998867的博客
08-26 601
1.定义结构体 #include //定义结构体 struct node{ int data; struct node* next; }; 2.创建链表 struct node* creatlist() { struct node* headnode = (struct node*)malloc(sizeof(struct node)); //headnode 成为了结构体变量 //变量使用前必须被初始化 //headnode->dat..
基础数据结构———有头链表（小白学习笔记）
lspdd的博客
01-31 772
链表就是不连续的内存块通过指针联系起来成为一个数组（个人的理解） 结构体的两大块：数据块，指针块 我们可以通过结构体来实现链表 但是如何新建一个链表呢，我这里讲一个有头链表 头的话就是没有数据域只有指针，带向后面的节点，后面的节点再指向一个节点 我们可以用结构体先表现出来节点 struct node { int data; struct node* next; }; 创建有头链表：即分配头指针空间并把指针指向NULL: struct node* creatlist() { struct node*
单链表头插法
weixin_52336181的博客
12-26 871
/* 头插法定义链表 */ #include<iostream> #include<stdio.h> #include<stdlib.h> /* 当使用数据结构体类型时 struct data{//学生类型 double name;//姓名 int num;//学号 int math;//分数 } */ using namespace std; struct Node{ int data; struct Node*...
C语言 定义一个单向链表，依次从键盘输入10个整数，通过动态内存分配建立链表的节点，将节点按保存整数值从小到大的顺序插入到单链表中，最后输出这个单链表
qq_44248821的博客
11-20 3244
题目：C语言 定义一个单向链表，依次从键盘输入10个整数，通过动态内存分配建立链表的节点，将节点按保存整数值从小到大的顺序插入到单链表中，最后输出这个单链表 是不是要先排序再建立动态链表，再建立输出链表呀？ 各位老师能帮我看一下这个题目代码具体应该怎么写呀，谢谢大家(*°∀°)=3 ...
C语言的键盘输入和屏幕输出
SqrsCbrOnly1的博客
06-10 9771
键盘输入和屏幕输出是编写简单的顺序结构程序时最常用到的操作。C程序中的键盘输入和屏幕输出都是通过调用输入/输出函数实现的。本章介绍常用的输入/输出函数。 一、单个字符的输入/输出 1.字符常量 C语言中的字符常量是用单引号括起来的一个字符。例如，‘a’是字符常量，而a则是一个标识符。再如，‘3’表示一个字符常量，而3则表示一个整数。 把字符放在一对单引号的做法，适用于多数可打印字符，但不适用于某些...
C语言双向链表（创建、插入、遍历、删除）
cp_srd的博客
04-13 607
#ifndef DLIST_H #define DLIST_H typedef struct NODE { int data; struct NODE *pre; struct NODE *next; }node; node *createhead(void); node *createnode(int data); void insertbyhead(node* hea...
C语言学习笔记——链表（单链表）
唐学长的博客
02-15 1650
链表是什么呢，其实就是数据的一种存储方式。相对于线性存储，链表是链式存储。它不像数组，每个元素的物理地址是相邻的。链表中每个元素（通常称为节点）的地址是随机的。每当要添加新节点时，链表就要开辟新的空间。即有多少个节点，就开辟多少空间，不会造成空间浪费，这就是链表的优势所在。
【Dev-c++】C语言数据结构实验——线性表
m0_52474147的博客
07-24 7618
基本原理在顺序表的第i个位置上插入一个元素时，必须先将线性表的第i个元素之后的所有元素依次后移一个位置，以便腾空一个位置，在把新元素插入到该位置。如，在第2个位置上插入元素43，然后输出顺序表。基本原理在带头结点的单链表中第i（从1开始计数）个位置之后插入元素、创建带头结点的单链表、在带头结点的单链表中删除第i个位置的元素等，最后输出单链表的内容。3）将未完成的代码补充完整，然后选择菜单中的“组建”下拉菜单中的“执行”，或者直接点击工具栏中的“”进行连接，调试和运行。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值