数据结构基础复习——带头结点的单链表的实现

最新推荐文章于 2023-01-14 11:22:16 发布
最新推荐文章于 2023-01-14 11:22:16 发布
阅读量479 收藏 6
点赞数 2
分类专栏： 数据结构 文章标签： 数据结构 链表 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44001521/article/details/103722662
版权 
#include<iostream>
using namespace std;

typedef int  ElementType;//定义类型
typedef struct LNode{	//结点类型
	ElementType data;	//结点的数据域
	struct LNode * next;//指针域
}LNode,*LinkList;				//LinkList 为指向结构体LNode的指针类型;

//和之前学的不同点： 增加头结点
//1、初始化

bool InitList(LinkList & L) {//头指针
	L = new LNode;
	L->next = NULL;
	return true;
}

//2.1创建链表  前插法：逆序输出，头结点后增加
bool CreateList1(LinkList & L) {
	int a = 0, b = 0;
	L = new LNode;
	L->next = NULL;
	cout << "please input the length of the list:" << endl;
	cin >> a;
	if (a <= 0) return false;
	LinkList p;
	while (a--) {
		p= new LNode;
		cout << "input the number" << endl;
		cin >> b;
		p->data = b;
		p ->next= L->next;//插入L头结点后面
		L->next = p;
	}
	L->next = NULL;
	return true;
}

//3 后插法 
bool CreateList2(LinkList & L) {
	int a = 0, b = 0;
	L = new LNode;
	L->next = NULL;
	cout << "please input the length of the list:" << endl;
	cin >> a;
	LinkList p,r;
	r = L;//尾结点指向头结点
	while (a--) {
		p = new LNode;
		cout << "input the number" << endl;
		cin >> b;
		p->data = b;
		p->next = NULL;
		r->next=p;//插入L尾指针后面
		r=p;
	}
	return true;
}

//4.取值，复杂度o((n-1)/2) 1《i《n,移动步数(i-1)
bool GetElem(LinkList L, int i, ElementType & e) {
	LinkList p = new  LNode;
	p = L->next; 
	int j = 1;
	while (p&& j < i) {
		p = p->next;
		++j;//次数增加
	}
	if (!p&&j > i) return false;
	e = p->data;
	return true;
}

//5.查找 复杂度同上,按值查找
LNode * LocateElem(LinkList L, ElementType e) {
	LinkList p = new LNode;
	p = L->next;//初始指向首元结点
	while (p && p->data != e) {//向后扫描，直到p为空或p值等于e
		p = p->next;
	}
	return p;
}

//6.插入 复杂度o(n) 复杂度o((n)/2) 1《i《n,移动步数(i-1)
bool ListInsert(LinkList & L, int i,ElementType e) {
	//在带头结点的单链表L中第i个位置插入值为e
	LinkList p,s;
	p = new LNode;
	p = L;
	int j = 0;//计算步数
	while (p && (j < i - 1)) {//加到插入位前一位
		p = p->next;
		++j;
	}
	if (!p || j > i - 1) 
		return false;
	s = new LNode;
	s->data = e;
	s->next = p->next;
	p->next = s;
	return true;
}

//7.删除 第几个结点o((n-1)/2)
bool ListDelete(LinkList &L, int i)
 {
	LinkList p,q;
	p = new LNode;
	p = L;//头结点
	int j = 0;
	while ((p->next) && (j < i - 1)) {
		p = p->next; ++j;
	}
	if (!(p->next) || (j > i - 1)) 
		return false;
	q = new LNode;
	q = p->next;
	p->next = q->next;
	delete q;
	q = NULL;
	return true;
}

//8.输出列表
void TraverseList(LinkList L) {
	LinkList p;
	p = new LNode;
	p = L->next;//头结点
	if (!p) 
	cout << " NULL " << endl;
	while (p) {
		cout << p->data << " ";
		p = p->next;
	}
}

