初始化 按序号查找值 按值查找序号 插入 输出 删除 前插法创建 后插法创建
求链表长度 数组冒泡排序 单链表冒泡排序 两个无序表合并到第三个表
/*
初始化 按序号查找值 按值查找序号 插入 输出 删除 前插法创建 后插法创建
求链表长度 数组冒泡排序 单链表冒泡排序 两个无序表合并到第三个表
*/
#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;
}