【数据结构】用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>;
public:
	ListNode() :data(Type()), next(NULL), prio(NULL)
	{}
	ListNode(Type d, ListNode<Type> *n = NULL, ListNode<Type> *m = NULL)
		:data(d), next(n), prio(m)
	{}
	~ListNode()
	{}

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

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

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

	void push_front(const Type &x)          //头插``
	{
		if (first->data == 0)
		{
			push_back(x);
			return;
		}
		ListNode<Type> *s = Buynode(x);
		s->next = first->next;
		first->next->prio = s;
		first->next = s;
		s->prio = first;
		first->data++;
	}

	void pop_back()                 //尾删``
	{
		if (first->data == 0)
			return;
		ListNode<Type> *p = last;
		last = last->prio;
		last->next = first;
		first->prio = last;
		delete p;
		first->data--;

	}

	void pop_front()                //头删``
	{
		if (first->data == 0)
		{
			return;
		}
		else
		{
			ListNode<Type> *s = first->next;
			if (first->data == 1)
			{
				last = first;
				last->next = first;
				first->prio = last;
			}
			else
			{
				first->next = s->next;
				s->next->prio = first;
			}
			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->prio = p;
				s->next = p;
				p->prio = s;
				first->data++;
			}
			else
				push_back(x);
		}
		else
		{
			p->next = s->next;
			s->next->prio = p;
			s->next = p;
			p->prio = s;
			first->data++;
		}

	}

	void show_list()                //显示``
	{
		if (first->data == 0)
		{
			cout << "NULL" << endl;
			return;
		}
		ListNode<Type> *q = first->next;
		while (q != first)
		{
			cout << q->data << "->";
			q = q->next;
		}
		cout << "NULL  first->data=" << first->data << " last->next->data=" << last->next->data << " last->data=" << last->data << " first->prio->data=" << first->prio->data << " " << endl;
	}

	void sort()                     //排序``
	{
		if (first->data == 0)
		{
			return;
		}
		ListNode<Type> *p = first->next;
		ListNode<Type> *q = p->next;
		p->next = first;
		first->prio = p;
		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;
				p->next->prio = q;
				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;
		first->prio = p;
		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"CDList.h"

void main()
{
	CDList<int> mylist;
	int select = 1;
	int Item;
	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/20150531224751379?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZG91ZG91d2ExMjM0/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center" alt="" />

时间: 2024-11-02 23:40:01

【数据结构】用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

栈和队列----将单链表的每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 题目给定信息: 问题分析: 这道题也是要求实现链表的逆序,但是不同的地方在于要求在链表中规定的某一部分实现链表的逆序.那么我们可以把这个链表分为三部分

【数据结构】双循环链表(c++)

头文件: #pragma once #include <iostream> #include <assert.h> using namespace std; template<class Type> class List; // 结点类 template<class Type> class NodeList { friend class List<Type>; public: NodeList(); NodeList(Type d, NodeLi

循环链表之双循环链表

接着上一篇博文http://12172969.blog.51cto.com/12162969/1918256,把循环链表里的双循环链表的基本操纵按照我个人的理解进行总结一下. 依然沿袭过去的风格,进入双循环链表之前,先提另一种结构,双向链表,先有了双向链表再有了双循环链表.这两种结构和单链表一样都有带头结点和不带头结点之分.我们先来看一下这几种结构的结构图: 双链表 双循环链表 既然单向链表有普通的链表也就是不循环的链表.那么双向链表也一样,也有普通的双向链表和双向循环链表:也有带头结点,不带头

西风的数据结构教程(1)——链表

今天,同学熊问了我一些基本数据结构的问题,我想这些基础的东西还是应该好好理解的.其实数据结构应该是计算机技术的基石,各种算法都是在数据管理的基础上运行的. 于是,我打算利用业余时间,将我学过的这部分内容整理出来,并且加上一些自己的创新性的内容,做成一份简明扼要的数据结构教程,然后尽可能的深入探讨一些关于这些内容的创新方法和优雅的实现. 回想当年,高中时期的计算机竞赛生涯,一遍遍的啃那些不懂的知识点,也正是因为如此,我虽不算出色,但也拥有了扎实的基本功,在此,我也要感谢我的恩师,我们唐山一中的郭莲

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

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