用c++写的单链表排序

最新推荐文章于 2025-02-24 23:13:19 发布
最新推荐文章于 2025-02-24 23:13:19 发布
阅读量3.6k 收藏 2
点赞数
CC 4.0 BY-SA版权
分类专栏： 大学学习时光
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Doraemon___/article/details/53223571
头文件node.h
#pragma once
template <class T>
class Node
{
public:
	T data;
	Node<T> * next;
	Node();
	Node(T data, Node<T>*next = NULL);
	~Node() {};
	bool operator!=(Node<T> *list);
};


template <class T>
Node<T>::Node()
{
	this->next = NULL;
}
template <class T>
Node<T>::Node(T data, Node<T>*next = NULL)
{
	this->data = data;
	this->next = next;
}

template<class T>
inline bool Node<T>::operator!=(Node<T> *list)
{
	return (this == list);
}
单链表的头文件
#pragma once
#include <iostream>
#include "Node.h"
using namespace std;
template <class T>
class SingleList
{
private:

public:
	Node<T> *head;
	SingleList();
	SingleList(T values[], int n);
	~SingleList();

	bool IsEmpty();
	int count();
	Node<T>* last();
	Node<T>* get(int n);
	virtual void set(int i, T x);
	friend ostream& operator<<<>(ostream&, SingleList<T>&);
	Node<T>* insert(int i, T x);
	virtual Node<T>* insert(T x);
	T remove(int i);
	void removeAll();
	Node <T> * search(T key);
	void insertUnrepeatable(T x);
	virtual void removeFirst(T key);
	void ChangeOver();
	
	void insertAll(int i, SingleList<T> &list);
		 //在*this第i个结点前插入list的所有元素。对i容错，若i<0，头插入；若i>长度，尾插入。不改变list
	bool containAll(SingleList<T> &list);      	//判断是否子集，*this是否包含list所有元素
	bool operator==(SingleList<T>&list);
	
	bool operator!=(SingleList<T>&list);
	SingleList(SingleList<T>&list);
	SingleList<T>* operator=(SingleList<T>&list);
	virtual void operator+=(SingleList<T>& list);
	void subList(int i,int n);            	//返回从第i个结点开始、长度为n的子表
};
template<class T>
void SingleList<T>:: subList(int i,int n)
{
	int k = 0;
	Node<T>*q = this->head;
	Node<T>*p = this->head->next;
	for (int j = 0; j < i&&p != NULL; j++)
		p = p->next; 
	while (p != NULL&&k<n) {
		q->next = new Node<T>(p->data);
		q = q->next;
		p = p->next;
		k++;
	}



}
template<class T>
void SingleList<T>::insertAll(int i, SingleList<T> &list)
{
	int len = this->count();
	if (i <= 0){
		Node<T> *p = list.head->next;
		Node<T> *qfront = this->head;
		Node<T> * tmp = this->head->next;
		while (p != NULL) {
			qfront->next = new Node<T>(p->data, tmp);
			qfront = qfront->next;
			p = p->next;
		}
	}else if (i >=len){
		Node<T> *p = list.head->next;
		Node<T> *qfront = this->head;
		while (qfront->next != NULL) {
			qfront = qfront->next;
		}
		while (p != NULL) {
			qfront->next = new Node<T>(p->data);
			qfront = qfront->next;
			p = p->next;
		}
	}else{
		Node<T> * qfront = this->head;
		Node<T> * p = list.head->next;
		for (int j = 0; j < i; j++)
			qfront = qfront->next;
		Node <T> *tmp = qfront->next;
		while (p != NULL) {
			qfront->next = new Node<T>(p->data,tmp);
			qfront = qfront->next;
			p = p->next;
		}
	}
}
template<class T>
bool SingleList<T>::containAll(SingleList<T> &list)      	//判断是否子集，*this是否包含list所有元素
{
	Node<T>*p = this->head->next;
	Node<T>*q = list.head->next;
	for (; q != NULL; q->next)
	{
		while (q->data != p->data)
		{
			p=p->next;
		}
		
	}
	return this;
}



