锐格————-线性表

最新推荐文章于 2023-10-07 16:39:10 发布
最新推荐文章于 2023-10-07 16:39:10 发布
阅读量221 收藏
点赞数
文章标签： 链表 数据结构 list
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53843010/article/details/121343933
版权

8559

设有一个线性表存放在一个- -维数组中的前n个数组元素位置。请编写一个顺序表的程序，将这个线性表原地逆置。
输出逆置前的顺序表和逆置后的顺序表。

#include <bits/stdc++.h>

using namespace std;

#define Maxsize 1000
typedef struct
{
    int *data;
    int length;
}Sqlist;

int Initlist(Sqlist &L)
{
    L.data=new int[Maxsize];
    if(!L.data) cout<<"error"<<endl;
    L.length=0;
    return 1;

}
void IN(Sqlist &L,int n)
{
    for(int i=0;i<n;i++)
    {
        cin>>L.data[i];
        L.length++;
    }
}
void out1(Sqlist &L)
{
    for(int i=0;i<L.length-1;i++)
    {
        cout<<L.data[i]<<" ";
    }
    cout<<L.data[L.length-1]<<endl;
}
void out2(Sqlist &L)
{
    for(int i=L.length-1;i>0;i--)
    {
        cout<<L.data[i]<<" ";
    }
    cout<<L.data[0]<<endl;
}
int main()
{
    int n;
    cin>>n;
    Sqlist L;
    Initlist(L);
    IN(L,n);
    out1(L);
    out2(L);
    return 0;
}

8553

随机产生或键盘输入一组元素，建立一个带头结点的单向链表(无序)，遍历单向链表，显示相应元素。

#include <bits/stdc++.h>

using namespace std;


typedef struct node
{
    int data;
    struct node *next;
}node,*linklist;

void putout(linklist l)
{
    linklist p=new node;
    p=l->next;
    while(p)
    {cout<<p->data<<" ";
    p=p->next;}

}



int main()
{

    linklist l=new node;
    l->next=NULL;
    int x;
    cin>>x;
    linklist r=new node;
      r=l;
    while(x)
    { linklist p=new node;
          p->data=x;
    p->next=NULL;
    r->next=p;r=p;
    cin>>x;
    }
   putout(l);


}

8554

试编写算法，把单向链表中元素逆置(不允许申请新的结点空间)

#include<bits/stdc++.h>
#define RESULT int
#define OK 1
#define ERROR 0
using namespace std;

typedef struct Node {

    int data;
	Node* next;

}LNode, * LinkList;

RESULT InitList(LinkList& L);									//初始化链表
RESULT InsertData_Back(LinkList& L, int data);					//尾插
RESULT Output_LinkList(LinkList& L);							//打印链表

int main() {

	LinkList L = new LNode;
	InitList(L);
	
	int num = 0;
	while (cin >> num) {
		LinkList p = L->next;
		while (num !=0) {
			InsertData_Back(L, num);		//输入
			cin >> num;
		}

		int n = 1;					//统计多少个元素
		p = L->next;
		while (p->next!=NULL) {
			p = p->next;
			n++;
		}
		
		LinkList back, back1, p1;	//设置工作指针
		p1 = L->next;
		p = L;

		for (int i = 0; i < n-1; i++) {		//查找尾结点
			while (p1->next != NULL) {
				p1 = p1->next;
			}

			back = p1;
			p1 = L;

			while (p1->next->next != NULL) {	//查找尾结点-1位置（因为不是双向链表很烦）
				p1 = p1->next;
			}
			back1 = p1;
	
			back->next = p->next;			//交换
			back1->next = NULL;
			p->next = back;
			p = p->next;

		}
		Output_LinkList(L);		//输出
		InitList(L);
		break;
	}

	return 0;
}

RESULT InitList(LinkList& L) {

	L = new LNode;
	L->next = NULL;

	return OK;
}

RESULT InsertData_Back(LinkList& L, int data) {

	LinkList temp = new LNode;
	temp->data = data;
	temp->next = NULL;
	LinkList p = L;
	while (p->next != NULL) {
		p = p->next;
	}
	p->next = temp;

	return OK;
}