//9.销毁 毁掉头
void DestroyList(LinkList &L) {
	if (!L) { 
		cout << "List NULL" << endl; 
	}
	else {
		LinkList p = new LNode;
		LinkList q = new LNode;
		p = L;//头结点
		while (p!=NULL) {
			q = p->next;
			delete p;
			p = q;
		}
		cout << "destroy OK" << endl;
	}
}

//10.清空  只留下头
void ClearList(LinkList &L) {
	if (!L) {
		cout << "List NULL" << endl;
	}
	else {
		LinkList p, q;
		p = new LNode;
		p = L->next;
		while(p!=NULL){
			q = p->next;
			delete p;
			p = q;
		}
		L->next = NULL;
		cout << "clear OK" << endl;
	}
}

//11.有序表的合并,有重复的
bool  MergeList1(LinkList & L1, LinkList & L2,LinkList & L3) {//小到大排序
	LinkList  pc, pa, pb;
	pa = L1->next;
	pb = L2->next; 
	L3 = pc=L1;
	while (pa&&pb) {
		if (pa->data <= pb->data) {
			pc->next = pa;
			pc = pa;
			pa = pa->next;
		}
		else { 
			pc->next = pb;
			pc = pb;
			pb = pb->next;
		}
	}
	pc->next = pa? pa : pb;
	delete L2;		//释放Lb的头结点
	L2 = NULL;
	return true;
}

//12.合并2个同时为递增或递减的序列，没有重复
bool MergeList(LinkList &La, LinkList &Lb, LinkList &Lc) {
	LinkList pa, pb, pc,temp;
	pa = La->next;
	pb = Lb->next;
	Lc = pc = La;
	while (pa &&  pb) {
		if (pa->data < pb->data) {
			pc->next = pa; pc = pa; pa = pa->next;
		}
		else if (pa->data > pb->data) {
			pc->next = pb; pc = pb; pb = pb->next;
		}
		else {
			pc->next = pa;
			pc = pa;
			pa = pa->next;
			temp = pb->next;
			delete pb;
			pb = temp;
		}
	}
	pc->next = pa ? pa : pb;
	delete Lb;
	return true;
}

//13.逆置且不开辟新空间,只能改变指针指向，且用前插法简单
void Inverse(LinkList &L) {
	LinkList p, q;
	p = L->next;
	L->next = NULL;
	while (p != NULL) {
		q = p->next;
		p->next = L->next;
		L->next = p;
		p = q;
	}
}

//14.递增序列删除闭区间值结点
void DeleteMinMax(LinkList &L, int mink, int maxk) {
	LinkList p=L->next,pre=NULL,q=NULL,s=NULL;
	while (p&&p->data < mink) {
		pre = p;
		p= p->next;
	}
	while (p&&p->data <= maxk) {
		p = p->next;
	}
	q = pre->next;
	pre->next = p;
	while (q != p) {
		s = q->next;
		delete q;
		q = s;
	}
}

//15.差异 在A中减少B的元素,A,B都是单调递增
void Difference(LinkList &L1, LinkList&L2,int & n) {
	LinkList pa, pb, pre,temp;
	pa = L1->next; pb = L2->next;
	pre = pa; n = 0;
	while (pa&&pb) {
		if (pa->data < pb->data) {
			pre = pa; pa = pa->next;
			n++;
		}
		else if (pa->data > pb->data) {
			pb = pb->next;
		}
		else {
			pre->next = pa->next;
			temp = pa;
			pa = pa->next;
			delete temp;
		}

	}
}

//16.交集
bool Intersection(LinkList &La, LinkList &Lb, LinkList &Lc) {
	LinkList pa, pb, pc, temp;
	pa = La->next;
	pb = Lb->next;
	Lc = pc = La;
	while (pa &&  pb) {//删除较小者的元素
		if (pa->data < pb->data) {
			temp = pa; pa = pa->next; delete temp;
		}
		else if (pa->data > pb->data) {
			temp = pb; pb = pb->next; delete temp;
		}
		else {
			pc->next = pa; pc = pa; pa = pa->next;
			temp = pb; pb = pb->next; delete temp;
		}
	}
	while (pa) {
		temp = pa; pa = pa->next; delete temp;
	}
		while(pb) {
			temp = pb; pb = pb->next; delete temp;
		}
	pc->next = NULL;
	delete Lb;
	return true;
}

