#pragma once
#ifndef _CLIST_H_
#define _CLIST_H_ #include <iostream>
#include <assert.h>
using namespace std; template<class Type> class List; typedef enum { FALSE, TRUE }Status; template<class Type>
class ListNode
{
friend class List<Type>;
public:
ListNode() :data(Type()), next(NULL)
{}
ListNode(Type d, ListNode<Type> *n = NULL)
: data(d), next(n)
{}
~ListNode()
{}
void setData(const Type &d)
{
data = d;
}
Type GetData()
{
return data;
}
private:
Type data;
ListNode<Type> *next;
}; template<class Type>
class List
{
public:
List()
{
ListNode<Type> *s = new ListNode<Type>(0);
assert(s != NULL);
last = first = s;
size = 0;
}
~List()
{}
public:
Status push_back(const Type &x)
{
ListNode<Type> *s = new ListNode<Type>(x);
last->next = s;
last = s;
size++;
return TRUE;
}
Status push_front(const Type &x)
{
ListNode<Type> *s = new ListNode<Type>(x);
s->next = first->next;
first->next = s;
if (size == 0)
{
last = s;
}
size++;
return TRUE;
}
Status pop_back()
{
if (size == 0)
{
return FALSE;
}
ListNode<Type> *p = first;
while (p->next != last)
{
p = p->next;
}
delete last;
last = p;
last->next = NULL;
size--;
return TRUE;
}
Status pop_front()
{
if (size == 0)
{
return FALSE;
}
ListNode<Type> *p = first->next;
first->next = p->next;
delete p;
if (size == 1)
{
last = first;
}
size--;
return TRUE;
}
void show_List()
{
ListNode<Type> *p = first->next;
while (p != NULL)
{
cout << p->data << "->";
p = p->next;
}
cout << "NULL" << endl;
}
Status insert_val(const Type &x)
{
ListNode<Type> *p = first;
while (p->next != NULL && p->next->data < x)
{
p = p->next;
}
if (p->next == NULL)
{
push_back(x);
}
else
{
ListNode<Type> *s = new ListNode<Type>(x);
s->next = p->next;
p->next = s;
size++;
}
/*
ListNode<Type> *s = new ListNode<Type>(x);
ListNode<Type> *q = p->next;
if(last->data > x)
{
while(q->data < x )
{
p = p->next;
q = q->next;
}
p->next = s;
s->next = q;
size++;
}
else
{
push_back();
}*/ return TRUE;
}
ListNode<Type>* find(const Type &key) const
{
if (size == 0)
{
return NULL;
}
ListNode<Type> *p = first->next;
while(p != NULL && p->data != key)
{
p = p->next;
}
return p;
// while (p != NULL)
// {
// if (p->data == key)
// {
// return p;
// }
// p = p->next;
// }
// return NULL;
}
Status delete_val(const Type &x)
{
if (size == 0)
{
return FALSE;
}
ListNode<Type> *p = find(x);
if (p == NULL)
{
return FALSE;
}
if (p == last)
{
pop_back();
}
else
{
ListNode<Type> *q = p->next;
p->data = q->data;
p->next = q->next;
delete q;
size--;
return TRUE;
}
return FALSE;
/* ListNode<Type> *p = first;
ListNode<Type> *q = p->next;
if(last->data == x)
{
pop_back();
}
while(q->data != x)
{
p = p->next;
q = q->next;
}
p->next = q->next;
return TRUE;*/
}
Status modify_val(const Type &x, const Type &y)
{
ListNode<Type> *p = find(x);
if (p == NULL)
{
return FALSE;
}
p->data = y;
return TRUE;
}
int length()
{
return size;
}
void clear()
{
ListNode<Type> *p = first->next;
while (p != NULL)
{
first->next = p->next;
delete p;
p = first->next;
}
last = first;
size = 0;
}
void destroy()
{
clear();
delete first;
first = last = NULL;
}
void sort()
{
if (size==0 || size==1)
{
return;
}
ListNode<Type> *p = first->next;
ListNode<Type> *q = p->next;
last = p;
last->next = NULL;
while (q != NULL)
{
p = q;
q = q->next; ListNode<Type> *s = first;
while (p->data > s->next->data && s->next != NULL)
{
s = s->next;
}
if (s->next == NULL)
{
p->next = NULL;
last->next = p;
last = p;
}
else
{
p->next = s->next;
s->next = p;
}
}
} void resver()
{
if (size==0 || size==1)
{
return;
}
ListNode<Type> *p = first->next;
ListNode<Type> *q = p->next;
last = p;
last->next = NULL;
while (q != NULL)
{
p = q;
q = q->next;
p->next = first->next;
first->next = p;
}
}
Status merge(List<Type> <1, List<Type> <2)
{
ListNode<Type> *p = lt1.first->next;
ListNode<Type> *q = lt2.first->next;
ListNode<Type> *s = first;
while (p != NULL && q != NULL)
{
if (p->data < q->data)
{
s->next = p;
p = p->next;
s = s->next;
}
else
{
s->next = q;
q = q->next;
s = s->next;
}
}
while (p != NULL)
{
s->next = p;
p = p->next;
s = s->next;
}
while (q != NULL)
{
s->next = q;
q = q->next;
s = s->next;
}
size = lt1.size + lt2.size;
return TRUE;
}
ListNode<Type> *prio(ListNode<Type> *p) const
{
if (p == NULL || p == first->next)
{
return NULL;
}
ListNode<Type> *pr = first;
while (pr->next != p)
{
pr = pr->next;
}
return pr;
}
ListNode<Type> *next(ListNode<Type> *p) const
{
if (p == NULL || p->next == NULL)
{
return NULL;
}
ListNode<Type> *q = first;
while (q->next != p)
{
q = q->next;
}
return q;
}
ListNode<Type> *Next(const Type &x) const
{
if (size==0 || size==1)
{
return NULL;
}
ListNode<Type> *q = find(x);
if (q == NULL)
{
return NULL;
}
return q->next;
}
ListNode<Type> *Prio(const Type &x) const
{
if(size==0 || size==1)
{
return NULL;
}
ListNode<Type> *p = first;
ListNode<Type> *q = p->next;
while (q != NULL)
{
if (q->data == x)
{
return p;
}
p = p->next;
q = q->next;
}
return NULL;
}
private:
ListNode<Type> *first;
ListNode<Type> *last;
size_t size;
}; #endif