RESULT Output_LinkList(LinkList& L) {

	LinkList temp = L->next;

	while (temp != NULL) {
		cout << temp->data << " ";
		temp = temp->next;
	}
	printf("\n");

	return OK;
}

8555

编写在非递减有序链表中插入一个元素使链表元素仍有序的函数，并利用该函数建立一个非递减有序单向链表。

#include<bits/stdc++.h>
#define RESULT int
#define OK 1
#define ERROR 0

using namespace std;

typedef struct Node {

    int data;

	Node* next;

}LNode, * LinkList;

RESULT InitList(LinkList& L);									//初始化链表
RESULT InsertData_Back(LinkList& L, int data);					//尾插
RESULT InsertData_Sort(LinkList& L, int data);					//查找插入
RESULT Output_LinkList(LinkList& L);							//打印链表

int main() {

	LinkList L = new LNode;
	InitList(L);

	int n = 0;

	while (cin >> n) {

		if (n != 0) {
			InsertData_Sort(L, n);
		}
		else {
			Output_LinkList(L);
			InitList(L);
			break;
		}

	}

	return 0;
}

RESULT InitList(LinkList& L) {

	L = new LNode;
	L->next = NULL;

	return OK;
}


RESULT InsertData_Back(LinkList& L, int data) {

	LinkList temp = new LNode;
	temp->data = data;
	temp->next = NULL;
	LinkList p = L;
	while (p->next != NULL) {
		p = p->next;
	}
	p->next = temp;

	return OK;
}

RESULT InsertData_Sort(LinkList& L, int data) {
	LinkList p = L;
	while (p->next != NULL && data > p->next->data) {
		p = p->next;
	}
	if (p->next == NULL) {
		InsertData_Back(L, data);
	}
	else {
		LinkList temp = new LNode;
		temp->data = data;
		temp->next = p->next;
		p->next = temp;
	}
	return 0;
}

RESULT Output_LinkList(LinkList& L) {

	LinkList temp = L->next;

	while (temp != NULL) {
		cout << temp->data << " ";
		temp = temp->next;
	}
	printf("\n");

	return OK;
}

8556

在这里插入图片描述

#include<bits/stdc++.h>
#define RESULT int
#define OK 1
#define ERROR 0

using namespace std;

typedef struct Node {

    int data;

	Node* next;

}LNode, * LinkList;

RESULT InitList(LinkList& L);									//初始化链表
RESULT InsertData_Back(LinkList& L, int data);					//尾插
RESULT InsertData_Sort(LinkList& L, int data);					//排序
RESULT Output_LinkList(LinkList& L);							//打印链表

int main() {

	LinkList L = new LNode;
	InitList(L);

	int n = 0;

	while (cin >> n) {
		while (n!=0) {
			InsertData_Back(L, n);
			cin >> n;
		}
		
		LinkList p = L;
		while (p->next->next!=NULL) {
			if (p->next->data % 2 == 0) {
				LinkList temp;
				temp = p->next;
				p->next = p->next->next;
				delete temp;
			}
			else {
				p = p->next;
			}
			
		}
		if (p->next->next == NULL) {
			if (p->next->data % 2 == 0) {
				LinkList temp;
				temp = p->next;
				p->next = p->next->next;
				delete temp;
			}
		}

		Output_LinkList(L);
	}


	return 0;
}

RESULT InitList(LinkList& L) {

	L = new LNode;
	L->next = NULL;

	return OK;
}


RESULT InsertData_Back(LinkList& L, int data) {

	LinkList temp = new LNode;
	temp->data = data;
	temp->next = NULL;
	LinkList p = L;
	while (p->next != NULL) {
		p = p->next;
	}
	p->next = temp;

	return OK;
}

RESULT InsertData_Sort(LinkList& L, int data) {
	LinkList p = L;
	while (p->next != NULL && data > p->next->data) {
		p = p->next;
	}
	if (p->next == NULL) {
		InsertData_Back(L, data);
	}
	else {
		LinkList temp = new LNode;
		temp->data = data;
		temp->next = p->next;
		p->next = temp;
	}
	return 0;
}


