C和C++实现单链表

c语言实现单链表

#include <stdio.h>
#include <malloc.h>
#define ERROR 0
#define OK 1

typedef int Status;
// 数据元素类型
typedef int ElemType;
// 数据结点
typedef struct Node
{
	ElemType value;
	struct Node* next;
}Node, LinkList;

// 初始化链表
Status InitList(LinkList* s)
{
	s = (LinkList*)malloc(sizeof(Node));
	if (s != NULL) {
		s->next = NULL;
		return OK;
	}
	else {
		return ERROR;
	}
}

// 返回要处理元素的前一个结点
Node* position(LinkList* s, int i) {
	int k;
	Node* ret = (Node*)s;
	for (k = 0; k < i; k++) {
		ret = ret->next;
	}
	return ret;
}


// 向链表i位置处插入元素e
Status InsertList(LinkList* s, int i, ElemType e) {
	Node* node = (Node*)malloc(sizeof(Node));
	if (node != NULL) {
		node->value = e;
		if (i == 0) {
			s->value = e;
		}
		// 定位到待插入位置的前一个结点
		Node* current = position(s, i);

		node->next = current->next;
		current->next = node;

		return OK;
	}
	else {
		return ERROR;
	}
}

// 判断链表是否为空 

Status empty(LinkList* l) {
	return (l->next == NULL);
}

// 删除链表中为值为i的结点

Status DeleteList(LinkList* s, int i) {
	if (!empty(s)) {
		// 但删除结点的前一个结点
		Node* current = position(s, i);
		// 待删除的结点
		Node* toDel = current->next;

		current->next = toDel->next;

		free(toDel);
		toDel = NULL;

		return OK;
	}
	else {
		return ERROR;
	}
}

// 设置链表s中位置为i的元素值为e
Status setElem(LinkList* s, int i, ElemType e) {
	if (!empty(s)) {
		Node* current = position(s, i);
		current->next->value = e;
		return OK;
	}
	else {
		return ERROR;
	}
}

// 获取链表s中位置为i的元素
ElemType getElem(LinkList* s, int i) {
	if (!empty(s)) {
		Node* current = position(s, i);
		return current->next->value;
	}
	else {
		return -1;
	}
}

// 查找链表s中是否存在元素e如果存在则返回下标否则返回-1
int find(LinkList* s, ElemType e) {
	int ret = -1;
	int i = 0;
	LinkList* p = s->next;
	while (p->next != NULL) {
		if (p->value == e) {
			ret = i;
			break;
		}
		else {
			i++;
			p = p->next;
		}
	}
	return ret;
}

int main()
{
	LinkList l;
	int i;
	InitList(&l);

	for (i = 0; i < 10; i++)
		InsertList(&l, i, i);

	printf("元素0的下标为： %d\n", find(&l, 0));

	for (i = 0; i < 10; i++) {
		printf("链表中元素依次为： %d\n", getElem(&l, i));
	}

	printf("更改下标为9的元素值为100\n");
	setElem(&l, 9, 100);

	printf("元素100的下标为： %d\n", find(&l, 100));

	DeleteList(&l, 7);

	printf("\n");
	for (i = 0; i < 9; i++) {
		printf("删除元素7后链表中元素依次为： %d\n", getElem(&l, i));
	}

	return 0;
}

c++实现单链表

#include <iostream>
using namespace std;

// 结点数据结构
template <typename T>
struct Node
{
	T value;
	// 指向下一个结点的指针
	Node<T>* next;
	// 构造函数
	Node() {}
	Node(const T& val, Node<T>* theNext) : value(val),next(theNext) {}
};

template <typename T>
class LinkList
{
private:
	//首结点
	Node<T>* m_firstNode;
	// 链表中的元素个数
	int m_size;
public:
	// 构造函数初始化
	LinkList() {
		m_firstNode = NULL;
		m_size = 0;
	}
	
	// 向位置i处插入元素e
	bool insert(int i, const T& e) {
		// 首先判断位置合法性
		bool ret = (0 <= i && i <= m_size);
		if (ret) {
			// 在位置0处插入的话则直接插入
			if (i == 0)
				m_firstNode = new Node<T>(e, m_firstNode);
			else {
				// 其它位置的话则先找到前驱结点
				Node<T>* p = m_firstNode;
				for (int k = 1; k < i; k++)
					p = p->next;
				p->next = new Node<T>(e, p->next);
			}
			m_size++;
		}
		return ret;
	}

	// 删除位置i的元素
	bool remove(int i) {
		// 首先判断参数合法性
		bool ret = (0 <= i && i < m_size);
		if (ret) {
			Node<T>* toDel;
			if (0 == i) {
				toDel = m_firstNode;
				m_firstNode = m_firstNode->next;
			} else {
				// 找到前驱结点位置
				Node<T>* p = m_firstNode;
				for (int k = 1; k < i; k++)
					p = p->next;

				toDel = p->next;
				p->next = p->next->next;

			}
			delete toDel;
			m_size--;
		}
		return ret;
	}

	// 设置位置i处的元素值为e
	bool set(int i, const T& e) {
		bool ret = (0 <= i && i < m_size);
		if (ret) {
			Node<T>* p = m_firstNode;
			for (int k = 0; k < i; k++)
				p = p->next;

			p->value = e;
		}
		return ret;
	}

	// 获取位置i处的元素值
	bool get(int i, T& e) {
		bool ret = (0 <= i && i < m_size);
		if (ret) {
			Node<T>*p = m_firstNode;
			for (int k = 0; k < i; k++)
				p = p->next;
			e = p->value;
		}
		return ret;
	}

	T get(int i) {
		T ret = -1;
		if (get(i, ret)) {
			return ret;
		}
		return ret;
	}

	// 查找链表中是否有为e的元素有则返回下标，否则返回-1
	int find(const T& e) const {
		int ret = -1;
		int i = 0;
		Node<T>* p = m_firstNode;
		while (p) {
			if (e == p->value) {
				ret = i;
				break;
			} else {
				i++;
				p = p->next;
			}
		}
		return ret;
	}

	// 链表反转

	void resersal() {
		// 三指针法
		if (!empty()) {
			Node<T>* p = m_firstNode;
			Node<T>* p1 = m_firstNode->next;
			while (p1 != NULL) {
				Node<T>* p2 = p1->next;

				p1->next = p;
				p = p1;
				p1 = p2;
			}
			m_firstNode->next = NULL;
			m_firstNode = p;
		}
	}

	bool empty() {
		return m_size == 0;
	}

	int length() const {
		return m_size;
	}

};

int main()
{
	LinkList<int> l;
	for (int i = 0; i < 10; i++)
		l.insert(i, i);
	
	cout << "此时链表中的元素个数为:  " << l.length() << endl;

	for (int i = 0; i < l.length(); i++)
		cout << "链表中的元素依次为: " << l.get(i) << endl;

	cout << "在链表中查找元素6的下标为: " << l.find(6) << endl; 

	cout << "删除下标为6的元素"  << endl;
	
	l.remove(6);

	cout << "此时链表中的元素个数为:  " << l.length() << endl;

	cout << "修改下标为4的元素值为100"  << endl;
	l.set(4, 100);

	l.resersal();

	for (int i = 0; i < l.length(); i++)
		cout << "此时链表中的元素依次为: " << l.get(i) << endl;

	return 0;
}