头歌 单链表的基本操作

第1关 单链表的插入操作

#include 
#include 
#include 
using namespace std;

/* 定义ElemType为int类型 */
typedef int ElemType;
void input(ElemType &s);
void output(ElemType s);
int equals(ElemType a,ElemType b);
/* 单链表类型定义 */
typedef struct LNnode
{	
	ElemType data;
	struct LNnode *next;
}LNnode,*LinkList;

void InitList(LinkList &L);
int ListInsert(LinkList &L,int i,int e) ;
void ListTraverse(LinkList L,void(*vi)(ElemType));

int main()               //main() function 
{	
     LinkList A;
     ElemType e;
     InitList(A);
      int n,i;
     // cout<<"Please input the list number ";
     cin>>n;
     for(i=1;i<=n;i++)
        { 
		   cin>>e;
         ListInsert(A, i, e);
       }
	//cout<<"请输入插入的位置："<>i;
	//cout<<"请输入插入的值："<>s;
}
void output(ElemType s)
 {
cout<next = nullptr;
	/********** End **********/
}
int ListInsert(LinkList &L,int i,int e) 
{
	// 在带头结点的单链线性表L的第i个元素之前插入元素e  
	/********** Begin **********/ 
    if(!L) return 0;

    LinkList p = L;
    for(int j = 1;jnext;
    }
    if(!p) return 0;
    LinkList a = (LinkList ) malloc(sizeof(LNnode));
    if(!a) return 0;
    a->data = e;
    a->next = p->next;
    p->next = a;
    return 1;
	/********** End **********/
}

void ListTraverse(LinkList L,void(*vi)(ElemType))
{ 
	// 初始条件：单链表L已存在。
	//操作结果：依次对L的每个数据元素调用函数vi()
	/********** Begin **********/ 
    LinkList p = L;
    while(p->next != nullptr){
        vi(p->next->data);
        p=p->next;
    }   
	/********** End **********/
}

 第2关 单链表的删除操作

#include 
#include 
#include 
using namespace std;

/* 定义ElemType为int类型 */
typedef int ElemType;
void input(ElemType &s);
void output(ElemType s);
int equals(ElemType a,ElemType b);

/* 单链表类型定义 */
typedef struct LNnode
{	
	ElemType data;
	struct LNnode *next;
}LNnode,*LinkList;

void InitList(LinkList &L);
int ListInsert(LinkList &L,int i,int e) ;
int ListDelete(LinkList L,int i,ElemType &e);
void ListTraverse(LinkList L,void(*vi)(ElemType));

