计算机考研数据结构--链表部分

最新推荐文章于 2024-08-15 09:00:00 发布
最新推荐文章于 2024-08-15 09:00:00 发布
阅读量383 收藏 1
点赞数
分类专栏： 计算机考研 文章标签： 计算机考研 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuanwa0969/article/details/85722442
版权

计算机考研数据结构–链表部分

1、顺序表中删除第i个元素；
#include <stdlib.h>
#include <stdio.h>

typedef struct SeqList{
int *arr;
int arr_length;
}SeqList;
int main(){
int arr[10]={1,2,3,4,5,6,7,8,9,10};

SeqList l;
l.arr=arr;//l.arr=arr[10];不对！！
l.arr_length=10;//赋值要全，别丢长度

int i;
scanf("%d",&i);
for(i;i<l.arr_length;i++){
	l.arr[i-1]=l.arr[i];
}

for(i=0;i<l.arr_length-1;i++){
	printf("%d",l.arr[i]);
}
return 0;

}
2、在第i个元素前面插入e
#include <stdlib.h>
#include <stdio.h>

typedef struct SeqList{
int *arr;
int arr_length;
}SeqList;
int main(){
int arr[10]={1,2,3,4,5,6,7,8,9,10};

SeqList l;
l.arr=arr;
l.arr_length=10;

int index,e;
scanf("%d%d",&index,&e);
int i;
for(i=l.arr_length-1;i>=index-1;i--){
	l.arr[i+1]=l.arr[i];
}
l.arr[index-1]=e;
l.arr_length++;
for(i=0;i<l.arr_length;i++){
	printf("%d",l.arr[i]);
}
return 0;

}
或者
#include <stdlib.h>
#include <stdio.h>

typedef struct SeqList{
int *arr;
int arr_length;
}SeqList;

void inset(SeqList *a,int index,int e){
int i;
for(i=a->arr_length-1;i>=index-1;i–){
a->arr[i+1]=a->arr[i];
}
a->arr[index-1]=e;
a->arr_length++;
}
int main(){
int arr[10]={1,2,3,4,5,6,7,8,9,10};

SeqList l;
l.arr=arr;
l.arr_length=10;

int index,e,i;
scanf("%d%d",&index,&e);
inset(&l,index,e);
for(i=0;i<l.arr_length;i++){
	printf("%d",l.arr[i]);
}
return 0;

}
3、从顺序表中删除最小元素，空出的位置有最后一个元素填补
#include <stdlib.h>
#include <stdio.h>

typedef struct SeqList{
int *arr;
int arr_length;
}SeqList;

void delete(SeqList *a){
int i;
int min_index=0;//用来记录最小的位置
for(i=1;iarr_length-1;i++){//查找最小元素的位置
if(a->arr[i]arr[min_index]){
min_index=i;
}
}
a->arr[min_index]=a->arr[a->arr_length-1];
a->arr_length–;
}
int main(){
int arr[10]={1,2,3,4,5,6,7,8,9,10};

SeqList l;
l.arr=arr;
l.arr_length=10;
int i;
delete(&l);
for(i=0;i<l.arr_length;i++){
	printf("%d",l.arr[i]);
}
return 0;

}
4、在无序顺序表中删除值在s和t之间的所有元素
如果s和t是下标
#include <stdlib.h>
#include <stdio.h>

typedef struct SeqList{
int *arr;
int arr_length;
}SeqList;

void delete(SeqList *a,int start,int end){
int i;
int distance=end-start-1;
for(i=start;iarr_length-distance;i++){
a->arr[i]=a->arr[end-1];
end++;
}
a->arr_length-=distance;
}
int main(){
int arr[10]={1,2,3,4,5,6,7,8,9,10};

SeqList l;
l.arr=arr;
l.arr_length=10;
int i,start,end;
scanf("%d%d",&start,&end);
delete(&l,start,end);
for(i=0;i<l.arr_length;i++){
	printf("%d",l.arr[i]);
}
return 0;

}
如果是指顺序表中的值无序
#include <stdlib.h>
#include <stdio.h>
//有序顺序表
typedef struct SeqList{
int *arr;
int arr_length;
}SeqList;

