DEV C++单链表的一些基本操作

初始化 按序号查找值 按值查找序号 插入 输出 删除 前插法创建 后插法创建
求链表长度 数组冒泡排序 单链表冒泡排序 两个无序表合并到第三个表

/*
初始化 按序号查找值 按值查找序号 插入 输出 删除 前插法创建 后插法创建
求链表长度 数组冒泡排序 单链表冒泡排序 两个无序表合并到第三个表
*/

#include <iostream>
#include <stdio.h>
using namespace std;
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;  //Status是函数返回值类型,其值是函数结果状态代码
typedef int ElemType;  //ElemType为可定义的数据类型,此设为int类型

typedef struct LNode {
	ElemType data;
	struct LNode *next;
} LNode, * LinkList;

/**
  * @brief  单链表的初始化
  * @param  LinkList类型
  * @retval 无
  */
Status LinkList_Init(LinkList &L) {
	L = new LNode;     //生成新节点作为头结点，用头指针L指向头结点
	L->next = NULL;
	return OK;
}

/**
  * @brief  按序号查找值
  * @param  LinkList类型，序号，返回值
  * @retval 无
  */
Status LinkList_GetElem(LinkList L, int i, ElemType &e) {
	int j;
	LNode *p;
	p = L->next ;
	j = 1; //计数器
	while (j < i && p) {
		p = p->next;
		++j;
	}
	if ( j > i)
		return ERROR;
	e = p->data  ;
	return OK;
}

/**
  * @brief  按值查找序号，当没有需要查找的值时，i=0
  * @param  LinkList类型，查找值，返回节点位置
  * @retval 该值对应的节点
  */
LNode *LinkList_LocateElem(LinkList L, ElemType e, int &i) {
	i = 1;
	LNode *p;
	p = L->next ;
	while (p && p->data != e) {
		++i;
		p = p->next ;
	}
	if (!p)
		i = 0;
	return p;
}

/**
  * @brief  单链表的插入，i之前
  * @param  LinkList类型，插入位置，插入值
  * @retval 无
  */
Status LinkList_Insert(LinkList &L, int i, ElemType &e) {
	int j;
	LNode *p, *s;
	p = L;
	j = 0;
	while (p && j < i - 1) {
		p = p->next ;
		++j;
	}
	if (!p || j > i - 1)
		return ERROR;
	s = new LNode;
	s->data = e;
	s->next = p->next ;
	p->next = s;
	return OK;
}

/**
  * @brief  单链表的输出
  * @param  LinkList类型
  * @retval 无
  */
void LinkList_Output(LinkList L) {
	LNode *p;
	p = L;
	while (p = p->next )
		cout << p->data ;
	cout << endl;
}

/**
  * @brief  单链表的删除
  * @param  LinkList类型，删除位置，返回删除值
  * @retval 无
  */
Status LinkList_Delete(LinkList &L, int i, ElemType &e) {
	LNode *p, *q;
	int j;
	p = L;
	j = 0;
	while (p->next  && j < i - 1) {
		p = p->next ;
		++j;
	}
	if (!(p->next ) || j > i - 1)
		return ERROR;
	q = p->next ;
	p->next = q->next ;
	e = q->data ;
	delete q;
	return OK;
}

/**
  * @brief  前插法创建单链表
  * @param  LinkList类型，创建的节点数
  * @retval 无
  */
void LinkList_Create_Pre(LinkList &L, int n) {
	LNode *p;
	L = new LNode;
	L->next = NULL;
	cout << "请输入" << n << "个数:\n";
	for (int i = n; i > 0; --i) {
		p = new LNode;
		cin >> p->data ;
		p->next = L->next ;
		L->next = p;
	}
}

/**
  * @brief  后插法创建单链表
  * @param  LinkList类型，创建的节点数
  * @retval 无
  */
void LinkList_Create_Rear(LinkList &L, int n) {
	LNode *r, *p;
	L = new LNode;
	L->next = NULL;
	r = L;
	cout << "请输入" << n << "个数:\n";
	for (int i = 0; i < n; i++) {
		p = new LNode;
		cin >> p->data ;
		p->next = NULL;
		r->next = p;
		r = p;
	}
}

