数据结构期末报告 实验一

最新推荐文章于 2021-05-27 09:48:41 发布
最新推荐文章于 2021-05-27 09:48:41 发布
阅读量2.5k 收藏 50
点赞数 12
文章标签： 链表 数据结构 算法 单链表 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangnuanxin520/article/details/106216099
版权

1.对任意输入的一组数据，建立一个递增有序的单链表

#include<iostream>
#include<algorithm>
#include<string>
using namespace std;

#define null = NULL;

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

enum error_type{ success, overflow, underflow, rangeerror, arrange_error};

class list {
public:
	list();
	int length()const;
	error_type get_element(const int i, int & x) const;     //按序号查找元素
	node* locate(const int x)const;                         //按值查找元素
	error_type insert(const int i, const int x);            //插入元素
	error_type delete_element(const int i);                 //删除元素
	node* get_head() { return head; };                      //读取链表表头指针 
	void create1();                                         //表头插入法
	void create2();                                         //表尾插入法
	void display();                                         //输出链表
	void insert1(int x);
private:
	int count;
	node* head;
};

list::list()                   //初始化list
{
	head = new node;
	head->next = NULL;
	count = 0;
}

int list::length()const       //求长度的实现
{
	node *p = head->next;
	int n = 0;                //计数过程，定义一个n用来计数
	while (p != NULL)
	{
		n++;
		p = p->next;
	}
	return n;
}

error_type   list::get_element(const int i, int& x)const  //按序号取元素的实现
{
	node *p = head->next; int j = 1;
	while (j != i && p != NULL)
	{
		p = p->next; j++;
	}
	if (p == NULL) 
		return rangeerror;
	x = p->data;
	return success;
}
node* list::locate(const int x)const {         //按值查找元素的实现
	node *p = head->next;
	while (p != NULL) {
		if (p->data == x)
			return p;
		else
			p = p->next;
	}

}

error_type list::insert(const int i, const int x) {       //插入运算的实现
	node *p = head;int j = 0;
	while (j != i - 1 && p != NULL) {
		p = p->next;
		j++;
	}
	if (i<1 || i>count + 1)
		return arrange_error;
	node *s = new node;
	s->data = x;
	s->next = p->next;
	p->next = s;
	count++;
	return success;
}

error_type list::delete_element(const int i)  //删除运算的实现
{
	node *p = head; int j = 0;
	while (j != i - 1 && p != NULL) {
		p = p->next; j++;
	}
	if (i < 1 || i > count)      // if ( p == NULL ||p->next==NULL )
		return rangeerror;
	node *u = p->next;
	p->next = u->next;
	delete u;
	count--;
	return success;
}
void   list::create1() {       //表头插入法实现链表创建
	int x;
	cin >> x;
	while (x != 0) {          //截止符号是0
		count++;
		node *s = new node;
		s->data = x;
		s->next = head->next;
		head->next = s;
		cin >> x;
	}
}

void  list::create2() {       //表位插入法实现链表创建
	int x;
	cin >> x;
	node *rear = head;
	while (x != 0) {          //截止符号是0
		count++;
		node *s = new node;
		s->data = x;
		s->next = NULL;
		rear->next = s;
		rear = s;
		cin >> x;
	}
}

void  list::display() {     //输出链表
	node* p = head->next;
	while (p != NULL) { cout << p->data << " "; p = p->next; }
	cout << endl;

}
void list::insert1(int x)    //增序插入数
{
	node* u, * P;
	P = head;
	while (P->next != NULL && P->next->data < x)   //搜索插入位置
		P = P->next;
	if (P->next == NULL || P->next->data > x)
	{
		u = new node;
		u->data = x;
		u->next = P->next;                            //插入新结点
		P->next = u;
		count++;
	}
}

int main() {
	list abc;
	int x;
	cout << "下面开始输入数字；（提示：输入0结束！）" << endl;
	cin >> x;
	while (x != 0) {
		
		abc.insert1(x);
		cin >> x;

	}
	abc.display();
	return 0;
}

2.将单链表Ｌ中的奇数项和偶数项结点分解开，并分别连成一个单链表

#include<iostream>
#include<algorithm>
#include<string>
using namespace std;

#define null = NULL;

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

enum error_type{ success, overflow, underflow, rangeerror, arrange_error};