void delete(SeqList *a,int start,int end){
int i;
int index;
int len=a->arr_length;
for(i=0;iarr_length;i++){
if(a->arr[i]<end&&a->arr[i]>start){
index=i;
int j;
for(j=index;jarr_length-1;j++){
a->arr[j]=a->arr[j+1];
}
a->arr_length–;
i–;
}
}
}
int main(){
int arr[10]={1,4,0,2,5,9,8,3,10,7};

SeqList l;
l.arr=arr;
l.arr_length=10;
int i,start,end;
scanf("%d%d",&start,&end);
delete(&l,start,end);
for(i=0;i<l.arr_length;i++){
	printf("%d",l.arr[i]);
}
return 0;

}
5、在有序顺序表中删除值在s和t之间的所有元素
#include <stdlib.h>
#include <stdio.h>
//有序顺序表
typedef struct SeqList{
int *arr;
int arr_length;
}SeqList;

void delete(SeqList *a,int start,int end){
int i;
int start_index;
int end_index;
for(i=0;iarr_length;i++){
if(a->arr[i]==start){
start_index=i;
}
if(a->arr[i]==end){
end_index=i;
}
}

int distance=end_index-start_index-1;
for(i=start_index+1;i<a->arr_length-distance;i++){
	a->arr[i]=a->arr[end_index];
	end_index++; 
}
a->arr_length-=distance;

}
int main(){
int arr[10]={1,2,3,4,5,6,7,8,9,10};

SeqList l;
l.arr=arr;
l.arr_length=10;
int i,start,end;
scanf("%d%d",&start,&end);
delete(&l,start,end);
for(i=0;i<l.arr_length;i++){
	printf("%d",l.arr[i]);
}
return 0;

}
6、单链表访问第i个元素
#include <stdio.h>
#include <stdlib.h>

typedef struct LNode{
int data;
struct LNode *next;
}LNode;

void createList(LNode *p,int a[],int n){
LNode *s;
int i;
for(i=0;i<n;i++){
s=(LNode *)malloc(sizeof(LNode));
s->data=a[i];
s->next=p->next;
p->next=s;
}
}
void find(LNode *p,int index,int *a){
LNode *s=p->next;
int cnt=1;
while(s!=NULL){
if(cnt==index){
*a=s->data;
break;
}
cnt++;
s=s->next;
}
}
void print(LNode *p){
LNode *q=p->next;
while(q!=NULL){
printf("%d",q->data);
q=q->next;
}
printf("\n");
}
int main(){
LNode *p;
p=(LNode *)malloc(sizeof(LNode));
p->next=NULL;
int a[10]={1,2,3,4,5,6,7,8,9,10};
createList(p,a,10);
print§;
int e;
int index;
scanf("%d",&index);
find(p,index,&e);
printf("%d",e);
return 0;
}
7、在第i个位置前插入元素e(用的一个程序)
void inset(LNode *p,int index,int e){
LNode *s,*r;
s=(LNode *)malloc(sizeof(LNode));
s->next=NULL;
s->data=e;

int cnt=1;
r=p->next;
while(r!=NULL){
	if(cnt==index-1){
		s->next=r->next;
		r->next=s;
		break;
	}
	cnt++;
	r=r->next;
}

}
8、单链表删除第i个元素，用e返回
int delete(LNode *p,int index){
int e;
LNode *s=p->next;
int cnt=1;
while(s!=NULL){
if(cnt==index-1){
e=s->next->data;
LNode *u=s->next;
s->next=s->next->next;
free(u);
return e;
break;
}
cnt++;
s=s->next;
}
}
9、头插法和尾插法
#include<stdio.h>
#include<stdlib.h>