#include "CList.h"

void main()
{
List<int> mylist;
List<int> youlist;
List<int> mergelist; int select = 1;
int pos;
int item;
system("Color 0d");
while (select)
{
cout << "************************************" << endl;
cout << "* [0] quit_system [1] push_back *" << endl;
cout << "* [2] push_front [3] show_list *" << endl;
cout << "* [4] pop_back [5] pop_front *" << endl;
cout << "* [6] insert_val [7] delete_val *" << endl;
cout << "* [8] merge [9] next *" << endl;
cout << "* [10] find [11] sort *" << endl;
cout << "* [12] resver [13] length *" << endl;
cout << "* [14] clear [15] destroy *" << endl;
cout << "* [16] modify_val [17] prio *" << endl;
cout << "************************************" << endl;
cout << "请选择:>";
cin >> select;
switch (select)
{
case 1:
cout << "请输入要插入的数据(-1结束):>";
while (cin >> item, item != -1)
{
mylist.push_back(item);
}
break;
case 2:
cout << "请输入要插入的数据(-1结束):>";
while (cin >> item, item != -1)
{
mylist.push_front(item);
}
break;
case 3:
system("cls");
mylist.show_List();
system("pause");
break;
case 4:
mylist.pop_back();
break;
case 5:
mylist.pop_front();
break;
case 6:
cout << "请输入要插入的值:>";
cin >> item;
mylist.insert_val(item);
break;
case 7:
cout << "请输入要删除的值:>";
cin >> item;
mylist.delete_val(item);
break;
case 8:
for (int i = 1; i < 10; i+=2)
{
mylist.push_back(i);
}
for (int i = 2; i < 10; i += 2)
{
youlist.push_back(i);
}
mergelist.merge(mylist, youlist);
mergelist.show_List();
break;
case 9:
cout << "请输入要查找的值:>";
cin >> item;
cout << "所在查找值的后继为:" << mylist.Next(item) << endl;
break;
case 10:
cout << "请输入要查找的值:>";
cin >> item;
cout << "该值指针为:" << mylist.find(item) << endl;
break;
case 11:
mylist.sort();
break;
case 12:
mylist.resver();
break;
case 13:
cout << "线性表的长度为:" << mylist.length() << endl;
break;
case 14:
mylist.clear();
break;
case 15:
mylist.destroy();
break;
case 16:
cout << "请输入要改动的值:>";
cin >> item;
cout << "请输入改动后的值:>";
cin >> pos;
mylist.modify_val(item, pos);
break;
case 17:
cout << "请输入要查找的值:>";
cin >> item;
cout << "所在查找值的前驱为:" << mylist.Prio(item) << endl;
break;
default:
break;
}
}
}

执行界面例如以下:

watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center" alt="">