/**
  * @brief  求链表长度
  * @param  LinkList类型
  * @retval int长度
  */
int LinkList_Length(LinkList L) {
	int n = 0;
	LNode *p;
	p = L;
	while (p->next ) {
		n++;
		p = p->next ;
	}
	return n;
}

/**
  * @brief  数组冒泡排序，升序
  * @param  数组类型，长度
  * @retval 无
  */
void Array_Maopao(ElemType array[], int n) {
	int i;  //比较的轮数
	int j;  //每轮比较的次数
	int buf;  //交换数据时用于存放中间数据
	for (i = 0; i < n - 1; ++i) { //比较n-1轮
		for (j = 0; j < n - 1 - i; ++j) { //每轮比较n-1-i次,
			if (array [j] > array [j + 1]) {
				buf = array [j];
				array [j] = array[j + 1];
				array [j + 1] = buf;
			}
		}
	}

}

/**
  * @brief  单链表冒泡排序，升序
  * @param  LinkList类型
  * @retval 无
  */
void LinkList_Maopao(LinkList &a) {
	int n, flag = 0;
	LNode *p;
	p = a ;
	n = LinkList_Length(a);
	ElemType array[n];
	while (p = p->next ) {//把链表的值放到数组里，排序后再重新赋值
		array[flag] = p->data ;
		flag++;
	}
	Array_Maopao(array, n);
	p = a ;
	flag = 0;
	while (p = p->next ) {
		p->data = array[flag];
		flag++;
	}
	free(array);
}

/**
  * @brief  把无序单链表A和B合并到C中，不去重，升序
  * @param  LinkList类型，LinkList类型，LinkList类型
  * @retval 无
  */
void LinkList_Union_Orderly(LinkList A, LinkList B, LinkList &C) {
	int n, flag = 0, flaga = 0, flagb = 0;
	int a_len, b_len;
	if (C->next ) {
		cout << "目标链表非空,原链表为:" ;
		LinkList_Output(C);
	}
	ElemType temp;//临时存放当前节点数据
	LNode *pa, *pb, *pc;
	pa = A ;
	pb = B;
	a_len = LinkList_Length(A);
	b_len = LinkList_Length(B);
	/***********************************************/
	ElemType array_a[a_len];//把值放到数组里，进行排序，而不影响原链表顺序
	ElemType array_b[b_len];
	while (pa = pa->next ) {
		array_a[flag] = pa->data ;
		++flag;
	}
	Array_Maopao(array_a, flag );
	flag = 0;
	while (pb = pb->next ) {
		array_b[flag] = pb->data ;
		++flag;
	}
	Array_Maopao(array_b, flag );
	/***********************************************/
	flag = LinkList_Length(C) + 1; //以下作链表C的插入位置
	while (flaga < a_len && flagb < b_len) {
		if (array_a[flaga] < array_b[flagb]) {
			temp = array_a[flaga++];
			LinkList_Insert(C, flag++, temp);
		} else {
			temp = array_b[flagb++];
			LinkList_Insert(C, flag++, temp);
		}
	}
	while (flaga < a_len) {
		temp = array_a[flaga++];
		LinkList_Insert(C, flag++, temp);
	}
	while (flagb < b_len) {
		temp = array_b[flagb++];
		LinkList_Insert(C, flag++, temp);
	}
	free(array_a);
	free(array_b);
}

+ 逆置

/**
  * @brief  单链表的逆置
  * @param  LinkList类型
  * @retval 无
  */
Status LinkList_Reverse(LinkList &L) {
	LNode *p;
	p = L;
	if (!(p = p->next )) {
		cout << "该链表为空" << endl;
		return ERROR;
	}
	int i = 0;
	ElemType array[LinkList_Length(L)];
	while (p) {
		array[i] = p->data ;
		++i;
		p = p->next ;
	}
	p = L;
	--i;
	while (p = p->next ) {
		p->data = array[i];
		--i;
	}
	cout << "逆置后的链表为:";
	LinkList_Output(L);
	free(array);
	return OK;
}