typedef struct LNode{
int data;//单链表中的数据域
struct LNode *next;//单链表中的指针域
}LNode;
//头插法
void createList1(LNode *p,int a[],int n){
int i=0;
for(i=0;i<n;i++){
LNode *s=(LNode *)malloc(sizeof(LNode));
s->data=a[i];
s->next=p->next;
p->next=s;

}

}

//头插法 **的情况，createList2(&p,a,5);
void createList1(LNode **p,int a[],int n){
int i=0;
for(i=0;i<n;i++){
LNode *s=(LNode *)malloc(sizeof(LNode));
s->data=a[i];
s->next=(*p)->next;
(*p)->next=s;

}

}

void print(LNode *p){
LNode *s=p->next;
while(s!=NULL){
printf("%d",s->data);
s=s->next;
}
printf("\n");
}
//尾插法
void createList2(LNode *p,int a[],int n){
LNode *s;
int i=0;
for(i=0;i<n;i++){
s=(LNode *)malloc(sizeof(LNode));
s->data=a[i];
p->next=s;
p=p->next;//勿忘！！！
}
p->next=NULL;
}
int main(){
LNode *p;
p=(LNode *)malloc(sizeof(LNode));//申请节点空间
p->next=NULL;//一定不要忘记！！！// 将next设置为NULL
int a[5]={1,2,3,4,5};
createList2(p,a,5);
print§;
return 0;

}
10、la和lb按值非递减，归并la和lb，得到新的单链表lc，使得lc也按值非递减，并占用原来的空间
void guibing(LNode *la,LNode *lb){
LNode *p=la->next;
LNode *q=lb->next;

LNode *a=la;//将a作为新链表的头节点

a->next=NULL;
//两个链表从头开始往后找插入节点，直到其中 一个所有节点插入完结束
while(p!=NULL&&q!=NULL){
//两个节点比较，选出最小者插入，并且移动到后一个节点
if(p->data<=q->data){
a->next=p;
a=a->next;//!!!
p=p->next;
}
if(p->data>q->data){
a->next=q;
a=a->next;
q=q->next;
}
}
//两个链表中有一个遍历完了，剩下的链表直接插入到a中就好
if(p!=NULL){
a->next=p;
}
if(q!=NULL){
a->next=q;
}
free(lb);//释放lb
}
11、通过一趟遍历，确定链表中值最大的节点（在第九题基础上）
返回最大值
int find_Max(LNode *p){
LNode *s=p->next;
int max=0;
while(s!=NULL){
if(maxdata){
max=s->data;
}
s=s->next;
}

return max;

}
返回最大的节点
//返回最大的节点
LNode *max_LNode(LNode *p){
LNode *s=p->next;
// LNode *max=p->next;//是对的
LNode *max=s;//LNode *max=p;是不对的，他此时指向的为空

while(s!=NULL){
	if(max->data<s->data){
		max=s;
	}
	s=s->next;
}
return max;

}

void printt(LNode *p){
LNode *s=p;//节点的输出不能用LNode *s=p->next;！！！！可以说是没有头结点
while(s!=NULL){
printf("%d",s->data);
s=s->next;
}
printf("\n");
}

12、将链表中值最小的节点移动到链表的最前面
void findMinn(LNode *p){
LNode *s=p->next;
LNode *min=s;
LNode *pre=p;//指向最小值的前驱结点
LNode *t=p;//实时追踪当前指向的前驱结点
while(s!=NULL){
if(min->data>s->data){
min=s;
pre=t;//当最小的结点更换时，前驱结点 也需要更换
}
t=s;//在s指针向后移动之前，指向它，即为后驱结点的前驱结点
s=s->next;
}
pre->next=pre->next->next;//从链表中删除结点
min->next=p->next;//将最小的结点插入到头节点后面
p->next=min;
}
13、对链表使用冒泡排序
方法一：自己的方法（没有考虑排序完成就结束）
void findMinn(LNode *p){
LNode *s=p->next;
LNode *r=p->next;
int temp=s->data;
while(r!=NULL){//一次是无法完成的
while(s->next!=NULL){
if(s->data>s->next->data){
temp=s->data;
s->data=s->next->data;
s->next->data=temp;
}
s=s->next;
}

	r=r->next;
	s=p->next;
}

}