RESULT Output_LinkList(LinkList& L) {

	LinkList temp = L->next;

	while (temp != NULL) {
		cout << temp->data << " ";
		temp = temp->next;
	}
	printf("\n");

	return OK;
}

8557

在这里插入图片描述

#include<iostream>
#define RESULT int
#define OK 1
#define ERROR 0

using namespace std;

typedef struct Node {

    int data;

	Node* next;

}LNode, * LinkList;

RESULT InitList(LinkList& L);									//初始化链表
RESULT InsertData_Head(LinkList& L, int data);					//头插
RESULT InsertData_Back(LinkList& L, int data);					//尾插
RESULT InsertData_Middle(LinkList& L, int NO, int data);		//在NO位置插入元素
RESULT Output_LinkList(LinkList& L);							//打印链表
LinkList List_Combine(LinkList& L_1, LinkList& L_2);			//合并链表，仅原空间
void ListSort(LinkList& L);
void reverse(LinkList& L) {
	LinkList p;
	int n = 1;
	p = L->next;
	while (p->next != NULL) {
		p = p->next;
		n++;
	}

	LinkList back, back1, p1;
	p1 = L->next;
	p = L;

	for (int i = 0; i < n - 1; i++) {
		while (p1->next != NULL) {
			p1 = p1->next;
		}

		back = p1;
		p1 = L;

		while (p1->next->next != NULL) {
			p1 = p1->next;
		}
		back1 = p1;

		back->next = p->next;
		back1->next = NULL;
		p->next = back;
		p = p->next;

	}
}

int main() {

	//初始化链表L_1
	LinkList L_1;
	if (!InitList(L_1)) {
		return 0;
	}
	int n;
	cin >> n;
	while (n != 0) {
		InsertData_Back(L_1, n);
		cin >> n;
	}
	ListSort(L_1);

	//初始化链表L_2
	LinkList L_2;
	if (!InitList(L_2)) {
		return 0;
	}
	cin >> n;
	while (n != 0) {
		InsertData_Back(L_2, n);
		cin >> n;
	}
	ListSort(L_2);

	LinkList L_3 = new LNode;
	L_3 = List_Combine(L_1, L_2);
	reverse(L_3);
	Output_LinkList(L_3);


	//清除空间
	delete(L_1);
	delete(L_2);


	return 0;
}

RESULT InitList(LinkList& L) {

	L = new LNode;
	L->next = NULL;

	return OK;
}

RESULT InsertData_Head(LinkList& L, int data) {

	LinkList temp = new LNode;

	temp->data = data;
	temp->next = L;
	L = temp;

	return OK;
}

RESULT InsertData_Back(LinkList& L, int data) {

	LinkList temp = new LNode;
	temp->data = data;
	temp->next = NULL;
	LinkList p = L;
	while (p->next != NULL) {
		p = p->next;
	}
	p->next = temp;

	return OK;
}

RESULT InsertData_Middle(LinkList& L, int NO, int data) {

	LinkList temp = new LNode;
	temp->data = data;

	LinkList p = L;

	for (int i = 0; i < NO - 2; i++) {
		p = p->next;
	}

	temp->next = p->next;
	p->next = temp;

	return OK;
}

RESULT Output_LinkList(LinkList& L) {

	LinkList temp = L->next;

	while (temp != NULL) {
		cout << temp->data << " ";
		temp = temp->next;
	}


	return OK;
}

LinkList List_Combine(LinkList& L_1, LinkList& L_2) {

	//链表指针
	LinkList p_1 = L_1->next;
	LinkList p_2 = L_2->next;
	LinkList L_3 = new LNode;
	LinkList p = L_3;

	while (p_1 != NULL && p_2 != NULL) {

		/*if (p_1->data == p_2->data) {

			p->next = p_1;
			p = p_1;
			p_1 = p_1->next;
			p_2 = p_2->next;

		}*/

		if (p_1->data < p_2->data) {

			p->next = p_1;
			p = p_1;
			p_1 = p_1->next;

		}
		else {

			p->next = p_2;
			p = p_2;
			p_2 = p_2->next;

		}

	}

	if (p_1 == NULL && p_2 != NULL) {
		p->next = p_2;
	}
	if (p_2 == NULL && p_1 != NULL) {
		p->next = p_1;
	}

	return L_3;
}