class list {
public:
	list();
	int length()const;
	error_type get_element(const int i, int & x) const;     //按序号查找元素
	node* locate(const int x)const;                         //按值查找元素
	error_type insert(const int i, const int x);            //插入元素
	error_type delete_element(const int i);                 //删除元素
	node* get_head() { return head; };                      //读取链表表头指针 
	void create1();                                         //表头插入法
	void create2();                                         //表尾插入法
	void display();                                  //输出链表
	void create(list*& l);                                  //创建一个单链表 
	void devide(list* L, list* L1, list* L2);             //拆分线性表 
private:
	int count;
	node* head;
	node* next;
};

list::list()                   //初始化list
{
	head = new node;
	head->next = NULL;
	count = 0;
}

int list::length()const       //求长度的实现
{
	node *p = head->next;
	int n = 0;                //计数过程，定义一个n用来计数
	while (p != NULL)
	{
		n++;
		p = p->next;
	}
	return n;
}

error_type   list::get_element(const int i, int& x)const  //按序号取元素的实现
{
	node *p = head->next; int j = 1;
	while (j != i && p != NULL)
	{
		p = p->next; j++;
	}
	if (p == NULL) 
		return rangeerror;
	x = p->data;
	return success;
}
node* list::locate(const int x)const {         //按值查找元素的实现
	node *p = head->next;
	while (p != NULL) {
		if (p->data == x)
			return p;
		else
			p = p->next;
	}

}

error_type list::insert(const int i, const int x) {       //插入运算的实现
	node *p = head;int j = 0;
	while (j != i - 1 && p != NULL) {
		p = p->next;
		j++;
	}
	if (i<1 || i>count + 1)
		return arrange_error;
	node *s = new node;
	s->data = x;
	s->next = p->next;
	p->next = s;
	count++;
	return success;
}

error_type list::delete_element(const int i)  //删除运算的实现
{
	node *p = head; int j = 0;
	while (j != i - 1 && p != NULL) {
		p = p->next; j++;
	}
	if (i < 1 || i > count)      // if ( p == NULL ||p->next==NULL )
		return rangeerror;
	node *u = p->next;
	p->next = u->next;
	delete u;
	count--;
	return success;
}
void   list::create1() {       //表头插入法实现链表创建
	int x;
	cin >> x;
	while (x != 0) {          //截止符号是0
		count++;
		node *s = new node;
		s->data = x;
		s->next = head->next;
		head->next = s;
		cin >> x;
	}
}

void  list::create2() {       //表位插入法实现链表创建
	int x;
	cin >> x;
	node *rear = head;
	while (x != 0) {          //截止符号是0
		count++;
		node *s = new node;
		s->data = x;
		s->next = NULL;
		rear->next = s;
		rear = s;
		cin >> x;
	}
}

void  list::display() {       //输出链表
	node* p = head->next;
	while (p != NULL) { cout << p->data << " "; p = p->next; }
	cout << endl;

}

void list::devide(list* L, list* L1, list* L2)
{
	int x, i;
	for (i = 1; i < L->length() + 1; i++) {
		L->get_element(i, x);
		if (i % 2 != 0) {
			int j = 1;
			L1->insert(j, x);
		}
		else {
			int j = 1;
			L2->insert(j, x);
		}
	}
}


int main() {
	list L, L1, L2;
	L.create1();
	cout << "链表为：" << endl;
	L.display();
	L.devide(&L,&L1,&L2);
	cout << endl;
	cout << "链表的奇数项为：" << endl;
	L1.display();
	cout<<endl;
	cout << "链表的偶数项为：" << endl;
	L2.display();
	cout << endl;
	return 0;
}

3.用递增有序的链表A、B表示两个集合，判断B是否是A的子集

#include<iostream>
#include<algorithm>
#include<string>
using namespace std;

#define null = NULL;

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

enum error_type{ success, overflow, underflow, rangeerror, arrange_error};

class list {
public:
	list();
	int length()const;
	error_type get_element(const int i, int & x) const;     //按序号查找元素
	node* locate(const int x)const;                         //按值查找元素
	error_type insert(const int i, const int x);            //插入元素
	error_type delete_element(const int i);                 //删除元素
	node* get_head() { return head; };                      //读取链表表头指针 
	void create1();                                         //表头插入法
	void create2();                                         //表尾插入法
	void display();                                         //输出链表
private:
	int count;
	node* head;
	node* next;
};

list::list()                   //初始化list
{
	head = new node;
	head->next = NULL;
	count = 0;
}

int list::length()const       //求长度的实现
{
	node *p = head->next;
	int n = 0;                //计数过程，定义一个n用来计数
	while (p != NULL)
	{
		n++;
		p = p->next;
	}
	return n;
}