标准答案：
//要判断一趟排序是否发生交换
void find(LNode *p){
LNode *s=p->next;
LNode *q=s->next;
int temp=0;
while(1){//如果为五个数，最多拍列四次，但是其实不用判断次数，上一个程序就判断了，通过移动指针，控制排列，但是控制的却是五次，是不符合逻辑的，就通过是否排序完成来进行判断
int flag=0;//一定要放在每次循环的里面
while(q!=NULL){
if(s->data>q->data){
temp=q->data;
q->data=s->data;
s->data=temp;
flag=1;
}
s=q;
q=q->next;
}
if(flag0){
return;
}
s=p->next;//一定不要忘记将指针指回前面
q=s->next;
}
}
14、有序链表中去掉值相同的元素
void find(LNode *p){
LNode *s=p->next;
LNode *r;
while(s->next!=NULL){//一定还要判断下一个指针是否为空！！！
//如果此指针和下一个数据域相同
if(s->datas->next->data){
r=s->next;
s->next=s->next->next;

	} 
	s=s->next;

free®;//free一定要放在后面！！
}
}（错误！！！！！）

void findMinn(LNode *p){
LNode *s=p->next;
LNode *r;
if(sNULL||s->nextNULL){//如果此链表为空或者只有一个结点时，不用进行查找比较
return;
}
while(s->next!=NULL){
//如果此指针和下一个数据域相同
if(s->data==s->next->data){
r=s->next;

		 s->next=s->next->next;
		 free(r);
	}else{
		s=s->next;
	} 	
}

}

定义两个指针的情况
void findMinn(LNode *p){
LNode *s=p->next;
LNode *q=s->next;
LNode *r;
if(sNULL||qNULL){//如果此链表为空或者只有一个结点时，不用进行查找比较
return;
}
while(q!=NULL){
//如果此指针和下一个数据域相同
if(s->data==q->data){
r=q;
// printf("%d",r->data);
s->next=q->next;
q=q->next;
free®;//不能在q指向前就释放！！
}else{
s=s->next;
q=q->next;
}
}
}