template <class T>
SingleList<T>::SingleList()
{
	this->head = new Node<T>();
}
template <class T>
SingleList<T>::SingleList(T values[], int n)
{
	this->head = new Node<T>();
	Node<T> *rear = this->head;
	for (int i = 0; i < n; i++) {
		rear->next = new Node<T>(values[i]);
		rear = rear->next;
	}
}
template <class T>
SingleList<T>::~SingleList()
{
	this->removeAll();
	delete this->head;
}


template <class T>
bool SingleList<T>::IsEmpty()
{
	return this->head->next == NULL;
}
template<class T>
int SingleList<T>::count()
{
	int count = 0;
	Node<T> *p = this->head->next;
	while (p != NULL) {
		p = p->next;
		count++;
	}
	return count;
}
template<class T>
inline Node<T>* SingleList<T>::last()
{
	if (this->IsEmpty())
		return NULL;
	Node<T> *p = this->head->next;
	while (p->next != NULL)
		p = p->next;
	return p;
}
template <class T>
ostream& operator<<<>(ostream& out, SingleList<T> &list)
{
	out << "(";
	for (Node<T> *p = list.head->next; p != NULL; p = p->next) {
		out << p->data;
		if (p->next != NULL)
			out << ",";
	}
	out << ")" << endl;
	return out;
}
template <class T>
Node<T>* SingleList<T>::get(int n)
{
	Node<T> *p = this->head->next;
	for (int i = 1; p != NULL&&i < n; i++)
		p = p->next;
	if (n >= 0 && p != NULL)
		return p;
	throw out_of_range("参数超过序列范围");
}
template<class T>
void SingleList<T>::set(int i, T x)
{
	Node<T> * front = this->head;
	for (int j = 1; front->next != NULL&&j < i; j++)
		front = front->next;
	if (i > 0 && front->next != NULL) {
		Node<T> *p = front->next;
		p->data = x;
		return;
	}
	throw out_of_range("i超出范围。\n");
}
template <class T>
Node<T> * SingleList<T>::insert(int i, T x)
{
	Node<T> * front = this->head;
	for (int j = 1; front->next != NULL&&j < i; j++)
		front = front->next;
	front->next = new Node<T>(x, front->next);
	return front->next;
}
template<class T>
Node<T>* SingleList<T>::insert(T x)
{
	Node<T> *p = this->last();
	if (p == NULL)
		this->head->next = new Node<T>(x);
	else
		p->next = new Node<T>(x);
	return p->next;
}
template <class T>
T SingleList<T>::remove(int i)
{
	Node<T> *front = this->head;
	for (int j = 1; front != NULL&&j < i; j++)
		front = front->next;
	if (i >= 0 && front->next != NULL) {
		Node<T> *q = front->next;
		front->next = q->next;
		T odd = q->data;
		delete q;
		return odd;
	}
	throw out_of_range("i超出范围\n");
}

template<class T>
void SingleList<T>::removeAll()
{
	Node<T> *p = this->head->next;
	Node<T> *temp = NULL;
	while (p != NULL) {
		temp = p;
		p = p->next;
		delete temp;
	}
	head->next = NULL;
}

template<class T>
Node<T>* SingleList<T>::search(T key)
{
	Node<T> *p = this->head->next;
	while (p != NULL && p->data != key)
		p = p->next;
	if (p != NULL)
		return p;
	else
		return NULL;
}

template<class T>
void SingleList<T>::insertUnrepeatable(T x)
{
	Node<T> * p = this->head;
	while (p->next != NULL&&p->data != x)
		p = p->next;
	if (p->next == NULL)
		p->next = new Node<T>(x);
}