error_type   list::get_element(const int i, int& x)const  //按序号取元素的实现
{
	node *p = head->next; int j = 1;
	while (j != i && p != NULL)
	{
		p = p->next; j++;
	}
	if (p == NULL) 
		return rangeerror;
	x = p->data;
	return success;
}
node* list::locate(const int x)const {         //按值查找元素的实现
	node *p = head->next;
	while (p != NULL) {
		if (p->data == x)
			return p;
		else
			p = p->next;
	}

}

error_type list::insert(const int i, const int x) {       //插入运算的实现
	node *p = head;int j = 0;
	while (j != i - 1 && p != NULL) {
		p = p->next;
		j++;
	}
	if (i<1 || i>count + 1)
		return arrange_error;
	node *s = new node;
	s->data = x;
	s->next = p->next;
	p->next = s;
	count++;
	return success;
}

error_type list::delete_element(const int i)  //删除运算的实现
{
	node *p = head; int j = 0;
	while (j != i - 1 && p != NULL) {
		p = p->next; j++;
	}
	if (i < 1 || i > count)      // if ( p == NULL ||p->next==NULL )
		return rangeerror;
	node *u = p->next;
	p->next = u->next;
	delete u;
	count--;
	return success;
}
void   list::create1() {       //表头插入法实现链表创建
	int x;
	cin >> x;
	while (x != 0) {          //截止符号是0
		count++;
		node *s = new node;
		s->data = x;
		s->next = head->next;
		head->next = s;
		cin >> x;
	}
}

void  list::create2() {       //表位插入法实现链表创建
	int x;
	cin >> x;
	node *rear = head;
	while (x != 0) {          //截止符号是0
		count++;
		node *s = new node;
		s->data = x;
		s->next = NULL;
		rear->next = s;
		rear = s;
		cin >> x;
	}
}

void  list::display() {       //输出链表
	node* p = head->next;
	while (p != NULL) { cout << p->data << " "; p = p->next; }
	cout << endl;

}

int judge(list *L1,list *L2) 
{
	int x;
	if (L1->length() < L2->length())
		cout << "B不是A的子集"<<endl;
	else
	{
		for (int i = 1; i < L2->length() + 1; i++)
		{
			L2->get_element(i, x);
			x = L1->locate(x)->data;
			if (x != -1) continue;
			else
			{
				cout << "B不是A的子集" << endl;;
				goto a;
			}
		}
		cout << "B是A的子集" << endl;;
	}
   a:return 0;
}

int main() {
	list L1, L2;
	cout << "请输入L1：（以0结束）" << endl;
	L1.create2();
	cout << "请输入L2：（以0结束）" << endl;
	L2.create2();
	judge(&L1, &L2);
	return 0;
}

4.用递增有序的链表A、B表示两个集合，设计算法求它们的并集。

#include<iostream>
#include<algorithm>
#include<string>
using namespace std;

#define null = NULL;

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

enum error_type{ success, overflow, underflow, rangeerror, arrange_error};

class list {
public:
	list();
	int length()const;
	error_type get_element(const int i, int & x) const;     //按序号查找元素
	node* locate(const int x)const;                         //按值查找元素
	error_type insert(const int i, const int x);            //插入元素
	error_type delete_element(const int i);                 //删除元素
	node* get_head() { return head; };                      //读取链表表头指针 
	void create1();                                         //表头插入法
	void create2();                                         //表尾插入法
	void display();                                         //输出链表
	void minus_LinkList(list A, list B,list &C);
private:
	int count;
	node* head;
	node* next;
};

list::list()                   //初始化list
{
	head = new node;
	head->next = NULL;
	count = 0;
}

int list::length()const       //求长度的实现
{
	node *p = head->next;
	int n = 0;                //计数过程，定义一个n用来计数
	while (p != NULL)
	{
		n++;
		p = p->next;
	}
	return n;
}

error_type   list::get_element(const int i, int& x)const  //按序号取元素的实现
{
	node *p = head->next; int j = 1;
	while (j != i && p != NULL)
	{
		p = p->next; j++;
	}
	if (p == NULL) 
		return rangeerror;
	x = p->data;
	return success;
}
node* list::locate(const int x)const {         //按值查找元素的实现
	node *p = head->next;
	while (p != NULL) {
		if (p->data == x)
			return p;
		else
			p = p->next;
	}

}