数据结构与算法：链表
baiyechangjiu的博客
08-21 362
链表是物理存储单元上非连续的，非顺序的存储结构，链表是由一个个结点，通过指针来联系起来的，其中每个结点包含数据和指针： 或者我们采用另一张更加明显的图： 因为在C++语言中，当我们生成一个数组的时候，就要声明数组的长度，如此计算机便会在内存上开辟一个连续的不间断的内存空间来存储数据，因为存在着这样的一种可能，也就是数组所使用的内存空间之后的内存空间已经被使用，所以C++中一旦数组的大小明确了，就不能够再改变了。而且因为数组是存储一系列的同一类型的变量的集合，所以构成数组的每一个元素占用的内存空间
计算机考研数据结构----线性表
weixin_43970560的博客
07-07 960
第二章 线性表 一、线性表的定义 线性表是具有相同数据类型的n(n>=0)个数据元素的有限序列，其中n为表长，当n=0时线性表是一个空表。若用L命名线性表，其一般表示为L=(a1,a2,a3,…,ai,ai+1,…,an)。 线性表的特点： 1.表中元素的个数有限。 2.表中元素具有逻辑上的顺序性，表中元素有其先后次序。 3.表中元素都是数据元素，每个元素都是单个元素。 4.表中元素的数据类型都相同，每个元素占用相同大小的存储空间。 ai是线性表中的第i个元素在线性表中的位序。 a1是唯一的第一个数据
考研复试之数据结构——链表
weixin_38623697的博客
03-06 330
链表应用 虽然考试中极少会考察链表的实际应用，一般都是直接考各种链表的各种操作，不过我觉得了解链表的实际应用场景有利于建立一种直觉，加深我们对链表数据结构本身的理解。由于我本身对链表应用也不甚了解，在查阅一定资料后，我认为有一句话能比较好的总结： 链表插入删除效率极高，达到O(1)。对于不需要搜索但变动频繁且无法预知数量上限的数据，比如内存池、操作系统的进程管理、网络通信协议栈的trunk管理等等等等，缺了它是绝对玩不转的。[1]——知乎用户invalid s 链表 这一小节主要讨论链表本身：单
链表
仲夏的博客
05-16 313
主要就是对单链表的操作，功能主要有：初始化链表，增加元素，删除元素，获取链表长度，是否为空，元素大小排序，核心代码都有注释 #include<stdio.h> #include<malloc.h> typedef struct Node { int val; struct Node *next; }NODE,* PNODE;//typedef起两个...
考研数据结构之链表构造
qq_41151774的博客
12-30 162
#include<stdio.h> #include<stdlib.h> typedef struct Lnode { int data; struct Lnode *next; }Lnode,*linkList; Lnode structList(linkList l,int a); void main() { int input; linkList L,list; //...
考研数据结构复习——单链表算法主要实现
qq_44969202的博客
05-20 333
单链表是数据结构的基础，主要是在考研数据结构的复习中，把代码敲一遍，顺一下，总结一下单链表的几种最基本的操作。
王道2019最新计算机考研计算机数据结构-计算机组成原理.rar
07-16
《王道2019最新计算机考研计算机数据结构-计算机组成原理》是针对计算机科学与技术专业考研学生的重要参考资料，涵盖了数据结构和计算机组成原理两大核心课程的知识点。该压缩包文件提供了电子版教材，方便考生...
考研数据结构链表
weixin_46545179的博客
07-22 578
考研数据结构链表
王道咸鱼学长408课件PDF整理（数据结构-计算机组成-操作系统）
01-10
《王道咸鱼学长408课件PDF整理》是一个综合性的学习资源，主要涵盖了计算机科学中的三个核心领域：数据结构、计算机组成原理和操作系统。这个资源特别适合正在攻读计算机本科专业的学生以及准备考研408科目的考生。...
【计算机考研数据结构代码题总结】链表
qq_43506256的博客
12-10 1580
1.在带头节点的单链表L中，删除所有值为X的结点，并释放其空间，假设值为X的节点不唯一，试编写算法实现。 //单链表 //要放置三个指针，pre指向头结点(p结点的前驱)，p指向头结点的下一个结点，q指向要被删除的结点 typedef struct LNode{ int data; struct LNode *next; }LNode; void Del_X(LNode *L, ElemType X){ LNode *pre, *p, *q; pre = L; p = L->next;
考研复习线性表之——链表
weixin_44769592的博客
05-25 502
文章目录单链表存储结构GetElem()ListInsert()例题A，B是两个单链表，递增有序，归并A，B得到C，也是递增有序的 单链表 存储结构 typedef struct node{ int data; structnode *next;//定义指向后继节点的指针 }node,*Linklist; GetElem() void GetElem(Linklist L,int i,int &e){ int j=1; int p=L; while(p&&j<i)/
C语言单链表（超级无敌详细，408考研同样适用）
m0_74036487的博客
07-14 319
线性表的链式存储又称单链表，它是指通过一组任意的存储单元来存储线性表中的数据元素。为了建立数据元素之间的线性关系，对每个链表结点，除存放元素自身的信息外，还需要存放一个指向其后继的指针。单链表结点结构如下代码所示，其中 data 为数据域，存放数据元素;next为指针域，存放其后继结点的地址定义一个结构体来实现单链表typedef 关键字的作用相当于起别名有关结构体的定义，可以看看我的这篇博客c++结构体的定义c语言也适用int data;
【考研】单链表相关算法（从基础到真题）
qq_34438969的博客
10-02 2155
本文主要为了掌握单链表基础操作所作的总结，习题部分含408真题或高校真题，以便考研复习。包括但不限于尾插法和前插法建立单链表、“就地逆置”、链式有序表的合并、注意：（1）除非特别说明，本文的单链表操作默认是带头结点的。（2）区分带头结点和不带头结点的单链表的博文，我写了一半，写完就放链接。（如果很久还没放链接，可能博主有事耽搁了，麻烦提醒一下）【考研】线性表的应用之有序表的合并_住在阳光的心里的博客-CSDN博客【考研】《数据结构》知识点总结.pdf_其它文档类资源-CSDN文库目录前言。
考研数据结构——必看链表真题(常规套路)
希可诺的博客
04-11 2388
一、考研链表操作 （1）考研数据结构——单链表操作(模板) 整体分析：这四个题可以说也是固定思想套路，都是建立一个新的链表进行辅助操作，在考研中算是比较公认的一种处理方法了。 注意：有些小伙伴可能说会说，“我还有更好的方法或者更简洁的代码”，当然肯定会出现这种情况，我也并不反对，但是你的代码是给阅卷老师看的，这种新建链表的方法往往结构会更清晰。 目录 1、倒置链表 2、合并有序链表 3、将链表中所有负数结点移动到所有整数之前 4、将最小节点移动到第一个节点的前面 1、倒...
考研408之链表精讲
最新发布
weixin_60773175的博客
08-15 1040
链表是一种链式数据结构，由一系列节点（Node）组成，每个节点包含数据和指向下一个节点的指针。与数组相比，链表在插入和删除操作上更具灵活性，因为它不需要移动大量元素。在 C 语言中，我们可以使用结构体（struct）来定义链表节点。
计算机考研-数据结构知识点汇总.pdf
08-29
计算机考研数据结构知识点汇总 本资源摘要信息涵盖了计算机考研中的数据结构知识点，包括数据结构的基本概念、逻辑结构、存储结构、算法设计、线性表、链表、队列、栈等知识点。 一、数据结构基本概念 * 数据结构...
考研数据结构笔记--单链表
BELL__Meng的博客
08-28 362
单链表单链表结点定义单链表的操作 单链表结点定义 //单链表结点定义 typedef struct LNode{ int data; //data中存放结点数据域（以int类型为例） struct LNode *next; //指向后继结点的指针 }LNode; //定义单链表结点类型 单链表的操作 //尾插法创建单链表 /* ...
计算器（链表实现）
wenpu_Di
08-17 2256
思路： 1.分为两步计算，第一步先计算括号里面的数据！没计算完一个括号以后，判断是否括号已经消除完毕，消除完毕结束循环 2.消除完，先计算乘除后计算加减，（在处理括号理同时含有乘除和加减时，调用此过程） 总结： 1.要画出循环图来，保证思路清晰！每个细节要注意到并以适当的方式改正过来！ 漏洞： 由于采用的是字符数组的形式存储数字，但是不会把负数和小数点以数组的形式存储进去，所以整个过程当
数据结构考研复习（自用非408）链表——附单链表完整代码
qq_55709496的博客
10-30 212
链表部分
【译】2019年JavaScript中的计算机科学：链表
weixin_34061555的博客
01-24 119
原文地址：Computer science in JavaScript 2019: Linked list 原文作者：Nicholas C. Zakas 早在2009年，我就挑战自己一年内坚持每周写一篇博客文章。我曾经读到过，坚持发表文章是为博客带来流量的最好的方法。基于我的所有文章的理念，一周发表一篇文章看起来是一个很实际的目标，而事实上我缺少了博客文章的52个理念。（译者注：不太清楚这...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值