template<class T>
void SingleList<T>::removeFirst(T key)
{
	Node<T> *front = this->head;
	while (front->next != NULL && front->next->data != key)
		front = front->next;

	if (front->next->data == key) {
		Node<T> * p = front->next;
		front->next = p->next;
		delete p;
	}
}

template<class T>
void SingleList<T>::ChangeOver()
{
	Node<T> * front, *p, *succ;
	if (this->IsEmpty())
		return;
	front = this->head->next;
	p = front->next;
	if (p == NULL)
		return;
	succ = p->next;
	front->next = NULL;
	while (succ != NULL) {
		p->next = front;
		front = p;
		p = succ;
		succ = succ->next;
	}
	p->next = front;
	this->head->next = p;
}

template<class T>
bool SingleList<T>::operator==(SingleList<T> &list)
{
	Node<T> *p1 = this->head;
	Node<T> *p2 = list.head;
	while (p1 != NULL&&p2 != NULL && p1->data == p2->data)
	{
		p1 = p1->next;
		p2 = p2->next;
	}
	return p1 == NULL && p2 == NULL;
}

template<class T>
bool SingleList<T>::operator!=(SingleList<T>& list)
{
	Node<T> *p1 = this->head;
	Node<T> *p2 = list.head;
	while (p1 != NULL&&p2 != NULL && p1->data == p2->data) {
		p1 = p1->next;
		p2 = p2->next;
	}
	return !(p1 == NULL && p2 == NULL);
}

template<class T>
SingleList<T>::SingleList(SingleList<T>& list)
{
	Node<T> *p1;
	Node<T> *p2 = list.head->next;
	p1 = this->head = new Node<T>();
	p1->next = NULL;
	while (p2 != NULL) {
		p1->next = new Node<T>(p2->data);
		p1 = p1->next;
		p2 = p2->next;
	}
	p1->next = NULL;
}

template<class T>
SingleList<T>* SingleList<T>::operator=(SingleList<T>& list)
{
	SingleList *temp = new SingleList<T>();
	Node<T> *p1;
	Node<T> *p2 = list.head->next;
	p1 = this->head;
	while (p2 != NULL) {
		p1->next = new Node<T>(p2->data);
		p1 = p1->next;
		p2 = p2->next;
	}
	p1->next = NULL;
	return this;
}

template<class T>
void SingleList<T>::operator+=(SingleList<T>& list)
{
	if (this->IsEmpty()) {
		this->head->next = list.head->next;
	}
	else {
		Node<T> *p = this->last();
		p->next = list.head->next;
	}
}


#pragma once
#include "SingleList.h"
template <class T>
class SortedSinglyList :public SingleList<T>
{
public:
	SortedSinglyList(bool asc = true);
	SortedSinglyList(T values[], int n, bool asc = true);
	SortedSinglyList(SingleList<T>&list, bool asc = true);
	~SortedSinglyList();

	void set(int i, T x);
	Node<T>* SetPoint(Node<T> *front, T key);
	Node<T> *insert(T x);
	void insertUnrepeatable(T x);
	Node<T> * search(T key);
	void removeFirst(T key);

private:
	bool asc;
};

template<class T>
SortedSinglyList<T>::SortedSinglyList(bool asc)
{
	this->asc = asc;
}

template<class T>
SortedSinglyList<T>::SortedSinglyList(T values[], int n, bool asc)
{
	this->asc = asc;
	for (int i = 0; i < n; i++)
		this->insert(values[i]);
}

template<class T>
SortedSinglyList<T>::SortedSinglyList(SingleList<T>& list, bool asc)
{
	this->asc = asc;
	Node<T> *p = list.head->next;
	while (p != NULL)
	{
		this->insert(p->data);
		p = p->next;
	}
}

template<class T>
SortedSinglyList<T>::~SortedSinglyList()
{
}

