数据结构单链表&循环链表实现

//前途比爱情重要，爱情比前途难得，但对的人会站在你的前途里
#include<iostream>
using namespace std;

typedef struct _LinkNode {

	int data; //结点的数据域

	struct _LinkNode* next;//结点的指针域

}LinkNode, Linklist;


bool InitList(Linklist*& L) {

	L = new LinkNode;

	if (!L) return false;//生成结点失败

	L->next = NULL;

	return true;
}


//前插法
bool ListInsert_front(Linklist*& L, LinkNode* node) {

	if (!L || !node) return false;

	node->next = L->next;
	L->next = node;
	return true;
}


//尾插法
bool ListInsert_back(Linklist*& L, LinkNode* node) {

	LinkNode* last = NULL;
	if (!L || !node) return false;
	last = L;
	while (last->next) {
		last = last->next;
	}
	node->next = NULL;
	last->next = node;
	return true;
}


//任意位置插入
bool ListInsert(Linklist*& L, int i, int e) {

	if (!L)return false;

	int j = 0;
	Linklist* p, * s;
	p = L;

	while (p && j < i - 1)//查找位置为i-1的结点，p指向该结点
	{
		p = p->next;
		j++;
	}

	if (!p || j > i - 1) {
		return false;
	}

	s = new LinkNode;//生成新结点
	s->data = e;
	s->next = p->next;
	p->next = s;
	return true;

}


//单链表按位置取值
bool Link_GetElem(Linklist*& L, int i, int& e) {

	//在带头节点的单链表L中查找第i个元素
	//用e记录L中第i个元素的值
	int index;
	Linklist* p;
	if (!L || !L->next) return false;

	p = L->next;
	index = 1;
	while (p && index < i) {//链表向后扫描，直到p指向第i个元素或者p为空
		p = p->next;
		index++;
	}
	if (!p || index > i) return false;//i值不合法，i>n或i<=0;

	e = p->data;
	return true;
}


//单链表按值查找
bool Linklist_FindElement(Linklist* L, int e, int& index) {

	//在带头结点的单链表L中查找值为e的元素位置
	Linklist* p;
	p = L->next;
	index = 1;

	if (!L || !L->next) {
		index = -1;
		return false;
	}

	while (p && p->data != e) {
		p = p->next;
		index++;
	}

	if (!p) {
		index = -1;
		return false;//查找结点不存在
	}

	return true;
}


//单链表的删除
bool LinklistDelete(Linklist* L, int i) {

	Linklist* p, * q;
	p = L;
	int index = 0;

	if (!L || !L->next) return false;

	while ((p->next) && (index < i - 1)) {
		index++;
		p = p->next;
	}

	if (!p->next || index > i - 1) return false;

	q = p->next;		//临时保存被删结点的地址以备释放空间
	p->next = q->next;	//改变删除结点前驱结点的指针域
	delete q;			//释放被删除结点的空间

	return true;
}


//单链表打印
void LinkPrint(Linklist*& L) {

	LinkNode* p = NULL;
	if (!L) { cout << "此链表为空" << endl; return; }

	p = L->next;

	while (p) {
		cout << p->data << " ";
		p = p->next;
	}
	cout << endl;
}


//销毁单链表
void LinklistDestroy(Linklist*& L) {

	Linklist* p = L;
	cout << "销毁链表" << endl;

	while (p) {
		L = L->next; //L指向下一个结点
		delete p;   //删除当前结点
		p = L;     //p移向下一个结点
	}

}