void ListSort(LinkList &head) {
    LinkList  p,  q;
    for (p = head->next; p != NULL; p = p->next)
		for (q = p->next; q != NULL; q = q->next)
			if (p->data > q->data){
				int t1 = p->data; p->data = q->data; q->data = t1;    
		    }
}

8558

在这里插入图片描述

#include<bits/stdc++.h>
#define RESULT int
#define OK 1
#define ERROR 0

using namespace std;

typedef struct Node {

    int data;
	Node* front;
	Node* next;

}LNode, * LinkList;

RESULT InitList(LinkList& L);									//初始化链表
RESULT InsertData_Back(LinkList& L, int data);					//尾插
RESULT InsertData_Sort(LinkList& L, int data);					//尾插
RESULT Output_LinkList(LinkList& L);							//打印链表

int main() {

	LinkList l = new LNode;
	InitList(l);

	int n;
	cin >> n;
	int i = 0;
	while (n != 0) {
		InsertData_Back(l, n);
		cin >> n;
		i++;
	}

	LinkList s = new LNode;
	InitList(s);
	LinkList temp;
	LinkList sp = s;
	LinkList p = l->next;
	for (int j = 0; j < i && p != NULL; j++) {
		if (p->data % 2 == 0) {
			if (p->next == NULL) {
				p->front->next = NULL;
				sp->next = p;
				break;
			}
			p->front->next = p->next;	//取下节点
			p->next->front = p->front;
			sp->next = p;
			p->front = sp;
			temp = p->next;
			p->next = NULL;
			p = temp;
			sp = sp->next;

		}
		else {
			p = p->next;

		}
	}

	Output_LinkList(l);
	Output_LinkList(s);
	return 0;
}

RESULT InitList(LinkList& L) {

	L = new LNode;
	L->next = NULL;

	return OK;
}


RESULT InsertData_Back(LinkList& L, int data) {

	LinkList temp = new LNode;
	temp->data = data;
	temp->next = NULL;
	LinkList p = L;
	while (p->next != NULL) {
		p = p->next;
	}
	temp->front = p;
	p->next = temp;

	return OK;
}

RESULT InsertData_Sort(LinkList& L, int data) {
	LinkList p = L;
	while (p->next != NULL && data > p->next->data) {
		p = p->next;
	}
	if (p->next == NULL) {
		InsertData_Back(L, data);
	}
	else {
		LinkList temp = new LNode;
		temp->data = data;
		temp->next = p->next;
		p->next = temp;
	}
	return 0;
}


RESULT Output_LinkList(LinkList& L) {

	LinkList temp = L->next;

	while (temp != NULL) {
		cout << temp->data << " ";
		temp = temp->next;
	}
	printf("\n");

	return OK;
}

8560

在这里插入图片描述