template<class T>
void SortedSinglyList<T>::removeFirst(T key)
{
	Node<T> *front = head, *p = head->next;
	while (p != NULL && (this->asc ? key > p->data:key < p->data))
	{
		front = p;
		p = p->next;
	}
	if (p != NULL&&key == p->data)
	{
		front->next = p->next;
		delete p;
	}
}

template<class T>
void SortedSinglyList<T>::set(int i, T x)
{
	throw logic_error("不支持此操作");
}






template<class T>
Node<T>* SortedSinglyList<T>::SetPoint(Node<T> *front, T key)
{
	Node <T> *p = front->next;
	if (p != NULL && (asc ? key > p->data:key < p->data))
		SetPoint(p, key);
	else
		return front;
}
template<class T>
Node<T>* SortedSinglyList<T>::insert(T x)
{
	//Node<T> *front = head, *p = head->next;
	//while (p != NULL && (this->asc ? x >= p->data : x <= p->data))
	//{
	//	front = p;
	//	p = p->next;
	//}
	//Node<T> *q = new Node<T>(x, p);
	//front->next = q;
	//return q;
	Node<T> *front = SetPoint(this->head, x);
	Node<T> *q = new Node<T>(x, front->next);
	front->next = q;
	return q;
}




template<class T>
void SortedSinglyList<T>::insertUnrepeatable(T x)
{
}

template<class T>
Node<T>* SortedSinglyList<T>::search(T key)
{
	return NULL;
}
下面是主函数
#include "SortedSinglyList.h"


