【数据结构】用C++实现单循环链表的各种操作(包括头删,尾删,插入,逆序,摧毁,清空等等)

//头文件

#ifndef _LIST_H
#define _LIST_H

#include<iostream>
using namespace std;

template<class Type>
class CList;

template<class Type>
class ListNode
{
	friend class CList<Type>;
public:
	ListNode() :data(Type()), next(NULL)
	{
	}
	ListNode(Type d, ListNode<Type> *n = NULL)
		:data(d), next(n)
	{}
	~ListNode()
	{}

private:
	Type data;
	ListNode<Type> *next;
};

template<class Type>
class CList
{
public:
	CList()
	{
		first = last = Buynode();
		last->next = first;
	}
	~CList()
	{
		destroy();
	}
public:

	void push_back(const Type &x)            //尾插``
	{
		ListNode<Type> *s = Buynode(x);
		last->next = s;
		last = s;
		last->next = first;
		first->data++;
	}

	void push_front(const Type &x)          //头插``
	{
		ListNode<Type> *s = Buynode(x);
		s->next = first->next;
		first->next = s;
		last = s;
		for (int i = 0; i < first->data; i++)
		{
			last = last->next;
		}
		first->data++;
	}

	void pop_back()                 //尾删``
	{
		if (first->data == 0)
			return;
		ListNode<Type> *s = first;
		for (int i = 1; i < first->data; i++)
		{
			s = s->next;
		}
		delete s->next;
		s->next = first;
		last = s;
		first->data--;
	}

	void pop_front()                //头删``
	{
		if (first->data == 0)
		{
			return;
		}
		if (first->data == 1)
		{
			pop_back();
		}
		else
		{
			ListNode<Type> *s = first->next;
			first->next = s->next;
			delete s;
			first->data--;
		}
	}

	void insert_val(const Type &x)          //按值插入``
	{
		ListNode <Type> *p = Buynode(x);
		ListNode <Type> *s = first;
		if (first->data == 0)
		{
			push_back(x);
			return;
		}
		while (s->next->data<x&&s->next->next != first)
		{
			s = s->next;
		}
		if (s->next->next == first)
		{
			if (s->next->data>x)
			{
				p->next = s->next;
				s->next = p;
				first->data++;
			}
			else
				push_back(x);
		}
		else
		{
			p->next = s->next;
			s->next = p;
			first->data++;
		}

	}

	void show_list()                //显示``
	{

		ListNode<Type> *q = first->next;
		while (q!=first)
		{
			cout << q->data << "->";
			q = q->next;
		}
		cout << "NULL  first->data=" << first->data <<"  first="<<first<< " last->next=" << last->next << endl;
	}

	void sort()                     //排序``
	{
		if (first->data == 0)
		{
			return;
		}
		ListNode<Type> *p = first->next;
		ListNode<Type> *q = p->next;
		p->next = first;
		last = p;
		first->data = 1;
		ListNode<Type> *r;
		while (q != first)
		{
			insert_val(q->data);
			r = q;
			q = q->next;
			delete r;
		}
	}

	ListNode<Type>* find(const Type &x)              //查找``
	{
		ListNode<Type> *s;
		for (s = first->next; s != first; s = s->next)
		{
			if (s->data == x)
			{
				return s;
			}
		}
		return NULL;
	}

	int length()                          //求长度``
	{
		return(first->data);
	}

	void delete_val(const Type &x)       //按值删除``
	{
		if (first->data == 0)
		{
			cout << "未找到该数:" << endl;
			return;
		}
		else
		{

			ListNode<Type> *p = find(x);
			if (p == NULL)
			{
				cout << "未找到该数:" << endl;
				return;
			}
			ListNode<Type> *q = first;
			while (q->next != p)
			{
				q = q->next;
			}
			if (q->next->next == first)
			{
				pop_back();
			}
			else
			{
				q->next = p->next;
				delete p;
				first->data--;
			}
		}
	}

	void clear()                       //清除``
	{
		if (first->data == 0)
			return;
		while (first->next != first)
		{
			pop_back();
		}
	}