error_type list::insert(const int i, const int x) {       //插入运算的实现
	node *p = head;int j = 0;
	while (j != i - 1 && p != NULL) {
		p = p->next;
		j++;
	}
	if (i<1 || i>count + 1)
		return arrange_error;
	node *s = new node;
	s->data = x;
	s->next = p->next;
	p->next = s;
	count++;
	return success;
}

error_type list::delete_element(const int i)  //删除运算的实现
{
	node *p = head; int j = 0;
	while (j != i - 1 && p != NULL) {
		p = p->next; j++;
	}
	if (i < 1 || i > count)      // if ( p == NULL ||p->next==NULL )
		return rangeerror;
	node *u = p->next;
	p->next = u->next;
	delete u;
	count--;
	return success;
}
void   list::create1() {       //表头插入法实现链表创建
	int x;
	cin >> x;
	while (x != 0) {          //截止符号是0
		count++;
		node *s = new node;
		s->data = x;
		s->next = head->next;
		head->next = s;
		cin >> x;
	}
}

void  list::create2() {       //表位插入法实现链表创建
	int x;
	cin >> x;
	node *rear = head;
	while (x != 0) {          //截止符号是0
		count++;
		node *s = new node;
		s->data = x;
		s->next = NULL;
		rear->next = s;
		rear = s;
		cin >> x;
	}
}

void  list::display() {       //输出链表
	node* p = head->next;
	while (p != NULL) { cout << p->data << " "; p = p->next; }
	cout << endl;

}
void list:: minus_LinkList(list A,list B,list &C)
{
	node* tempA = A.get_head()->next;
	node* tempB = B.get_head()->next;
	node* tempC = C.get_head();
	int x;
	while (tempA != NULL)
	{
		node* s = new node;
		s->data = tempA->data;
		tempC->next = s;
		tempC = s;
		tempC->next = NULL;
		tempA = tempA->next;
	}
	tempC = C.get_head();
	while (tempB != NULL)
	{
		x = tempB->data;
		if (C.locate(x) == NULL)
		{
			node* s = new node;
			s->data = x;
			s->next = tempC->next;
			tempC->next = s;
		}
		tempB = tempB->next;
	}
}


int main() {
	list A, B, C;
	cout << "请输入L1：（以0结束）" << endl;
	A.create2();
	cout << "请输入L2：（以0结束）" << endl;
	B.create2();
	A.minus_LinkList(A, B, C);
	C.display();
	return 0;
}

5.设计算法判断单循环链表是否每个结点的值都是偶数。

#include<iostream>
#include<algorithm>
#include<string>
using namespace std;

#define null = NULL;

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

enum error_type{ success, overflow, underflow, rangeerror, arrange_error};

class list {
public:
	list();
	int length()const;
	error_type get_element(const int i, int & x) const;     //按序号查找元素
	node* locate(const int x)const;                         //按值查找元素
	error_type insert(const int i, const int x);            //插入元素
	error_type delete_element(const int i);                 //删除元素
	node* get_head() { return head; };                      //读取链表表头指针 
	void create1();                                         //表头插入法
	void create2();                                         //表尾插入法
	void display();                                         //输出链表
	int loop(list L);
private:
	int count;
	node* head;
	node* next;
};

list::list()                   //初始化list
{
	head = new node;
	head->next = NULL;
	count = 0;
}

int list::length()const       //求长度的实现
{
	node *p = head->next;
	int n = 0;                //计数过程，定义一个n用来计数
	while (p != NULL)
	{
		n++;
		p = p->next;
	}
	return n;
}

error_type   list::get_element(const int i, int& x)const  //按序号取元素的实现
{
	node *p = head->next; int j = 1;
	while (j != i && p != NULL)
	{
		p = p->next; j++;
	}
	if (p == NULL) 
		return rangeerror;
	x = p->data;
	return success;
}
node* list::locate(const int x)const {         //按值查找元素的实现
	node *p = head->next;
	while (p != NULL) {
		if (p->data == x)
			return p;
		else
			p = p->next;
	}

}

error_type list::insert(const int i, const int x) {       //插入运算的实现
	node *p = head;int j = 0;
	while (j != i - 1 && p != NULL) {
		p = p->next;
		j++;
	}
	if (i<1 || i>count + 1)
		return arrange_error;
	node *s = new node;
	s->data = x;
	s->next = p->next;
	p->next = s;
	count++;
	return success;
}