【C++/数据结构】单链表的基本操作的更多相关文章

  1. PHP单链表的基本操作

    链表的实现 数据结构第一个就是链表了,链表分为两种有直接的数组形式的顺序链,这里不讨论,什么array_push(),array_pop(),函数基本能满足日常的需求,但报告老板,我就是想装个X 上代 ...

  2. python实现数据结构单链表

    #python实现数据结构单链表 # -*- coding: utf-8 -*- class Node(object): """节点""" ...

  3. C语言数据结构-单链表的实现-初始化、销毁、长度、查找、前驱、后继、插入、删除、显示操作

    1.数据结构-单链表的实现-C语言 typedef struct LNode { int data; struct LNode* next; } LNode,*LinkList; //这两者等价.Li ...

  4. 数据结构——单链表java简易实现

    巩固数据结构 单链表java实现 单链表除了表尾 每个几点都有一个后继 结点有数据和后继指针组成  通过构建表头和表尾(尾部追加需要)两个特殊几点 实现单链表的一些操作,代码如下 package co ...

  5. 用Java实现单链表的基本操作

    笔试题中经常遇到单链表的考题,下面用java总结一下单链表的基本操作,包括添加删除节点,以及链表转置. package mars; //单链表添加,删除节点 public class ListNode ...

  6. C# 数据结构--单链表

    什么是单链表 这两天看到很多有关单链表的面试题,对单链表都不知道是啥的我.经过学习和整理来分享一下啥是单链表和单链表的一些基本使用方法.最后看些网上有关单链表的面试题代码实例. 啥是单链表? 单链表是 ...

  7. 数据结构-------单链表(C++)

    相关信息: /** * @subject 数据结构 实验2 * @author 信管1142班 201411671210 赖俊杰 * @project 单链表 * @time 2015年10月29日1 ...

  8. C# 数据结构 - 单链表 双链表 环形链表

    链表特点(单链表 双链表) 优点:插入和删除非常快.因为单链表只需要修改Next指向的节点,双链表只需要指向Next和Prev的节点就可以完成插入和删除操作. 缺点:当需要查找某一个节点的时候就需要一 ...

  9. 数据结构—单链表(类C语言描写叙述)

    单链表 1.链接存储方法 链接方式存储的线性表简称为链表(Linked List). 链表的详细存储表示为: ① 用一组随意的存储单元来存放线性表的结点(这组存储单元既能够是连续的.也能够是不连续的) ...

  10. python算法与数据结构-单链表(38)

    一.链表 链表是一种物理存储单元上非连续.非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的.链表由一系列结点(链表中每一个元素称为结点)组成,结点可以在运行时动态生成.每个结点包括 ...

随机推荐

  1. Android(java)学习笔记202:JNI之hello.c(c代码功能实现)指针语法解析

    1. 接下来我们细讲分析一下前面一讲中,c功能实现的代码: (1)hello.c : #include <jni.h> char* getHello() { //////// return ...

  2. java.math.BigDecimal类multiply的使用

    java.math.BigInteger.multiply(BigInteger val) 返回一个BigInteger,其值是 (this * val).声明 以下是java.math.BigInt ...

  3. Java软件开发不同薪资级别-技术要求

    15~20万 WEB应用服务器(Tomcat.Weblogic.Jetty.JBoss.WebSphere) NoSQL(Redis.MongoDB.HBase.Memcache) 消息中间件(Kaf ...

  4. Java SE、Java EE、Java ME 三者区别

    现在一个个来分析 1. Java SE(Java Platform,Standard Edition).Java SE 以前称为 J2SE.它允许开发和部署在桌面.服务器.嵌入式环境和实时环境中使用的 ...

  5. windows sdk 设置窗体透明

    #define WINVER 0x0501 #include <windows.h> /* Declare Windows procedure */ LRESULT CALLBACK Wi ...

  6. 20面向对象三特征 之继承 方法重写 super

    继承是:多个类有重复内容,把重复内容放到一个新类中,就可以通过extends关键词去让原来的类和新类产生继承关系,子类只能拿到父类一部分信息.通过extends关键词去指明类与类之间的关系,一个父类可 ...

  7. 2019年,Linux运维行业的趋势,跟不上学习就被淘汰

    运维行业经历了多年的发展,已经有了很大的变化,最开始的机房.网线.人肉,到现在一步步的自动化.智能化.容器化,运维人员的职业技能要求越来越高,稍不注意就可能被淘汰. 今天马小哥就来盘点一下2019年运 ...

  8. 【笔记】搭建OpenWrt编译环境

    参考书目<B智能路由开发指南> 目标:搭建一个OpenWrt编译环境,可以同时在家里和公司使用. [2018-09-13] 刚开始想用自己的电脑共享远程桌面,但不知道什么原因搞不定,所以干 ...

  9. 树莓派 - wiringPi

    wiringPi其实和BCM2835 library类似,也是通过memmap, IOmap来实现在用户空间直接操作底层寄存器 wiringPi http://wiringpi.com/ Wiring ...

  10. JavaScript:获取上传图片的base64

    文章来源:http://www.cnblogs.com/hello-tl/p/7661535.html 1.HTML代码 <!DOCTYPE html> <html lang=&qu ...