	void resver()                       //逆序``
	{
		if (first->data == 0)
		{
			return;
		}
		ListNode<Type> *p = first->next;
		ListNode<Type> *q = p->next;
		p->next = first;
		last = p;
		first->data = 1;
		ListNode<Type> *r;
		while (q != first)
		{
			push_front(q->data);
			r = q;
			q = q->next;
			delete r;
		}
	}

	void quit_system(int &a)               //退出``
	{
		clear();
		a = 0;
	}

	void destroy()              //摧毁``
	{
		clear();
		delete first;
	}
protected:
	ListNode<Type>* Buynode(Type x = Type())
	{
		ListNode<Type> *p = new ListNode<Type>(x);
		return p;
	}
private:
	ListNode<Type> *first;
	ListNode<Type> *last;
};

#endif

//主函数
#include"CList.h"

void main()
{
	CList<int> mylist;
	int select = 1;
	int Item;
	//int pos;
	while (select)
	{
		cout << "**************************************" << endl;
		cout << "* [1] show_list       [2] push_front *" << endl;
		cout << "* [3] push_back       [4] pop_front  *" << endl;
		cout << "* [5] pop_back        [6] insert_val *" << endl;
		cout << "* [7] find            [8] delete_val *" << endl;
		cout << "* [9]length           [10] clear     *" << endl;
		cout << "* [11] quit_system    [12] destroy   *" << endl;
		cout << "* [13] resver         [14] sort      *" << endl;
		cout << "**************************************" << endl;
		cout << "请选择:>";
		cin >> select;
		switch (select)
		{
		case 1:
			mylist.show_list();
			break;
		case 2:
			cout << "请输入要插入的值(-1结束):>";
			while (cin >> Item, Item != -1)
			{
				mylist.push_front(Item);
			}
			break;
		case 3:
			cout << "请输入要插入的值(-1结束):>";
			while (cin >> Item, Item != -1)
			{
				mylist.push_back(Item);
			}
			break;
		case 4:
			mylist.pop_front();
			;
			break;
		case 5:
			mylist.pop_back();
			break;
		case 6:
			cout << "请输入要插入的值:>";
			cin >> Item;
			mylist.insert_val(Item);
			break;
		case 7:
			cout << "请输入要查找的数:";
			cin >> Item;
			cout << "该数的地址为:";
			cout << mylist.find(Item) << endl;
			break;
		case 8:
			cout << "请输入要删除的值:>";
			cin >> Item;
			mylist.delete_val(Item);
			break;

		case 9:
			cout << "该顺序表长度为:" << mylist.length() << endl;
			break;
		case 10:
			mylist.clear();
			break;
		case 11:
			mylist.quit_system(select);
			break;
		case 12:
			mylist.destroy();
		case 13:
			mylist.resver();
			break;
		case 14:
			mylist.sort();
			break;
		default:
			break;
		}
	}
	return;
}
<img src="http://img.blog.csdn.net/20150522192337983?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZG91ZG91d2ExMjM0/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center" alt="" />
<img src="http://img.blog.csdn.net/20150522192343396?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZG91ZG91d2ExMjM0/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center" alt="" />
时间: 2024-12-28 20:56:06

【数据结构】用C++实现单循环链表的各种操作(包括头删,尾删,插入,逆序,摧毁,清空等等)的相关文章

【数据结构】两个单循环链表的连接操作