error_type list::delete_element(const int i)  //删除运算的实现
{
	node *p = head; int j = 0;
	while (j != i - 1 && p != NULL) {
		p = p->next; j++;
	}
	if (i < 1 || i > count)      // if ( p == NULL ||p->next==NULL )
		return rangeerror;
	node *u = p->next;
	p->next = u->next;
	delete u;
	count--;
	return success;
}
void   list::create1() {       //表头插入法实现链表创建
	int x;
	cin >> x;
	while (x != 0) {          //截止符号是0
		count++;
		node *s = new node;
		s->data = x;
		s->next = head->next;
		head->next = s;
		cin >> x;
	}
}

void  list::create2() {       //表位插入法实现链表创建
	int x;
	cin >> x;
	node *rear = head;
	while (x != 0) {          //截止符号是0
		count++;
		node *s = new node;
		s->data = x;
		s->next = NULL;
		rear->next = s;
		rear = s;
		cin >> x;
	}
}

void  list::display() {       //输出链表
	node* p = head->next;
	while (p != NULL) { cout << p->data << " "; p = p->next; }
	cout << endl;

}
int list::loop(list L) {
	int x;
	for (int i = 1; i < L.length() + 1; i++) {
		L.get_element(i, x);
		if (x % 2 != 0) {
			cout << "链表不是每个结点的值都是偶数" << endl;;
			goto k;
		}
	}
	cout << "链表每个结点的值都是偶数" << endl;;
  k:	return 0;
}



int main() {
	list L;
	cout << "请输入L：（以0结束）" << endl;
	L.create1();
	L.loop(L);
	return 0;
}

 