int main() {
	int n;
	Linklist* L = NULL;
	Linklist* s = NULL;


	//1.初始化一个空的链表
	InitList(L);


	//2.使用前插法插入数据
	cout << "前插法创建单链表" << endl;
	cout << "请输入插入的个数n:";
	cin >> n;

	while (n > 0) {
		s = new LinkNode;//生成新结点s
		cin >> s->data;
		ListInsert_front(L, s);
		n--;
	}


	//3.使用尾插法插入数据
	cout << "尾插法创建单链表" << endl;
	cout << "请输入插入的个数n:";
	cin >> n;

	while (n > 0) {
		s = new LinkNode;//生成新结点s
		cin >> s->data;
		ListInsert_back(L, s);
		n--;
	}


	//4.单链表的输出
	LinkPrint(L);


	//5.任意位置插入元素
	cout << "请问你要插入几个元素" << endl;
	int j; cin >> j;
	while (j--) {
		int i, x;
		cout << "请输入插入元素的位置及值：";
		cin >> i >> x;
		if (ListInsert(L, i, x)) {
			cout << "插入成功" << endl;
		}
		else {
			cout << "插入失败" << endl;
		}
		LinkPrint(L);
	}


	//6.单链表取值
	int element;
	cout << "请输入你要获取值的位置";
	cin >> n;
	if (Link_GetElem(L, n, element)) {
		cout << "第" << n << "元素的值为：" << element << endl;
	}
	else {
		cout << "第" << n << "个元素的值获取失败！" << endl;
	}


	//7.单链表按值查找
	int index = 0;
	cout << "输入你要查询值的位置：";
	cin >> n;
	if (Linklist_FindElement(L, n, index)) {
		cout << "你查询值为" << n << "的位置为" << index << endl;
	}
	else {
		cout << "你查询值为" << n << "的位置为" << index << endl;
	}


	//8.单链表的删除元素
	cout << "请输入你要删除第几个元素:";
	cin >> n;
	if (LinklistDelete(L, n)) {
		cout << "删除第" << n << "元素成功!" << endl;
		LinkPrint(L);
	}
	else {
		cout << "删除第" << n << "元素失败!" << endl;
	}


	//9.销毁单链表
	LinklistDestroy(L);


	system("pause");
	return 0;
}

循环链表

// SingleList.h 单循环链表类定义
#include <iostream>
using namespace std;
// 单循环链表节点
struct SingleListNode {
    int data;
    SingleListNode* next;
    SingleListNode(int val, SingleListNode* ptr = nullptr);
};

//单循环链表
class SingleList {
public:
    SingleListNode* dummy;
    SingleList();
    ~SingleList();
public:
    void add(int);
    void remove(int);
    SingleListNode* find(int);
};
// SingleList.cpp 单循环链表类的函数实现及静态成员定义


SingleListNode::SingleListNode(int val, SingleListNode* ptr)
    : data(val), next(ptr) { }

SingleList::SingleList()
    : dummy(new SingleListNode(-1)) { // 构造dummy时，需要把next指向本身
    dummy->next = dummy;
}

SingleList::~SingleList() {
    auto ptr = dummy->next;
    while (ptr != dummy) { // 析构条件变为ptr != dummy
        auto temp = ptr;
        ptr = ptr->next;
        delete temp;
        std::cout << "Element deleted!" << std::endl;
    }
    delete dummy;
    std::cout << "SingleList Destroyed!" << std::endl;
}

void SingleList::add(int val) {
    auto ptr = find(val);
    if (ptr) {
        std::cerr << val << " exists, add failed!" << std::endl;
        return;
    }
    else {
        auto temp = new SingleListNode(val);
        temp->next = dummy->next;
        dummy->next = temp;
    }
}

void SingleList::remove(int val) {
    auto ptr = find(val);
    if (ptr == nullptr) {
        std::cerr << val << " does not exist, remove failed!" << std::endl;
        return;
    }
    else {
        auto temp = ptr->next;
        ptr->next = ptr->next->next;
        delete temp;
    }
}

SingleListNode* SingleList::find(int val) {
    auto prev = dummy;
    auto temp = dummy->next;
    while (temp != dummy) { //循环条件变为temp不等于dummy
        if (temp->data == val)
            return prev;
        prev = prev->next;
        temp = temp->next;
    }
    return nullptr;
}
// SingleListTest.cpp 对该单循环链表的测试代码


int main(void) {
    SingleList list;

    list.add(0);
    list.add(1);
    list.add(2);
    list.add(3);
    list.add(4);
    list.add(4);	// 添加已存在元素
    list.remove(0); // 末尾元素
    list.remove(2); // 中间元素
    list.remove(4); // 开头元素
    list.remove(4); // 删除不存在元素
    for (auto temp = list.dummy->next; temp != list.dummy; temp = temp->next) // 循环链表循环条件为temp != list.dummy
        std::cout << temp->data << " ";
    std::cout << std::endl;
    /*期望的输出
    4 exists, add failed!
    4 does not exist, remove failed!
    3 1
    Element deleted!
    Element deleted!
    SingleList Destroyed!
    */
    return 0;
}