int main()               //main() function 
{	
	LinkList A;
	ElemType e;
	InitList(A);
	int n,i;
	// cout<<"Please input the list number ";
	cin>>n;
	for(i=1;i<=n;i++)
	{ 
		cin>>e;
		ListInsert(A, i, e);
	}
	//cout<<"请输入删除的位置："<>i;	
	if(  ListDelete(A,i,e) )
	{
		cout<<"删除成功，删除后单链表如下："<>s;
}
void output(ElemType s)
{
	cout<next=NULL; // 指针域为空
	
}

int ListInsert(LinkList &L,int i,ElemType e) 
{	// 在带头结点的单链线性表L的第i个元素之前插入元素e  
	LinkList p,s;
	p = L;   
	int j = 0;
	while (p && j < i-1) {  // 寻找第i-1个结点
		p = p->next;
		++j;
	} 
	if (!p || j > i-1) 
		return 0;                   // i小于1或者大于表长
	s = (LinkList)malloc(sizeof(LNnode));  // 生成新结点
	s->data = e;  s->next = p->next;      // 插入L中
	p->next = s;
	return 1;
}

void ListTraverse(LinkList L,void(*vi)(ElemType))
{ 	// 调用函数vi()依次输出单链表L的每个数据元素
	LinkList p=L->next;
	while(p)
	{
		vi(p->data);
		p=p->next;
	}
	printf("\n");	
}

int  ListDelete(LinkList L,int i,ElemType &e) // 算法2.10。不改变L
{ 
	// 在带头结点的单链线性表L中，删除第i个元素，并由e返回其值
	/********** Begin **********/ 
    if(!L->next) return 0;

    LinkList up = L ;
    LinkList p = up->next;
    if(i==1){
        e  = L->next->data;
        LinkList t = L->next;
        L->next = L->next->next;
        free(t);
        return e;
    }
    for(int j = 1;jnext;
        up = up->next;
    }
    if(!p) return 0 ;
    LinkList t = p;
    up->next = p->next;
    e = t->data;
    free(t);
    return e;
	/********** End **********/
}

 第3关 单链表的按照序号查找值操作

#include 
#include 
#include 
using namespace std;

/* 定义ElemType为int类型 */
typedef int ElemType;
void input(ElemType &s);
void output(ElemType s);
int equals(ElemType a,ElemType b);

/* 单链表类型定义 */
typedef struct LNnode
{	
	ElemType data;
	struct LNnode *next;
}LNnode,*LinkList;

void InitList(LinkList &L);
int ListInsert(LinkList &L,int i,int e) ;
void ListTraverse(LinkList L,void(*vi)(ElemType));
int GetElem(LinkList L,int i,ElemType &e) ;

int main()               //main() function 
{	
	LinkList A;
	ElemType e;
	InitList(A);
	int n,i;
	// cout<<"Please input the list number ";
	cin>>n;
	for(i=1;i<=n;i++)
	{ 
		cin>>e;
		ListInsert(A, i, e);
	}
	//cout<<"请输入查找的序号："<>i;	
	if(  GetElem(A,i,e) )
	{
		cout<<"查找成功！"<>s;
}
void output(ElemType s)
{
	cout<next=NULL; // 指针域为空
	
}

int ListInsert(LinkList &L,int i,ElemType e) 
{	// 在带头结点的单链线性表L的第i个元素之前插入元素e  
	LinkList p,s;
	p = L;   
	int j = 0;
	while (p && j < i-1) {  // 寻找第i-1个结点
		p = p->next;
		++j;
	} 
	if (!p || j > i-1) 
		return 0;                   // i小于1或者大于表长
	s = (LinkList)malloc(sizeof(LNnode));  // 生成新结点
	s->data = e;  s->next = p->next;      // 插入L中
	p->next = s;
	return 1;
}

void ListTraverse(LinkList L,void(*vi)(ElemType))
{ 	// 初始条件：单链表L已存在。
	//操作结果：依次对L的每个数据元素调用函数vi()
	LinkList p=L->next;
	while(p)
	{
		vi(p->data);
		p=p->next;
	}
	printf("\n");
}

int GetElem(LinkList L,int i,ElemType &e) 
{ 
	// L为带头结点的单链表的头指针。当第i个元素存在时，其值赋给e并返回1，否则返回0
	/********** Begin **********/ 
	if(!L->next) return 0;
    LinkList p = L;
    for(int j =0;jnext;
    }
    if(!p) return 0;
    e = p->data;
    return e;
    
	/********** End **********/
}

 第4关 单链表的按照值查找结点位序的操作

#include 
#include 
#include 
using namespace std;


/* 定义ElemType为int类型 */
typedef int ElemType;
void input(ElemType &s);
void output(ElemType s);
int equals(ElemType a,ElemType b);

/* 单链表类型定义 */
typedef struct LNnode
{	
	ElemType data;
	struct LNnode *next;
}LNnode,*LinkList;
void InitList(LinkList &L);
int ListInsert(LinkList &L,int i,int e) ;
void ListTraverse(LinkList L,void(*vi)(ElemType));
int LocateElem(LinkList L,ElemType e,int(*compare)(ElemType,ElemType));
int main()               //main() function 
{	
	LinkList A;
	ElemType e;
	InitList(A);
	int n,i;
	// cout<<"Please input the list number ";
	cin>>n;
	for(i=1;i<=n;i++)
	{ 
		cin>>e;
		ListInsert(A, i, e);
	}
	//cout<<"请输入查找的元素："<>e;	
	i=LocateElem(A,e,equals);
	if( i ) 
	{
		cout<<"查找成功！"<>s;
}
void output(ElemType s)
{
	cout<next=NULL; // 指针域为空	
}

int ListInsert(LinkList &L,int i,ElemType e) 
{	// 在带头结点的单链线性表L的第i个元素之前插入元素e  
	LinkList p,s;
	p = L;   
	int j = 0;
	while (p && j < i-1) {  // 寻找第i-1个结点
		p = p->next;
		++j;
	} 
	if (!p || j > i-1) 
		return 0;                   // i小于1或者大于表长
	s = (LinkList)malloc(sizeof(LNnode));  // 生成新结点
	s->data = e; 
    s->next = p->next;      // 插入L中
	p->next = s;
	return 1;	
}

void ListTraverse(LinkList L,void(*vi)(ElemType))
{ 	// 初始条件：单链表L已存在。
	//操作结果：依次对L的每个数据元素调用函数vi()
	LinkList p=L->next;
	while(p)
	{
		vi(p->data);
		p=p->next;
	}
	printf("\n");
}

int LocateElem(LinkList L,ElemType e,int (*equal)(ElemType,ElemType))
{ 
	// 初始条件: 单链表L已存在，equal()是数据元素判定函数(满足为1，否则为0)
	// 操作结果: 返回L中第1个与e满足关系equal()的数据元素的位序，若这样的数据元素不存在，则返回值为0
	/********** Begin **********/ 
	if(!L->next) return 0;
    LinkList p = L->next;
    for(int i = 1;p;i++){
        if(equal(p->data,e))
            return i;
        p = p->next;
    }
	/********** End **********/
}

第5关 单链表的逆置操作

#include 
#include 
#include 
using namespace std;

/* 定义ElemType为int类型 */
typedef int ElemType;
void input(ElemType &s);
void output(ElemType s);
int equals(ElemType a,ElemType b);

/* 单链表类型定义 */
typedef struct LNnode
{	
	ElemType data;
	struct LNnode *next;
}LNnode,*LinkList;
void InitList(LinkList &L);
int ListInsert(LinkList &L,int i,int e) ;
void ListTraverse(LinkList L,void(*vi)(ElemType));
void reverse (LinkList  L);
int main()               //main() function 
{	
	LinkList A;
	ElemType e;
	InitList(A);
	int n,i;
	// cout<<"Please input the list number ";
	cin>>n;
	for(i=1;i<=n;i++)
	{ 
		cin>>e;
		ListInsert(A, i, e);
	}
	cout<<"逆置单链表："<>s;
}
void output(ElemType s)
{
	cout<next=NULL; // 指针域为空	
}

int ListInsert(LinkList &L,int i,ElemType e) 
{	// 在带头结点的单链线性表L的第i个元素之前插入元素e  
	LinkList p,s;
	p = L;   
	int j = 0;
	while (p && j < i-1) {  // 寻找第i-1个结点
		p = p->next;
		++j;
	} 
	if (!p || j > i-1) 
		return 0;                   // i小于1或者大于表长
	s = (LinkList)malloc(sizeof(LNnode));  // 生成新结点
	s->data = e;  s->next = p->next;      // 插入L中
	p->next = s;
	return 1;	
}

void ListTraverse(LinkList L,void(*vi)(ElemType))
{ 	// 初始条件：单链表L已存在。
	//操作结果：依次对L的每个数据元素调用函数vi()
	LinkList p=L->next;
	while(p)
	{
		vi(p->data);
		p=p->next;
	}
	printf("\n");	
}

void reverse (LinkList  L)
{  
	//逆置L指针所指向的单链表
	/********** Begin **********/ 
    LinkList l = L->next;
    LinkList end = l->next;
    LinkList t;
    while(end){
        t = L->next;
        L->next = l->next;
        l->next = end->next;
        end->next = t;
        end = l->next;
    }


    
	/********** End **********/
}

 第6关 两个有序单链表的合并操作

#include 
#include 
#include 

using namespace std;

/* 定义ElemType为int类型 */
typedef int ElemType;

void input(ElemType &s);

void output(ElemType s);

int equals(ElemType a, ElemType b);

/* 单链表类型定义 */
typedef struct LNnode {
    ElemType data;
    struct LNnode *next;
} LNnode, *LinkList;

void InitList(LinkList &L);

int ListInsert(LinkList &L, int i, int e);

void ListTraverse(LinkList L, void(*vi)(ElemType));

void MergeList(LinkList &La, LinkList &Lb, LinkList &Lc);

int main()               //main() function
{
    LinkList A, B, C;
    ElemType e;
    InitList(A);
    InitList(B);
    int n, i;
    // cout<<"Please input the list number ";
    cin >> n;
    for (i = 1; i <= n; i++) {
        cin >> e;
        ListInsert(A, i, e);
    }
    cin >> n;
    for (i = 1; i <= n; i++) {
        cin >> e;
        ListInsert(B, i, e);
    }
    cout << "合并两个有序单链表：" << endl;
    MergeList(A, B, C);
    
    ListTraverse(C, output);
}

/*****ElemType类型元素的基本操作*****/
void input(ElemType &s) {
    cin >> s;
}

void output(ElemType s) {
    cout << s << " ";
}

int equals(ElemType a, ElemType b) {
    if (a == b)
        return 1;
    else
        return 0;
}

/*****单链表的基本操作*****/
void InitList(LinkList &L) {    // 操作结果：构造一个空的单链表L
    L = (LinkList) malloc(sizeof(LNnode)); // 产生头结点，并使L指向此头结点
    if (!L) // 存储分配失败
        return;
    L->next = NULL; // 指针域为空
}

int ListInsert(LinkList &L, int i, ElemType e) {    // 在带头结点的单链线性表L的第i个元素之前插入元素e
    LinkList p, s;
    p = L;
    int j = 0;
    while (p && j < i - 1) {  // 寻找第i-1个结点
        p = p->next;
        ++j;
    }
    if (!p || j > i - 1)
        return 0;                   // i小于1或者大于表长
    s = (LinkList) malloc(sizeof(LNnode));  // 生成新结点
    s->data = e;
    s->next = p->next;      // 插入L中
    p->next = s;
    return 1;
}

void ListTraverse(LinkList L, void(*vi)(ElemType)) {    // 初始条件：单链表L已存在。
    //操作结果：依次对L的每个数据元素调用函数vi()
    LinkList p = L->next;
    while (p) {
        vi(p->data);
        p = p->next;
    }
    printf("\n");
}

void MergeList(LinkList &La, LinkList &Lb, LinkList &Lc) {    // LC 只是指正 没有指向任何地址
    // 已知单链线性表La和Lb的元素按值非递减排列。
    // 归并La和Lb得到新的单链线性表Lc，Lc的元素也按值非递减排列。
    /********** Begin **********/

    LinkList a = La->next, b = Lb->next, c = La;
    Lc = c;

    while (a && b) {
        LinkList t= (LinkList) malloc(sizeof(LNnode));
        if (!t) return;
        t->next = nullptr;

        if (a->data < b->data) {
            t->data = a->data;
            c->next = t;
            c = c->next;
            a = a->next;
        }else {
            t->data = b->data;
            c->next = t;
            c = c->next;
            b = b->next;
        }
    }

    while (a) {
        LinkList t= (LinkList) malloc(sizeof(LNnode));
        if (!t) return;
        t->next = nullptr;

        t->data = a->data;
        c->next = t;
        c = c->next;
        a = a->next;
    }
    while (b) {
        LinkList t= (LinkList) malloc(sizeof(LNnode));
        if (!t) return;
        t->next = nullptr;
        t->data = b->data;
        c->next = t;
        c = c->next;
        b = b->next;
    }

    /********** End **********/
}