张暖心
关注
  • 12
    点赞
  • 踩
  • 50
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c语言数据结构期末实验汇总
12-11
期末对这学期做过的各个实验做了个汇总,现在发出来,希望对大家有所帮助.其中包括的实验有: 实验一 线性表的运算与应用 实验二 栈和队列及其应用 实验三 二叉树的存储与遍历 实验四 图的创建和遍历 实验五 顺序查找与二分查找 实验六 直接插入排序的快速排序算法
基于Python的数据结构大作业+实验报告
08-16
通过一系列挑战性的大作业和详细的实验报告要求，你将掌握各种Python数据结构的原理、应用和实际问题解决方法。从基础数据类型到高级数据结构，我们引导你构建坚实的编程基础和问题解决能力。 适用人群： 编程初学...
《数据结构》实验课期末考试
weixin_44197749的博客
01-01 1723
#代码是直接从提交的答题卡上复制的，可能格式啥有错 #运行结果当时要求用自己的姓名就不粘过来了 题目： 1、（30分）利用自己的姓名拼音字母建立一个单链表（带头结点），注意，如果链表存在已知字母，则不能插入。输入格式样例： 请输入姓名：LIMING 建立的单链表输出为：L->I->M->N->G->^ 注： （1）输入自己姓名拼音，大写全拼，中间无空格； （2）如果链表长度小于5（不含），则在单链表尾部，反复插入单个字母A，直到链表长度等于5为止。 2、在1所建立的单链表基础上
数据结构之集合
DayDayUp
10-25 884
集合是不同对象（称为成员）的无序聚集。集合是成员彼此之间相关，但每个成员在集合中只出现一次的无序聚集。集合的两个特点： 成员是无序的 每个成员都只在集合中出现一次 集合的应用： 数据关联：用来确定数据集合之间的关系，例如，求两个集合之间的交集， 集合覆盖：一种优化求解问题。例如从一大堆选手中挑选人员来组成一支队伍，每名队员都具有某种特定的技能的组合。我们可以采用集合覆盖的抽象方法来组成一只拥有特定技能组合的最小团队。也就是说，对于团队这个集合所需要的任意一种技能，队伍中应该至少有一名队员拥有这项能力。
输入一组数，构建有序链表 （C语言实现）
阳光大男孩！！！的博客
07-04 2826
要求说明 输入一组数，构建有序链表。 整体思路 用数组保存这组数，每次都去找最小值，把最小值构建结点并使用头插法插入到单链表中。 然后将该值删掉(为简便起见，把值弄成MAX)。 这里使用的是类直接插入的排序方法。 代码实现 #include <stdio.h> #include <stdlib.h> #define MAX 1000000 // 单链表结构体定义 typedef struct node { int val; struct node *next; } n
创建单链表，然后进行递增排序
山重水复疑无路,柳暗花明又一村
11-25 2431
创建单链表，然后进行递增排序 实现代码： #include #include typedef struct LNode{ int data; struct LNode *next; }LNode; void CreateLink(LNode *&h,int a[],int n){ int i; LNode *s,*t; h=(LNode *)malloc(sizeof(LNode
数据结构C语言期末实验作业
08-15
适合大一，大二学生，数据结构期末作业带有顺序表+链表+顺序栈+链栈+顺序队列+链队+二叉树(先序遍历+中序遍历+后序遍历)带结构图
基于C++的大二下Linux和数据结构实验报告设计源码
最新发布
05-24
本项目是基于C++的大二下Linux和数据结构实验报告设计源码，包含64个文件，...这个项目用于存放大二下期Linux和数据结构实验课的实验报告，以及选修课的期末课程报告，旨在帮助学生更好地整理和回顾实验和课程内容。
数据结构实验.rar
06-29
实验一： 1、（必做题）采用函数统计学生成绩：输入学生的成绩，计算并输出这些学生的最低分、最高分、平均分。 2、（必做题）采用递归和非递归方法计算k阶裴波那契序列的第n项的值，序列定义如下： f0=0, f1=0, …,...
数据结构期末上机考试程序及实验报告
01-05
刚刚考完的数据结构上机的内容，自己做的，可能写得不太好，但考虑到最好不要让它流传的范围太广所以把分设得高一点，希望对还没有进行期末考试的同志们有个借鉴，也希望大家看完后能留言指出其中的不足
设A和B是两个单链表，其表中元素递增有序
11-29
设A和B是两个单链表，其表中元素递增有序。试写一算法将A和B归并成一个按元素值递减有序的单链表C，并要求辅助空间为O(1),试分析算法的时间复杂度。
大二数据结构实验报告
01-04
2013级数据结构试验（栈、链表、图等等）
数据结构与算法 -李春葆 实验报告-顺序表
12-20
大学生期末作业救命稻草 包含实验源代码，算法描述，代码运行结果截图，实验总结以及算法流程图。
数据结构实验报告（本科时用过的）.zip
11-08
本科时用过的 【数据结构】实验报告。
学生成绩管理系统（数据结构）实验报告.docx
07-10
期末实践周必备（数据结构）学生成绩管理系统，基于C语言完成的，百分百作者原创，资源保证！
数据结构单链表学习笔记
qq_52544734的博客
05-27 329
数据结构上机 单链表 尾插法创建链表 头插法创建链表 销毁链表 求链表长度 求单链表中第i个元素 在第i个节点前插入值为x的节点 在链表中查找元素值为x的节点 删除元素第i个元素节点 在递增有序的单链表l中插入一个值为x的元素保持递增有序 将单链表中的奇数项和偶数项分解开 求递增有序单链表中l1和l2的公共元素 放入新的单链表l3 删除重复元素 递增有序单链表L1、L2，不申请新结点，利用原表结点对2表进行合并，并使得合并后成为一个集合，合并后用L1的头结点作为头结点，删除L2的头结点，要求时间性能最好。
单链表编写递增有序并集（c语言实现）
半岛落枫的博客
09-27 1644
#include #include #define OK    1 typedef int status; typedef int ElemType; typedef struct Node{       ElemType data;       struct Node *next; }LNode,*LinkList; void creat(LinkList L); v
C语言：有序单链表的创建
qq_43432875的博客
12-16 1万+
如何创建一个带头结点的有序的单链表？ 链表在创建的时候就把它创建成有序的会显得专业许多（雾）， 而不是先创建无序链表再排序； 拿一道典型例题举个栗子，相信你们都见过这道题； Problem Description 输入N个无序的整数，建立一个有序链表，链表中的结点按照数值非降序排列，输出该有序链表。 Input 第一行输入整数个数N； 第二行输入N个无序的整数。 Output 依次输出有序链表的...
将两个递增的有序链表合并为一个递增的有序链表（C语言编程实现）
热门推荐
强强强子的博客
10-11 4万+
将两个递增的有序链表合并为一个递增的有序链表。要求结果链表仍使用原来两个链表的存储空间, 不另外占用其它的存储空间。表中不允许有重复的数据。 #include #include typedef struct list { int data; struct list * next; //下一个节点地址 }list; //第一条链表 struct list
中南大学943数据结构
05-24
中南大学943数据结构是指中南大学计算机科学与技术专业的一门必修课程，主要内容包括数据结构基础知识、算法分析和设计等方面的内容。该课程的教学目的是让学生掌握数据结构的基本概念和常用算法，培养学生的算法设计和程序实现能力，为学生今后的计算机科学研究和实践工作打下坚实的基础。该课程的考核方式一般包括平时成绩、作业、实验和期末考试等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值