关于链表操作编程实现的一些总结

链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。

使用链表结构可以克服数组需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。链表有很多种不同的类型，单项链表、双向链表和循环链表。下面总结链表操作的代码实现。

1.单向链表

typedef struct student
{
int data;
struct student *next;
} node;

// 创建链表
node *CreateList()
{
node *head,*rear,*temp;
head = (node *)malloc(sizeof(node));
rear = head;
int flag = 1, x;

while (flag)
{
cout<<"\nPlease input the data:";
cin>>x;

if (x != 0)
{
temp = (node *)malloc(sizeof(node));
temp->data = x;
rear->next = temp;
rear = temp;
}
else
flag = 0;

}

head = head->next;
rear->next = NULL;

return head;
}

// 获取链表长度
int GetListLength(node *head)
{
int count = 0;
node *temp = head;
while (temp != NULL)
{
count++;
temp = temp->next;
}

return count;
}

// 链表内容输出
void PrintList(node *head)
{
node *temp = head;
while (temp != NULL)
{
cout<<temp->data<<" ";
temp = temp->next;
}

cout<<endl;
}

// 删除节点
node *DeleteElement(node *head, int num)
{
node *p1, *p2;
p1 = head;
if (p1 != NULL)
{
while (num != p1->data && p1->next != NULL)
{
p2 = p1;
p1 = p1->next;
}

if (num == p1->data)
{
if (p1 == head)
head = p1->next;
else
p2->next = p1->next;
free(p1);
}
else
{
cout<<"Can not find the data: "<<num<<endl;
}
}
return head;
}

// 链表逆序输出(递归函数实现)
void ReversePrintList(node *head)
{
node *temp = head;
if (temp != NULL)
{
if (temp->next != NULL)
{
ReversePrintList(temp->next);
}
cout<<temp->data<<endl;
}
}

// 链表逆置
node *ReserveList(node *head)
{
if (head == NULL || head->next == NULL)
return head;

node *t, *p1, *p2, *p;
p1 = (node *)malloc(sizeof(node));
p1->data = head->data;
p1->next = NULL;
p = p1;
t = head->next;

while (t != NULL)
{
p2 = (node *)malloc(sizeof(node));
p2->data = t->data;
p2->next = p;
p = p2;
t = t->next;
}
return p2;

}

2.双向链表

typedef struct student
{
int data;
struct student *prev;
struct student *next;
} node;

// 创建链表
node *CreateList()
{
node *head,*rear,*temp;
head = (node *)malloc(sizeof(node));
rear = head;
int flag = 1, x;

while (flag)
{
cout<<"\nPlease input the data:";
cin>>x;

if (x != 0)
{
temp = (node *)malloc(sizeof(node));
temp->data = x;
rear->next = temp;
temp->prev = rear;
rear = temp;
}
else
flag = 0;

}

head = head->next;
head->prev = NULL;
rear->next = NULL;

return head;
}

3.循环链表

typedef struct node_str
{
int data;
struct node_str *next;

}LNode, *LinkList;

// 创建循环链表(n为循环链表中元素总数)
LinkList CreateCircularList(int n)
{
LinkList head,rear,temp;
int id = 1;

head = (LinkList)malloc(sizeof(LNode));
head->data = id;
head->next = head;
rear = head;

while (--n)
{
temp = (LinkList)malloc(sizeof(LNode));
temp->data = ++id;
temp->next = rear->next;
rear->next = temp;
rear = temp;
}
return head;
}

// 输出循环链表k位置开始的m个元素(k从1开始计算)
void PrintCircularList(LinkList head, int k, int m)
{
if (head != NULL)
{
LinkList newHead = head;
k--;
while (k)
{
newHead = newHead->next;
k--;
}

for (int i=0; i<m; i++)
{
cout<<newHead->data<<endl;
newHead = newHead->next;
}
}
}

循环链表求解约瑟夫问题

// 约瑟夫环（约瑟夫问题）：
// 已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，
// 数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复
// 下去，直到圆桌上仅剩1人。

// 约瑟夫问题
void JOSEPHUS(int n, int m, int k)
{
// 创建循环队列
LinkList head = CreateCircularList(n);

// 将队列头移动到编号为k的位置
k--;
while (k)
{
head = head->next;
k--;
}

// 开始报数，删除节点
while (n > 1)
{
LinkList p = head, temp;
for (int i=1; i<m; i++)
{
p = head;
head = head->next;
}
temp = head;
p->next = temp->next;
head = temp->next;
free(temp);
n--;
}

// 输出最后留下人的编号
cout<<head->data<<endl;
}