鱼州玫瑰
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构实验：单向链表
小白的逆袭
07-07 1501
实验内容： 1．随机产生或键盘输入一组元素（不少于10个元素），建立一个带头结点的单链表。 2．把单链表中的元素逆置（不允许申请新的结点空间）。 3．删除单链表中所有的偶数元素结点。 4．编写在非递减有序链表中插入一个元素使链表元素仍有序的函数，利用该函数建立一个 非递减有序单链表。 5．利用算法4建立两个非递减有序单链表，然后合并成一个非递增链表。 6．把算法1建立的链表分解成两个链表，其中一...
【8555】编写在非递减有序链表中插入一个元素使链表元素仍有序的函数，并利用该函数建立一个非递减有序单向链表
Codes
09-25 4021
编写在非递减有序链表中插入一个元素使链表元素仍有序的函数，并利用该函数建立一个非递减有序单向链表 #include<bits/stdc++.h> #define RESULT int #define OK 1 #define ERROR 0 using namespace std; typedef struct Node { int data; Node* next;...
在非递减的有序单链表中插入一个值为x的数据元素，并使单链表仍保持有序的操作
zjhzcjg的专栏
10-16 1万+
// 在非递减的有序单链表中插入一个值为x的数据元素，并使单链表仍保持有序的操作   public void insert(Comparable  x) {       Node p = head.next;       Node q = head;// q用来记录p的前驱结点       //int temp;       Comparable temp;       while (
在一个有序(按非递减顺序)的链表中插入一个元素为x的结点，使插入后的链表仍然有序（链表数据域为整型数，N为6）。
2301_76779875的博客
07-19 187
在一个有序(按非递减顺序)的链表中插入一个元素为x的结点，使插入后的链表仍然有序（链表数据域为整型数，N为6）。**输出格式："%d " (注：所有数据输出结束后有一个回车)**输出格式："%d " (注：所有数据输出结束后有一个回车)**输出提示："插入后链表各个结点的数据域为："**输入提示："输入数组6个元素的值。**输出提示："此链表各个结点的数据域为："**输入提示："输入要插入的数据x:"输入数组6个元素的值。输入要插入的数据x:36。**输入格式："%d"**输入格式："%d"
编写在非递减有序链表中插入一个元素(整型)，使链表元素仍有序的函数（必须采用函数实现，否则不算成绩），并利用该函数建立一个非递减有序单向链表，之后输出这个有序的单链表。
2301_76327397的博客
09-20 484
【代码】编写在非递减有序链表中插入一个元素(整型)，使链表元素仍有序的函数（必须采用函数实现，否则不算成绩），并利用该函数建立一个非递减有序单向链表，之后输出这个有序的单链表。
锐格测试.cpp
04-05
锐格测试.cpp
NEFU锐格网络平台（实验课）用于莫拉莱斯存储锐格做过的题。.zip
最新发布
03-29
可以用于毕业设计（项目源码+项目说明）目前在window10/11测试环境一切正常，用于演示的图片和部署教程说明都在压缩包里
C语言程序设计大赛资料 - .pdf（0 积 f）
08-07
C语言程序设计大赛资料 一：知识点 数据结构： 1，单，双链表及循环链表 2，树的表示与存储，二叉树（概念，遍历）二叉树的应用（二叉排序树，判定树，博弈树，解答树等） 3，文件操作（从文本文件中读入数据并...
不通过JavaScript实现的自动滚动视差效果
10-30
介绍了一种通过CSS3实现的视差（Parallax）效果，这个效果通过在一个元素上叠加多个背景图片，并使用-webkit- transition-属性来实现。
数据结构实验课_实验二 单向链表
zavay的博客
12-28 2312
一、实验内容 1．随机产生或键盘输入一组元素，建立一个带头结点的单向链表（无序)。2．遍历单向链表。 3．把单向链表中元素逆置（不允许申请新的结点空间)。4．在单向链表中删除所有的偶数元素结点。 5．编写在非递减有序链表中插入一个元素使链表元素仍有序的函数，并利用该函数建立一个非递减有序单向链表。 代码实现： 在这里插入代码片#include <stdio.h> #include <stdlib.h> #include <time.h> typedef int Elem
在一个有序(按非递减顺序)的链表中插入一个元素为x的结点，使插入后的链表仍然有序（链表数据域为整型数，初始时输入6个元素）。
qq_51366188的博客
12-05 6357
【链表】 算是自己写的第一个百行代码了！纪念！ 在一个有序(按非递减顺序)的链表中插入一个元素为x的结点，使插入后的链表仍然有序（链表数据域为整型数，初始时输入6个元素）。 程序运行示例如下： 输入数组6个元素的值。 12 23 34 45 56 67 此链表各个结点的数据域为：12 23 34 45 56 67 输入要插入的数据x:36 插入后链表各个结点的数据域为：12 23 34 36 45 56 67 Talk is cheap, show me the code. /* 在一个有序(按非递减顺
创建一个有序单链表（数据结构）
qq_64821210的博客
09-25 570
【代码】创建一个有序单链表（数据结构）
数据结构--耿国华版（课设2）---单链表的遍历、逆置、排序、合并、插入删除
奔赴在热爱征程上的小小孩~
07-08 835
要求： 1.编写函数,实现随机产生或键盘输入一组元素,建立一个带头结点的单链表（无序） 2.编写函数,实现遍历单链表 3.编写函数,实现把单向链表中元素逆置 4.编写函数,建立一个非递减有序单链表 5.编写函数,利用以上算法，建立两个非递减有序单链表,然后合并成一个非递减链表。 6.编写函数,在非递减有序单链表中插入一个元素使链表仍然有序 7.编写函数,实现在非递减有序链表中删除值为x的结点 8.编写一个主函数,在主函数中设计一个简单的菜单,分别调试上述算法 代码： #include<stdio.h&
单链表（二）
qq_44365086的博客
08-14 331
13. //La和Lb按值非递减，归并La和Lb，得到新的单链表Lc。 //使得Lc也按值非递减且不含重复元素，并占用原来的空间。 /* 用两个指针分别指向La和Lb的第一个数据结点。每次取较小的结点“尾插”到Lc中。 如果带插入结点与尾结点相同，则释放该结点，反之则追加到尾部。 重复上述步骤，直到其中一个链的结点被搜索完。随后再将剩余结点直接追加到Lc尾部 */ void insertNode(LinkNode *&pTail,LinkNode *node){//在Lc尾部插入新结点
数据结构实验1单链表
weixin_44780625的博客
07-07 2954
文章目录实验1 单链表一、 实验目的或任务二、 实验教学基本要求三、 实验教学的内容或要求需要word文件请点击这里 实验1 单链表 一、 实验目的或任务 通过指导学生上机实践，对常用数据结构的基本概念及其不同的实现方法的理论得到进一步的掌握，并对在不同存储结构上实现不同的运算方式和技巧有所体会。 二、 实验教学基本要求 1.了解实验目的及实验原理； 2.编写程序，并附上程序代码和结果图； 3.总结在编程过程中遇到的问题、解决办法和收获。 三、 实验教学的内容或要求 1.编写函数,实现随机产生或键盘输入一组
【数据结构】【循环单链表】
weixin_56612338的博客
10-07 571
本篇博客是基于c语言的数据结构篇的循环单链表操作的代码实现，保姆级教程，一篇就足够
数据结构--c语言--在非递减有序的顺序表中插入一个元素x，保持顺序表有序性。
热门推荐
J_SUNV的博客
11-25 1万+
实验目的 熟悉将算法转换成程序代码的过程，了解顺序表的逻辑结构特性，熟练掌握顺序表存储结构的C语言描述方法。熟练掌握顺序表的基本操作：查找、插入、删除、合并等，掌握顺序表的随机存取特性。 实验内容 （1）在非递减有序的顺序表中插入一个元素x，保持顺序表有序性               #include&lt;stdio.h&gt; #include&lt;stdlib.h&g...
2021-11-14
m0_55300220的博客
11-14 667
数据结构作业纠错 1.(单选题，2 分) 在求算术表达式的过程中，需要引用两个栈，一个是在算术表达式转换成后缀表达式过程中用来存放（ ）的栈，另一个是在后缀表达式求值过程中用来存放（ ）的栈。 A.操作数，运算符 B.运算符，运算符 C.运算符，操作数 D.操作数，操作数 教师批阅 正确答案C， 我的答案 ：A 3.(单选题，2 分) 将算法表达式a/b+(cd-ef)/g转换为等价的后缀表达式是（ ）。 A.ab/+cd*-efg/ B.ab/+(cd-ef*)g/ C.abcde
锐格网络平台数据结构
10-12
锐格网络平台的数据结构主要包括以下几个方面： 1. 用户数据结构：包括用户基本信息、账号密码、权限等； 2. 文章数据结构：包括文章标题、内容、作者、发布时间等； 3. 评论数据结构：包括评论内容、评论者、评论...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值