int main() {
	LinkList mylist=new LNode;
	int i, e, x;
	cout << "1.初始化\n";
	cout << "创建方法只能选择一个:\n";
	cout << "2.创建（前插法）\n";
	cout << "3.创建（后插法）\n";
	cout << "4.取值" << endl;
	cout << "5.查找\n";
	cout << "6.插入\n";
	cout << "7.删除\n";
	cout << "8.输出\n";
	cout << " 9.销毁\n";
	cout << " 10.清零\n";
	cout << " 11.单序合并(无重复）\n ";
	cout << "12.单序合并（有重复）\n";
	cout << "13.逆置\n";
	cout << "14.删除闭区间内数据\n";
cout<< "15.差异\n";
cout << "16.交集\n";
cout << "0.退出\n";
	int choice = -1;
	while (choice != 0) {
		cout << "\nchoice=" << endl;
		cin>> choice;
		switch (choice) {
		case 1: //初始化
			if (InitList(mylist))
				cout << "顺序表初始化成功" << endl;
			else cout << "顺序表初始化不成功" << endl;
			break;
		case 2://前入创建
			if (CreateList1(mylist)) {
				cout << "顺序表创建成功" << endl;
				break;
			}
			else
				cout << "顺序表创建不成功" << endl;
			break;
		case 3://后入创建
			if (CreateList2(mylist)) {
				cout << "顺序表创建成功" << endl;
				break;
			}
			else
				cout << "顺序表创建不成功" << endl;
			break;
		case 4://取值
			cout << "输入第i（整数）个元素" << endl;
			cin >> i;
			if (GetElem(mylist, i, e) == 1) {
				cout << "第" << i << "个元素是" << e << endl;
			}
			else if (GetElem(mylist, i, e) == 0)
				cout << "顺序表取值失败,overflow" << endl;
			break;
		case 5://查找
			cout << "查找的数字：" << endl;
			cin >> x;
			if (LocateElem(mylist, x) == NULL) {
				cout << "查无此数字" << endl;
			}
			else
				cout << "查找成功，要找的数字结点的位置是" << LocateElem(mylist, x) << endl;
			break;

		case 6://插入
			cout << "要插入的位置和值分别是:" << endl; cin >> i >> e;
			if (ListInsert(mylist, i, e)) {
				cout << "插入成功" << endl;
			}
			else cout << "插入失败" << endl;
			break;
		case 7://删除
			cout << "要删除的位置分别是:" << endl; cin >> i;
			if (ListDelete(mylist, i)) {
				cout << "删除成功" << endl;
			}
			else cout << "删除失败" << endl;
			break;
		case 8://输出
			TraverseList(mylist);
			break;
		case 9://销毁
			DestroyList(mylist);
			break;
		case 10://清零
			ClearList(mylist);
			break;
		case 11:
			LinkList mylist2, mylist3;
			if (InitList(mylist2))
				cout << "顺序表mylist2初始化成功" << endl;
			else {
				cout << "顺序表mylist2初始化不成功" << endl;
				break;
			}
			if (CreateList2(mylist2)) {
				cout << "顺序表mylist2创建成功" << endl;
			}
			else {
				cout << "顺序表创建不成功" << endl;
				break;
			}
			if (InitList(mylist3))
				cout << "顺序表初始化成功" << endl;
			else {
				cout << "顺序表初始化不成功" << endl;
				break;
			}
			cout << "mylist1=";
			TraverseList(mylist);
			cout << "\nmylist2=";
			TraverseList(mylist2);
			MergeList(mylist, mylist2, mylist3);
			cout << "\nmylist3=";
			TraverseList(mylist3);
			break;
		case 12:
			if (InitList(mylist2))
				cout << "顺序表mylist2初始化成功" << endl;
			else {
				cout << "顺序表mylist2初始化不成功" << endl;
				break;
			}
			if (CreateList2(mylist2)) {
				cout << "顺序表mylist2创建成功" << endl;
			}
			else {
				cout << "顺序表创建不成功" << endl;
				break;
			}
			if (InitList(mylist3))
				cout << "顺序表初始化成功" << endl;
			else {
				cout << "顺序表初始化不成功" << endl;
				break;
			}
			cout << "mylist1=";
			TraverseList(mylist);
			cout << "\nmylist2=";
			TraverseList(mylist2);
			MergeList1(mylist, mylist2, mylist3);
			cout << "\nmylist3=";
			TraverseList(mylist3);
			break;
		case 13: Inverse(mylist);
			break;
			case 14: {
				int x, y;
				cout << "the min,max of border " << endl;
				cin >> x >> y;
				DeleteMinMax(mylist, x, y);
				cout << "mylist1=";
				TraverseList(mylist);
				break;
			}
			case 15:
				if (InitList(mylist2))
					cout << "顺序表mylist2初始化成功" << endl;
				else {
					cout << "顺序表mylist2初始化不成功" << endl;
					break;
				}
				if (CreateList2(mylist2)) {
					cout << "顺序表mylist2创建成功" << endl;
				}
				else {
					cout << "顺序表创建不成功" << endl;
					break;
				}
				if (InitList(mylist3))
					cout << "顺序表初始化成功" << endl;
				else {
					cout << "顺序表初始化不成功" << endl;
					break;
				}
				cout << "mylist1=";
				TraverseList(mylist);
				cout << "\nmylist2=";
				TraverseList(mylist2);
				int n;
				Difference(mylist, mylist2,n);
				cout << "\nmylist3=";
				TraverseList(mylist);
				break;
				
			case 16:
				if (InitList(mylist2))
					cout << "顺序表mylist2初始化成功" << endl;
				else {
					cout << "顺序表mylist2初始化不成功" << endl;
					break;
				}
				if (CreateList2(mylist2)) {
					cout << "顺序表mylist2创建成功" << endl;
				}
				else {
					cout << "顺序表创建不成功" << endl;
					break;
				}
				if (InitList(mylist3))
					cout << "顺序表初始化成功" << endl;
				else {
					cout << "顺序表初始化不成功" << endl;
					break;
				}
				cout << "mylist1=";
				TraverseList(mylist);
				cout << "\nmylist2=";
				TraverseList(mylist2);
				Intersection(mylist, mylist2, mylist3);
				cout << "\nmylist3=";
				TraverseList(mylist3);
				break;
				
		}
	}
}
广大菜鸟
关注
专栏目录
算法与数据结构之带头结点的单链表
谁D了我的BUG
01-01 2816
单链表的定义 #include&amp;amp;amp;amp;lt;stdio.h&amp;amp;amp;amp;gt; #include&amp;amp;amp;amp;lt;malloc.h&amp;amp;amp;amp;gt; #include&amp;amp;amp;amp;lt;stdlib.h&amp;amp;amp;amp;gt; typedef struct Node { int data; //数据域 struct
数据结构作业5--单链表
qq_41464448的博客
09-19 2125
6-1 带头结点的单链表就地逆置 （10 分） 本题要求编写函数实现带头结点的单链线性表的就地逆置操作函数。L是一个带头结点的单链表，函数ListReverse_L(LinkList &amp;L)要求在不新开辟节点的前提下将单链表中的元素进行逆置，如原单链表元素依次为1,2,3,4，则逆置后为4,3,2,1。 函数接口定义： void ListReverse_L(LinkList &am...
带头结点的单链表的实现
weixin_45009662的博客
06-07 312
带头结点的单链表的实现 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。 链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。 带头结点的单链表的结构定义： typedef int ElemType; typedef struct Node { union { int length; ElemType data; }; struct N
数据结构——串（朴素的模式匹配算法、KMP模式匹配算法）
厚积而薄发，谋定而后动
04-20 2万+
提示：以下内容不适合零基础人员，仅供笔者复习之用。 概要： 串是由零个或多个字符组成的有限序列，又名叫字符串。 一、串的比较     给定两个串，s = "a1a2.....an"，t="b1b2....bm"，当满足以下条件之一时，s n。例如，s="hap"，t="happy"，就有s存在某个k。例如，s="happen"，t="happy"，因为两串前4个字母均
单链表的划分：给定一个不带头节点的单链表和数值x，划分链表，使得所有小于x的节点排在大于等于x的节点之前（应该保留原来链表节点的相对顺序）
Henry313的博客
08-13 1476
Node* partition(Node *head, int x) //链表的划分 { Node *s=NULL; if(head==NULL) return NULL; Node *p=head; Node *phead2=NULL,*phead1=NULL; Node *p1=NULL,*p2=NULL; while(p!=NULL) { if(p-&gt...
数据结构复习——————单链表的各种操作（带头节点的初始化方法）
LiuTonyson的博客
10-06 786
代码： #include <stdio.h> #include <stdlib.h> #include <math.h> #include <string.h> typedef struct LNode{ int data; struct LNode *next; }LNode,*LinkList; //头插法建立单链表 LinkList List_HeadInsert(LinkList &L){ //每次均在头节点之后插入元素 L=
数据结构复习（Java实现）——单链表（不带头结点）
a951030393的博客
05-27 1419
Node类：package stu.cyzhang.danlianbiao; /** * 这是单链表的结点类 * @author dell *@version 1.0 * @param &lt;T&gt; */ public class Node&lt;T&gt; { private T data; //节点的数据 public Node&lt;T&gt; next...
数据结构复习题——填空题与程序填空题
最新发布
weixin_46448596的博客
01-14 5009
本题要求给出希尔排序对给定初始序列{9, 8, 7, 6, 5, 4, 3, 2, 1}利用增量序列{1, 3, 7}进行排序的分步结果。本题目要求Init_SeQueue()函数初始化循环队列，返回指向队列的指针，Empty_SeQueue(c_SeQueue *q)函数判空队列，空队列返回1。本题目要求Out_SeQueue (c_SeQueue *q , datatype *x)函数将 出循环队列的值送给变量x。/*队中元素的个数*/下列代码的功能是返回带头结点的单链表L的逆转链表。
带头结点循环链表详解：数据结构入门经典
总结来说，带头结点循环单链表是数据结构课程中的一个重要知识点，它展示了数据结构如何通过逻辑和物理结构来组织和处理数据，以及在实际问题中如何通过算法实现高效的操作。通过深入学习和实践，学生将能够掌握数据...
数据结构（C语言）——1线性表：有序单链表的交
<Hunter>
06-14 213
有序单链表的并（C语言）
数据结构 第3讲 顺序表
rainchxy的博客
09-12 4293
数据结构 第3讲 顺序表 顺序表是最简单的一种线性结构，逻辑上相邻的数据在计算机内的存储位置也是相邻的，可以快速定位第几个元素，中间不允许有空，所以插入、删除时需要移动大量元素。 顺序表可以分配一段连续的存储空间Maxsize，用elem记录基地址，用length记录实际的元素个数，即顺序表的长度， 结构体的定义： 结构体定义后，如果要定义个顺序表L，就可以写： SqLis
单链表的创建及操作
北极星的博客
03-15 1775
1、创建一个带头结点的单链表（头指针为head），且遍历此链表（输出链表中各结点的值）； 2、查找单链表中的第i个结点，并输出结点元素的值； 3、在单链表中的第i个结点前插入一个结点值为e的正整数(从外部输入); 4、删除单链表中的第j个结点； 5、将单链表中的各结点就地逆序（不允许另建一个链表）； #include #include #include using namespace std; t...
数据结构-------单链表
continuous的博客
08-01 2834
单链表 **单链表：**线性表的链式存储又称单链表。它是指通过一组任意的存储单元来存储线性表中的数据元素。每一个链表结点，除存放元素自身的信息外，还需要存放一个指向其后继的指针。 data next **双链表：**双链表结点中有两个指针prior和next，分别指向其前驱结点和后继结点。按值查找和按位查找的操作与单链表相同，插入删除操作时间复杂度仅为O(1)。 **循环单链表：**表中最后一个结点的指针不是NULL，而是指向头结点，从而整个链表形成一个环。可以从表中任意一个结点开始遍历整个链
实验3-带头结点的单链表
weixin_30502157的博客
11-03 2842
实验1： 1 /*编写函数void delx(linklist head, datatype x)，删除带头结点单链表head中第一个值为x 的结点。 2 并构造测试用例进行测试。 3 */ 4 /**********************************/ 5 /*文件名称：lab3_01.c */ 6 /**********...
南邮数据结构实验1.4：带表头结点单链表的非递减排序
Wonz
05-26 7125
题目：以实验 1.2 的带表头结点单链表为存储结构，编写程序实现单链表的非递减排序。 部分代码： 带表头结点单链表的非递减排序函数： 本来想用冒泡排序的，但是没成功，此部分程序参考了这里：https://bbs.csdn.net/topics/390668062 //简单选择排序：每次选择min的排到前面 Status Order(HeaderList *h){ Node *s1...
带头结点的单链表，采用直接插入排序的方法，按照非递减排序
CosmosSeed的博客
12-04 5647
直接插入排序的思想，就是先默认第一个元素是排序好的，在顺序表中，从后面往前依次进行比较，从而进行排序。但是在单链表中，从后面遍历的话，找结点的前驱非常困难。故需要设一指针，从头进行遍历。 代码如下： void Sort(LinkNode *&amp;L) { LinkNode *p,*pre,*q; p=L-&gt;next-&gt;next; ///p指向L的第二个...
数据结构-带头节点的单链表（C语言）超详细讲解
热门推荐
m0_56992713的博客
10-17 2万+
前面我们学到线性表的顺序存储结构（顺序表），发现它有着明显的缺点：插入和删除元素时需要频繁的移动元素，运算效率低。必须按事先估计的最大元素个数申请连续的存储空间。存储空间估计大了，造成浪费空间；估计小了，容易产生溢出，空间难以扩大。 采用链式存储结构的线性表（链表）可以克服以上的不足。 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(存放的数据元素)+指针(指示下一个元素存储位置，单、双链表的最后一个节点除外，它们.
【数据结构】第四章 串（2）朴素模式匹配算法、KMP算法（C++）
weixin_37706349的博客
06-10 1656
目录4.2_1 朴素模式匹配算法一、什么是字符串的模式匹配二、朴素模式匹配算法（1）使用字符串基本操作来实现（2）通过数组下标来实现总结：4.2_2 KMP算法一、KMP算法由来二、朴素模式匹配算法三、朴素模式匹配算法优化思路四、如何用代码实现KMP匹配过程4.2_3 KMP算法_求 next 数组一、手算二、KMP算法（next数组）完整代码4.2_4 KMP算法的进一步优化一、next 数组的优化思路二、KMP算法（nextval数组）完整代码在一段文字中搜索某一段内容。主串：被搜索的字符串。模式串：想
单链表算法题
qq_59961221的博客
10-10 2398
头插法建立单链表 #include "stdio.h" #include "stdlib.h" //单链表存储结构 typedef struct LNode{ int data; struct LNode *next; }LNode, *LinkList;//区别：LNode指向某个结点, *LinkList指向整个单链表 //初始化 分配空间 void InitList_L(LinkList &L){ L = (LinkList)malloc(sizeof(LNode));
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

广大菜鸟

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值