【数据结构】线性表的操作算法2

---

实验内容

（1）建立具有10个整型元素（1,3,2,9,0,4,7,6,5,8）的单链表，具体要求如下：
①采用尾插法建立单链表（推荐）
②头插法建立单链表
③删除最大值节点，并输出。

（2）解决约瑟夫问题，具体要求： ①建立循环单链表 ②按照规则删除节点，并输出。

（3）对单链表中的元素进行排序。具体如下：

---

实验代码

#include <stdio.h>
#include <malloc.h>
typedef int ElemType;
typedef struct LNode  		//定义单链表结点类型
{
    ElemType data;
    struct LNode *next;		//指向后继结点
} LinkList;

void CreateListF(LinkList *&L,ElemType a[],int n)
//头插法建立单链表
{
    LinkList *s;
    int i;
    L=(LinkList *)malloc(sizeof(LinkList));  	//创建头结点
    L->next=NULL;
    for (i=0; i<n; i++)
    {
        s=(LinkList *)malloc(sizeof(LinkList));//创建新结点
        s->data=a[i];
        s->next=L->next;			//将*s插在原开始结点之前,头结点之后
        L->next=s;
    }
}
//尾插法
void CreateListR(LinkList *&L,ElemType a[],int n)
{
    LinkList *s,*r;
    int i;
    L=(LinkList *)malloc(sizeof(LinkList));
    r=L;
    for(i=0; i<n; i++)
    {
        s=(LinkList *)malloc(sizeof(LinkList));
        s->data=a[i];
        r->next=s;
        r=s;
    }
    r->next=NULL;
}

//初始化
void InitList(LinkList *&L)
{
    L=(LinkList *)malloc(sizeof(LinkList));
    L->next =NULL;
}

//销毁
void DestoryList(LinkList *&L)
{
    LinkList *pre =L,*p=L->next;
    while(p!=NULL)
    {
        free(pre);
        pre=p;
        p=pre->next;
    }
    free(pre);
}

//求线性表的长度
int ListLength(LinkList *L)
{
    int n=0;
    LinkList *p=L;
    while(p->next!=NULL)
    {
        n++;
        p=p->next;
    }
    return(n);
}

//输出线性表
void DispList(LinkList *L)
{
    LinkList *p = L->next;
    while(p!=NULL)
    {
        printf("%d ",p->data);
        p=p->next;
    }
    printf("\n");
}

//求线性表中某元素值
bool GetItem(LinkList *L,int i,ElemType &e)
{
    int j= 0;
    LinkList *p=L;
    if(i<=0) return false;
    while(j<i&&p!=NULL)
    {
        j++;
        p=p->next;
    }
    if(p==NULL)
        return false;
    else
    {
        e=p->data;
        return true;
    }
}
//按元素值查找
int LocateElem(LinkList *L,ElemType e)
{
    int i=1;
    LinkList *p=L->next;
    while(p!=NULL&&p->data!=e)
    {
        p=p->next;
        i++;
    }
    if(p==NULL)
        return(0);
    else
        return(i);
}

//插入数据元素
bool ListInsert(LinkList *&L,int i,ElemType e)
{
    int j=0;
    LinkList *p=L,*s;
    if(i<=0)return false;
    while
    (j<i-1&&p!=NULL)
    {
        j++;
        p=p->next;
    }
    if(p==NULL)
        return false;
    else
    {
        s=(LinkList *)malloc(sizeof(LinkList));
        s->data=e;
        s->next=p->next;
        p->next=s;
        return true;
    }
}

//删除数据元素
bool ListDelete(LinkList *&L,int i,ElemType &e)
{
    int j=0;
    LinkList *p=L,*q;
    if(i<=0)return false;
    while
    (j<i-1&&p!=NULL)
    {
        j++;
        p=p->next;
    }
    if(p==NULL)
        return false;
    else
    {
        q=p->next;
        if(q==NULL)
            return false;
        e=q->data;
        p->next=q->next;
        free(q);
        return true;
    }
}
void Delmaxnode(LinkList *&L)    // 删除最大元素
{
    LinkList *p=L->next,*pre=L,*maxp=p,*maxpre=pre;  //用p扫描整个单链表，pre是始终指向前驱节点
    while(p!=NULL)
    {
        if(maxp->data<p->data)    // 若找到一个更大的节点
        {
            maxp=p;      //  更新maxp
            maxpre=pre;  //  更新pre
        }
        pre=p;       // p,pre同步后移一个节点
        p=p->next;
    }
    maxpre->next=maxp->next;   //   删除maxp节点
    free(maxp);         //   释放maxp节点
}

void  sort(linklist L)
{
    linklist p,q,r,pre;
    p=L->next;//p指向第一个节点
    q=p->next;//q要指向p的后继节点，保证在后面断开之后能够找到后续的单链表中元素的位置
    p->next=NULL;//断开单链表，将单链表分成前部分为有序单链表，后部分为无需单链表
    p=q;//p往后开始找到无序单链表的第一个值
    while(p!=NULL)
    {
        q=p->next;//q还是指向p的后继，保证不丢失
        r=L;//r的作用是遍历有序单链表找到让值插入的位置
        while(r->next!=NULL&&r->next->data<p->data)//因为r所遍历的是有序的，所以只要找到了一个位置，令r的后继节点的值大于p->info，就把p插在r和r->next中间
        {
            r=r->next;//遍历
        }
        pre=r;//借助pre进行插入操作
        p->next=pre->next;//插入操作
        pre->next=p;
        p=q;//因为已经将无序单链表的第一个值插入到有序单链表中，所以p往后移一位，这里也可以写成p=p->next

    }

}

#include <malloc.h>
#include <iostream>
#include <cstdlib>
#include <stdio.h>
typedef int ElemType;
struct LinkedList {
	int data;
	LinkedList *next;
};
LinkedList *rear;

void insert(LinkedList *&L, int value) {
	if (!L) {
		L = (LinkedList *)malloc(sizeof(LinkedList));
		if (!L) {
			printf("wrong");
		}
		L->data = value;
		L->next = L;
		rear = L;
	} else {
		LinkedList *newNode = (LinkedList *)malloc(sizeof(LinkedList));
		newNode->data = value;
		newNode->next = rear->next;
		rear->next = newNode;
		rear = newNode;
	}
}

void josephus_myself(LinkedList *L, int m) {
	LinkedList *cur = L;
	LinkedList *pre = rear;
	int count = 1;

	while (cur != cur->next){
		if (count == m) {
			printf("%d->", cur->data);
			LinkedList *temp = cur;
			cur = cur->next;
			pre->next = cur;
			count = 1;
			free(temp);
		} else if (count < m) {
			cur = cur->next;
			pre = pre->next;
			count++;
		}
	}
	printf("%d\n", cur->data);
	free(cur);
}

#include<bits/stdc++.h>
#include "linklist.h"
using namespace std;

int main()
{
    LinkList *L;
    InitList(L);
    int num[10]={1,3,2,9,0,4,7,6,5,8};
	CreateListR(L,num,10);
	puts("建立的线性表元素如下：");
	DispList(L);
	printf("建立的线性表的长度为:%d\n",ListLength(L));
    printf("L:");
    DispList(L);
    Delmaxnode(L);
	printf("删除最大节点\n");
	printf("L:");
	DispList(L);
}