如果在单链表或头指针表示的链表上操作这个比较消耗性能,因为都需要遍历第一个链表,找到an,然后将b1链接到an的后面,时间复杂度是:O(n).若在尾指针表示的单循环链表上实现,则只需改变指针,无需遍历,时间复杂度是:O(1) 现在看算法实现,需要4个主要步骤,都注释了: LinkList Connect(LinkList A,LinkList B){ //假设A,B为非空循环链表的尾指针 LinkList p = A->next;//1.保存A链表的头结点的位置 A->next = B->

【c++版数据结构】之循环单链表的实现(带头结点以及尾节点)

所实现的循环单链表的结构如下图所示: 循环单链表的实现,和上一篇文章单链表的实现大致相同点击打开链接,略有区别: 1:循环判断的条件不再是s == NULL或者s->next == NULL,而是他们是否等于头指针.2: 断开链表时的处理,尾节点的next不是NULL,而是指向头结点 具体细节参考上一篇文章 头文件:SCList.h #ifndef SCLIST_H #define SCLIST_H #include<iostream> #include<cassert> u

数据结构与算法——线性表链式存储(单循环链表)

今天总结循环单链表 什么是单循环链表? 单链表终端结点的指针域是指向空的,如果将其指向头结点,这样就形成了一个环,那么这种首尾相接的环就够成了单循环链表. 单链表中我们都是用头指针来表示的,但是在单循环链表里,用尾指针(指向最后一个节点).为什么要这样,因为如果用头指针,那么当查找最后一个元素的时候,就要循环遍历,时间复杂度为O(n),如果用尾指针,时间复杂度为O(1),而因为是循环的,所以头指针很容易表示出来即rear->next,时间复杂度也是O(1) 单循环链表中需要注意两点: 头指针使用

【数据结构】用C++实现双循环链表的各种操作(包括头删,尾删,插入,逆序,摧毁,清空等等)

//[数据结构]用C++实现单循环链表的各种操作(包括头删,尾删,插入,逆序,摧毁,清空等等) //头文件 #ifndef _CDLIST_H #define _CDLIST_H #include<iostream> using namespace std; template<class Type> class CDList; template<class Type> class ListNode { friend class CDList<Type>; p

栈和队列----将单链表的每K个节点之间逆序

将单链表的每K个节点之间逆序 给定一个单链表的头节点head,实现一个调整链表的函数,使得每K 个节点之间逆序,如果最后剩下不够K 个节点,则不调整最后几个. 例如: 链表:1->2->3->4->5->6->7->8->null,k=3. 调整好后:3->2->1->6->5->4->7->8->null,其中7.8不调整,因为不够一组. [解析] 1. 首先从左到右遍历链表,如果栈的大小不等于k ,则不断的

java版的单向链表的逆序输出

将单向链表逆序输出,方法有三种: a.遍历链表,将每个节点的内容存入一个数组中,然后逆序输出数组(最简单的做法) b.使用栈来逆序输出 c.直接将链表逆序然后输出(本文采用的方法) 先介绍算法: 1). 若链表为空或只有一个元素,则直接返回: 2). 设置两个前后相邻的指针p,q. 将p所指向的节点作为q指向节点的后继: 3). 重复2),直到q为空 4). 调整链表头和链表尾 示例:以逆序A->B->C->D为例,图示如下 package com.moluo.shujujiegou;

链表逆序2

问题来源:选自LeetCode 92:反转链表 II 问题描述: 反转从位置 m 到 n 的链表.请使用一趟扫描完成反转. 说明: 1 ≤ m ≤ n ≤ 链表长度. 示例: 输入: 1->2->3->4->5->NULL, m = 2, n = 4 输出: 1->4->3->2->5->NULL 题目给定信息: 问题分析: 这道题也是要求实现链表的逆序,但是不同的地方在于要求在链表中规定的某一部分实现链表的逆序.那么我们可以把这个链表分为三部分

数据结构学习--单循环链表(python)

概念 将单链表的终端节点的指针由原来的空指针改为指向头节点, 就是整个单链表形成一个环, 这种首尾相接的单链表称为单循环链表. 实现 class Node: """ 节点 """ def __init__(self, value): self.data = value self.next = None class CircularLinkedList: def __init__(self): self.rear = None # 尾节点 def

数据结构上机测试2-1:单链表操作A (顺序建表+关键字删除)

数据结构上机测试2-1:单链表操作A Time Limit: 1000MS Memory limit: 4096K 题目描述 输入n个整数,先按照数据输入的顺序建立一个带头结点的单链表,再输入一个数据m,将单链表中的值为m的结点全部删除.分别输出建立的初始单链表和完成删除后的单链表. 输入 第一行输入数据个数n: 第二行依次输入n个整数: 第三行输入欲删除数据m. 输出 第一行输出原始单链表的长度: 第二行依次输出原始单链表的数据: 第三行输出完成删除后的单链表长度: 第四行依次输出完成删除后的