int main()
{
	int tt[] = { 100,200,300,400,500,600,700,150,20 };
	int tt2[] = { 100,200,300,400,500,600,700,150,10 };
	SingleList<int> temp(tt, 9);
	SingleList<int> temp2(tt2, 9);
	cout << temp << endl;
	cout << temp2 << endl;
	SortedSinglyList<int> demo(temp);
	cout << demo << endl;
	SortedSinglyList<int> demo2(tt, 9,false);
	cout << demo2 << endl;
	cout<<temp.containAll(temp2);
	temp.subList(2,2);
	cout << temp;
	temp.insertAll(2, temp2);
	cout << temp << endl;

	getchar();

	return 0;
}
最后运行的效果是数组从小到大排序
c++ 链表排序
re
05-11 3906
node *bubbleSortList(node *head) { if (head == NULL || head->next == NULL) return head; node *p = NULL; bool isChange = true; while (p != head->next->next && i...
c++实现单链表的简单排序【冒泡排序，选择排序，插入排序】
weixin_45902800的博客
03-27 4110
结构体： typedef struct Node { int data; Node* next; Node(int x) :data(x), next(NULL) {}; }*BiNode; 创建链表 void create_Link(BiNode &head, int x) { Node* p = new Node(x); if (head == NULL) head = p; else { Node* cur = head; while (cur->next) {
数据结构C++单链表冒泡法排序
12-06
数据结构，单链表冒泡法排序数据结构，C++实现，可输入式程序
C++链表的排序实现
suren_jun的博客
10-18 5720
对于链表的排序算法，除了希尔排序之外，且堆排序不建议，其他排序方法都是支持的，如下：冒泡排序，选择排序，插入排序，归并排序，快速排序，计数排序，桶排序和基数排序。下面废话不多说。
单链表的排序（C++）
最新发布
m0_74091276的博客
02-24 651
本文介绍了如何使用归并排序对链表进行排序。首先通过Merge函数合并两个有序链表，再通过sortInList函数递归地拆分链表并排序。归并排序的优势在于其稳定性和 O(nlog⁡n)O(n \log n) 的时间复杂度，尤其适合链表结构的排序，因为它不需要额外的数组空间。通过快慢指针的拆分和递归合并，最终实现了一个高效的链表排序算法。
C++单链表排序
热门推荐
coolsunxu的博客
04-29 1万+
#include&lt;iostream&gt; #define ElemType int using namespace std; typedef struct Node { ElemType data; struct Node *next; }; void Create(Node *&amp;l) { //尾插法 int x; l-&gt;next = NULL; //头结点 ...
C++实现单链表按k值重新排序的方法
08-30
本文主要介绍了C++实现单链表按k值重新排序的方法，通过结合实例形式分析了C++单链表中按照给定值进行判断与排序的相关操作技巧。 一、单链表的定义 在C++中，单链表是一种基本的数据结构，由一系列节点组成，每个...
用C++写单链表的排序
09-29
在C++中，可以使用多种算法对单链表进行排序，这里以插入排序为例，因为它的原理简单直观，适合处理小规模数据或者部分有序的数据： ```cpp #include // 定义链表节点结构体 struct ListNode { int val; ...
C++实现单链表及其19种操作
程序猿老樊的博客
02-23 496
单链表是一种线性数据结构，由一系列节点组成，这些节点按顺序链接。每个节点包含数据部分和一个指向下一个节点的指针。链表的第一个节点称为头节点 ，最后一个节点的指针指向空 ，表示链表的结束。在C++语言中，可以使用结构体来定义节点：int data;} Node;//定义链表节点结构int data;Node* next;以上代码完整实现了所有18种链表操作，并包含快速排序实现。使用时需要注意指针操作的正确性和内存管理。
C++实现单链表的构造
08-19
在C++中，我们可以使用Sort函数来实现链表的排序，如下所示： ```cpp template void List<T>::Sort(){ // ... } ``` 四、总结 我们已经详细介绍了C++实现单链表的构造，包括链表的定义、链表的构造、链表的操作等...
用C++实现的链表的排序：选择排序和冒泡排序
12-11
这是根据数据结构书上讲的线性表的排序方法改写成链表，上面有简单的测试程序。
单链表排序
02-28
单链表排序
c/c++实现链表排序
11-07
简单实现链表排序，利用图形深入浅出的讲解，涵盖排序遇到很多问题，详细的很，助你轻松理解链表排序。
C++对单向链表进行排序
Mr.horse的博客
04-27 2064
#include <iostream> using namespace std; struct student { int num; char name[10]; float score[3]; float sum; student *next; }; void main() { student a[5]; student *h, *curr, *temp, *las...
C++链表冒泡，归并，插入排序（纯指针）
liuhuiyan_2014的专栏
07-16 1391
#include <iostream> using namespace std; //别问我为什么要写链表的冒泡排序。 struct Node { int data; Node *next; Node(int d = int()) :data(d), next(NULL){} }; class List { public: List(int a[], int n)
C++ 链表，排序
u013664757的专栏
07-09 728
1/ 链表插入排序问题。 /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: ...
c++ 单链表排序及测试案例
jiletianzun的博客
11-01 389
#include<iostream> using namespace std; //链表结构体 typedef struct Node { int val; struct Node* next; }LinkNode; //寻找支点 Node* GetPoint(LinkNode* head, LinkNode* tail) { int key = head->val; //假设支点的值为头节点的值 LinkNode* p = head; //定义一个指针指向头结点 L.
链表的快速排序（C/C++实现）
suhuamo的博客
09-15 2354
快速排序的是交换排序其中的一种，主要是采用分治的思想，每次迭代在当前区间中选取一个数作为哨兵，通过一系列的交换操作将当前区间分为左区间和右区间【使得左区间的值全部小于等于哨兵，右区间的值全部大于等于哨兵】。然后再对左区间、右区间执行这种划分区间的策略操作，当区间的长度为1时停止。等到所有分治的区间长度都为1时，此时的原数组就已经是一个排好序的数组了。// 当前区间的长度小于等于1时停止循环// 创建哨兵 mid// 创建i，j指针进行移动。
C/C++单链表排序
2301_78638761的博客
04-11 475
1.尾插法建立链表。 2.读取链表。 3.对两个链表进行合并。 4.通过位置转换进行链表排序。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值