10、单链表操作

单链表操作

单链表操作1

/*单链表的类型定义*/
typedef int DataType;
typedef struct node
{
	DataType data;
	struct node * next;
}LinkNode, *LinkList;

/*单链表的定位运算*/
LinkNode *Locate(LinkNode *L, int k)//????为什么此处是LinkNode *Locate()类型，表示什么意思
{
	LinkNode *p; int i;
	i= 1; p = L->next;							//初始时p指向第一个元素结点，i为计数器
	while(p != NULL && i < k )					//通过链接指针逐个向后查找第k个结点
	{
		p = p->next;
		i++;
	}
	if(p != NULL && i == k)						//存在第k个元素且指针p指向该元素结点
		return p;
	return NULL;								//第k个元素不存在
};

/*单链表的插入运算*/
int Insert(LinkNode *L, int k, int elem)
{
	LinkNode *p, *q;
	if(k==1)
		p=L;									//元素elem插入在第1个元素位置
	else p = Locate(L, k-1);					//查找表中的第k-1个元素
	if(p==NULL)
		return 0;								//表中不存在第k-1个元素，插入失败
	q = new LinkNode;							//创建插入结点
	if(q == NULL)
	{
		printf("存储分配失败！\n");
		return 0;
	}
	q->data = elem;								//元素elem插入第k-1个元素之后
	q->next = p ->next;
	p->next = q;

	return 1;
}

/*单链表的删除运算*/
int Remove(LinkNode *l, int k)
{
	linkNode *p, *q;
	if(k==1)
		p = L;									//删除第一个元素结点
	else p = Locate(L,k-1);						//查找表中的第k-1个元素
	if(p==NULL)									//表中不存在第k-1个元素则删除失败
		return 0;
	q = p->next;								//令q指向第k个元素结点
	p->next = q->next; delete q;				//删除结点
	return 1;
};

/*在待头结点的单链表中寻找第i个结点*/
LinkNode *Locate(LinkList &L, int i)
{
	if(i < 0)
		return NULL;							//位置i在表中不存在
	LinkNode *p = L;
	int k = 0;									//从表头结点开始检测
	while(p != NULL && k < i)					//p=NULL表示链短，无第i个结点
	{
		p = p -> next;
		k++;
	}
	return p;									//否则k = i，返回第i个结点地址
};

/*在带头结点的单链表中确定值最大的结点*/
LinkNode *Max(LinkList &L)
{
	if(L->next == NULL)
		return NULL;							//空表，返回指针NULL
	LinkNode * pmax = L->next, p=L->next->next; //假定首元结点中的数据值最大
	while(p != NULL)							//循环，下一个结点存在
	{
		if(p->data>pmax->data)					//pmax记忆找到的具最大值的结点
			pmax = p;
		p = p->next;							//检测下一个结点
	}
	return pmax;
}

/*统计带头结点的单链表中具有给定值x的所有元素*/
int Count(LinkList &L,DataType x)
{
	int n = 0;
	LinkNode *p = L->next;						//从首元结点开始检测
	while(p != NULL)							//循环，下一个结点存在
	{
	if(p -> data == x)							//找到一个，计数器加1
		n++;
	p = p->next;								//检测下一个结点
}
return n;
};

/*根据一维数组建立一个带头结点的单链表*/
void CreateList(LinkList &L, DataType A[], int n)
{
	LinkNode *rear;
	L = rear = new LinkNode;					//创建链表头结点
	for(int i = 0; i<n; i++)
	{
		rear->next = new LinkNode;				//链入一个新结点
		rear = rear->next;						//rear指向链中的尾结点
		rear->data = A[i];
	}
	rear->next = NULL;							//链表收尾

};

/*在非递减有序的带头结点的单链表中删除值相同的多余结点*/
void tidyup(LinkLisy &L)						//检测指针p指向首元结点
{
LinkNode *p = L->next, temp;
while(p != NULL && p ->next != NULL)			//循环检测链表
if(p->data == p->next->data)					//若相邻结点值相等
{
	temp = p->next;								//从链表删除一个值相同的结点
	p->next = temp->next;
	delete temp;								//释放该结点
}
else p = p->next;								//指针p进到链表的下一个结点
};

/*递归实现求链表中的最大整数、表中结点的个数、所有元素的平均值*/
int Max(LinkNode *L)
{
	if(L->link == NULL)							//链表仅一个结点，其值即所求
		return L->data;
	int (temp = Max(L->next));					//否则递归求后继结点中的最大值
	if(L->data>temp)
		return L->data;							//再与首元的值比较取大者
	else return temp;
};

int Num(LinkNode *L)
{
	if(L==NULL)									//空链表结点的个数为0
		return 0;
		return 1+Num(L->next );					//否则求后继结点数再加1

};

float Avg(LinkNode *L, int &n)					//链表仅一个结点
{
	if(L->next == NULL)							//其值即所求
	{
		n = 1;
		return(float)(L->data);
	}
	else										//否则
	{
		float Sum = Avg(L->next, n) * n;		//先递归求后继结点的平均值
		n++;									//在计算总和
		return (L->data+Sum)/n;					//然后加上首元之值再求平均值
	}
};

/*通过遍历一趟链表，将链表中所有结点的链接方向逆转*/
void Reverse(LinkNode * &h)
{
	if(h== NULL)
		return;
	LinkNode *p = h->next, *pr = NULL;			//逆转h指针
	while(p!=NULL)
	{
		h->next = pr;							//指针前移
		pr=h;
		h=p;
		p= p->next;
	}
	h->link = pr;
};

void Reverse(LinkNode &L)
{
	LinkNode *p =L->next, *pr ;
	L->link = NULL;
	while(p!=NULL)
	{
		pr = p;
		p = p->next;
		pr->next=L->next;					//摘下剩余链首元结点
		L->next = pr;						//作为首元结点插入结果链
	}
};

/*在一个带头结点的单链表中所有元素的结点的数据按递增顺序排序，删除表中所有大于min且小于max的元素*/
typedef int DataType
void rangeDelete(LinkNode &L, DataType min, DataType max)
{
	LinkNode *pr = L, *p = L->next;
	while(p != NULL && p->data <= min)				//寻找值大于min的元素
	{
		pr = p;
		p = p-> next;
	}
	while(p != NULL && p->data < max)				//删除值小于max的元素
	{
		pr ->next = p->next;
		delete p;
		p = pr->next;
	}
};

/*在一个带头结点的单链表中所有元素的结点的数据无序排序，删除表中所有大于min且小于max的元素*/
typedef int DataType
void rangeDelete(LinkNode &L, DataType min, DataType max)
{
	LinkNode *pr = L, *p = L->next;				//p是检测指针，pr是其前驱
	while(p != NULL)
	if(p ->data >min && p->data < max)			//寻找到删除结点，删除
	{
		pr ->next = p->next;
		delete p;
		p = pr->next;							//否则继续寻找被删结点
	}
	else
	{
		pr = p;
		p = p-> next;
	}
};

单链表操作2

//指向结点的指针是结构体指针类型，链表是结构体指针类型？？？？
#include<stdio.h>								//带头结点的链表操作
#include<stdlib.h>
#define ERROR 0
#define OK 1
#define OVERFLOW -1
typedef int ElemType;
typedef struct LNode
{
    ElemType data;
    struct LNode *next;							//next指向了一个和它本身数据类型一样的下一个结点
}LNode,*LinkList;								//LNode等价于struct LNode;	LinkList等价于struct LNode *						

void GetElem(LinkList L,int i,ElemType *e)		//查找第i个元素并返回，函数是无返回值类型
{
    LNode *p;									//ElemType *e用于存储返回的值，LNode *p等价于LinkList p
    int j=1;
    p=L->next;									//p=L->next,此时p指向首结点
    while(p&&j<i)								//如果结点为空就停止循环
    {
        p=p->next;++j;
    }
    if(!p||j>i)printf("不存在,查找错误\n");
    else
    *e=p->data;
}
void ListInsert_L(LinkList *L,int i,ElemType e)//插入元素。
{
    LinkList p=*L,s=NULL;														//LinkList *L?????LinkList p=*L
    int j=0;
    while(p&&j<i-1){p=p->next;++j;}
    if(!p||j>i-1)printf("插入位置错误\n");
    s=(LinkList)malloc(sizeof(LNode));
    s->data=e;
    s->next=p->next;
    p->next=s;
}
void ListDelet_L(LinkList *L,int i,ElemType *e)//删除元素
{
    LNode *p=*L,*q=NULL;
    int j=0;
    while(p->next&&j<i-1)
    {
        p=p->next;++j;
    }
    if(!(p->next)||j>i-1)printf("删除位置错误");
    q=p->next;p->next=q->next;
    *e=q->data;
    free(q);
}
void CreatList(LinkList *L,int n)//建立链表 输入n个ElemType类型的数
{
    LinkList p=NULL,q=NULL;
    int i;
    ElemType m;
    (*L)=(LinkList)malloc(sizeof(LNode));
    (*L)->next=NULL;
    p=(LinkList)malloc(sizeof(LNode));
    p->next=NULL;
    q=p;
    scanf("%d",&m);
    p->data=m;
    (*L)->next=p;
    for(i=1;i<n;i++)
    {
        p=(LinkList)malloc(sizeof(LNode));
        scanf("%d",&m);
        p->data=m;
        q->next=p;
        p->next=NULL;
        q=p;
    }
}
void DisList(LinkList L)
{
    LinkList p=L->next;
    while(p)
    {
        printf("%d ",p->data);
        p=p->next;
    }
    printf("\n");
}
int main()
{
    LinkList L=NULL;
    int i,p=1,m;
    ElemType e;
    printf("请输入10个元素:\n");
    CreatList(&L,10);
    printf("原来的10个元素为:");
    DisList(L);
    while(p)
    {
        printf("1)插入2)删除3)查找4)显示操作结果0)退出\n");
        scanf("%d",&m);
        switch(m)
        {
        case 1:printf("请分别输入要插入元素的位置及与元素值: ");
            scanf("%d%d",&i,&e);ListInsert_L(&L,i,e);break;
        case 2:printf("请分别输入要删除元素的位置: ");
            scanf("%d",&i);ListDelet_L(&L,i,&e);printf("删除的元素值为:%d\n",e);break;
        case 3:printf("请分别输入要查找的元素的位置: ");
            scanf("%d",&i);GetElem(L,i,&e);printf("该位置的元素为:%d\n",e);break;
        case 4:DisList(L);break;
        case 0:p=0;break;
        }
    }

    return 0;
}

单链表的插入3

#include"stdio.h"
#include"malloc.h"
#include"stdlib.h"

/*尾插法建立链表，链表元素顺序和数组一致*/
LinkList  CreatList2(LinkList &L)
{
    //从表头到表尾正向建立单链表L,每次均在表尾插入元素
    int x;  // 设元素类型为整型
    L=(LinkList)malloc(sizeof(LNode));
    LNode *s, *r=L;  //r 为表尾指针
    scanf ("%d", &x);  //输入结点的值

    while (x!=9999)
	{  //输入 9999 表示结束
        s=(LNode *)malloc(sizeof(LNode));
        s->data=x;
        r->next=s;
        r=s;  //r指向新的表尾结点
        scanf ("%d", &x);
    }

    r->next = NULL;  //尾结点指针置空
    return L;
}

/*头插法建立链表，链表元素顺序和数组相反*/
LinkList  CreatList1(LinkList &L)
{
    //从表尾到表头逆向建立单链表L，每次均在头结点之后插入元素
    LNode *s;int x;
    L=(LinkList)malloc(sizeof(LNode));  //创建头结点
    L->next=NULL;  //初始为空链表
    scanf("%d", &x);  //输入结点的值

    while(x!=9999)
	{  //输入 9999 表示结束
        s=(LNode*)malloc(sizeof(LNode) );  //创建新结点
        s->data=x;
        s->next=L->next;
        L->next=s;  //将新结点插入表中，L为头指针
        scanf ("%d", &x);
    }  //while 结束

    return L;
}
int main (void)
{
	return 0;
}

单链表的操作4

/*The Data Structure of Link List*/
typedef int DataType;
typedef struct LinkNode
{
    DataType         data;
    struct LinkNode *next;
}*LinkList; 

/*尾插法建立链表，链表元素顺序和数组一致*/
void CreateList(LinkList &L,DataType A[],int n)
{
    LinkNode *rear;
    L = rear = new LinkNode;
    for(int i=0; i<n; ++i)
    {
        rear->next =  new LinkNode;
        rear       =  rear->next;
        rear->data = A[i];
    }
    rear->next = NULL;
}

/*头插法建立链表，链表元素顺序和数组相反*/
void CreateList_reverse(LinkList &L,DataType A[], int n)
{
    L = new LinkNode;
    L->next = NULL;  

    for( int i=0; i<n; ++i)
    {
        LinkNode *p = new LinkNode;
        p->data = A[i];
        p->next = L->next;
        L->next = p;
    }
}  

/*链表逆置算法*/
void ReverseList(LinkList &L)
{
    LinkNode *pre = NULL;    /*two temporary node is needed to traverse the LinkList*/
    LinkNode * p  = L->next;  

    while( p != NULL)
    {
        L->next = p->next;   /* p->next will change,so store it in the head node*/
        p->next = pre;          

        pre = p;             /* pre point to the new head */
        p   = L->next;       /* p point to the next position */
    }
    L->next = pre;           /* L-next point to the head of the reversed list*/
}  

/*删除链表中的元素x*/
void DeleteList(LinkList &L,DataType x)
{
    for(LinkNode *pre=L,*p=L->next;  p!=NULL; pre=p,p=p->next )
        if( p->data == x)
        {
            pre->next = p->next;
            delete p;
            return;
        }
}    

/*插入链表元素x*/
void InsertList(LinkList &L ,DataType x)
{
    LinkNode *p = new LinkNode;
    p->data = x;
    p->next = L->next;
    L->next = p;
}  

/*显示链表所有元素，测试时比较有用*/
void DisplayList(LinkList &L)
{
    cout<<endl;
    for( LinkNode *p = L->next;  p != NULL;  p = p->next )
    {    cout<< p->data<<" ";    }
    cout<<endl;
}  

*链表的排序算法*/
void InsertSortList(LinkList &L)
{
    LinkNode *p     = L->next;        /*指向 待插入  结点 */
    LinkNode *nextp = NULL;           /*指向 p的后继 结点 */  

    LinkNode *q     = L;              /*指向有序链表的头部*/
    q->next         = NULL;              

    while( p != NULL )
    {
        q = L;
        while(q->next!=NULL && p->data >= q->next->data) /*寻找插入位置，循环停止时，p应插入到q的后面*/
        {   q = q->next;     }  

        nextp = p->next;
        p->next = q->next;    /* p 的后继应是 q */
        q->next = p;
        p = nextp;
    }
}  

/*链表查找算法*/
LinkNode *SearchList(LinkList &L,DataType x)
{
    LinkNode *p = L->next;
    while( p!=NULL && p->data!=x )
    {   p = p->next; }
    return p;
}  

/*链表销毁算法*/
void DestroyList(LinkList &L)
{
    if(L->next==NULL)
    {
        cout<<"delete"<<L->data<<endl;
        delete L;   }
    else
    {
        DestroyList(L->next);
        cout<<"delete"<<L->data<<endl;
        delete L;
    }
}

　　

　　

　　

　　

时间： 2024-12-15 07:10:09

10、单链表操作的相关文章

数据结构上机测试2-1:单链表操作A (顺序建表+关键字删除)

数据结构上机测试2-1:单链表操作A Time Limit: 1000MS Memory limit: 4096K 题目描述 输入n个整数,先按照数据输入的顺序建立一个带头结点的单链表,再输入一个数据m,将单链表中的值为m的结点全部删除.分别输出建立的初始单链表和完成删除后的单链表. 输入 第一行输入数据个数n: 第二行依次输入n个整数: 第三行输入欲删除数据m. 输出 第一行输出原始单链表的长度: 第二行依次输出原始单链表的数据: 第三行输出完成删除后的单链表长度: 第四行依次输出完成删除后的

数据结构之 线性表---单链表操作A （删除链表中的指定元素）

数据结构上机测试2-1:单链表操作A Time Limit: 1000MS Memory limit: 4096K 题目描述 输入n个整数,先按照数据输入的顺序建立一个带头结点的单链表,再输入一个数据m,将单链表中的值为m的结点全部删除.分别输出建立的初始单链表和完成删除后的单链表. 输入 第一行输入数据个数n: 第二行依次输入n个整数: 第三行输入欲删除数据m. 输出 第一行输出原始单链表的长度: 第二行依次输出原始单链表的数据: 第三行输出完成删除后的单链表长度: 第四行依次输出完成删除后的

循环单链表操作(转)

循环单链表的初始化,建立,插入,查找,删除. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 //////////////////////////////////////////////// //循环单链表的初始化,建立,插入,查找,删除.// //Autho

单链表操作

#include<stdio.h>#include<malloc.h> typedef struct Node{ int data; struct Node *next;}LinkList; //就地反转int LinkListRerverse(LinkList *head){ LinkList *q,*p; p = head->next; head->next = NULL; while(p != NULL){ q = p->next; p->next =

单链表操作系列

#include<stdio.h> #include<stdlib.h> typedef int ElemType; //定义结点类型 typedef struct Node { ElemType data; struct Node *next; }LNode,*LinkList; //单链表的建立1,头插法建立单链表,逆序生成 LinkList LinkListCreateH() { LinkList L,p; L = (LinkList)malloc(sizeof(LNode)

单链表操作实例程序

#include <iostream> #include <iomanip> using namespace std; typedef struct node { int val; node *next; }node; node * create_list(); void traverse_list(node *pHead); int get_len_list(node *pHead); bool delete_list(node *pHead,int pos,int &v

单链表操作问题，主要是逆操作

工作无事,搞其它事也不太方便,写点简单代码.本来想写的高大上一些,发现用范型不是一点代码的事,还是算了. #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct list { int val; struct list *next; }Node_def; #define NODE_SIZE (sizeof(Node_def)) #undef T #define T Node_def

数据结构之---c语言实现循环单链表操作

//=========杨鑫========================// //循环单链表的实现 #include <stdio.h> #include <stdlib.h> typedef int ElemType; //定义结点类型 typedef struct Node { ElemType data; struct Node *next; }Node,*LinkedList; int count = 0; //1.单循环链表的初始化 LinkedList init_ci

单链表操作（数据结构实验一）

 实验内容 1 初始化一个带表头结点的单链表. 2 从表头不断插入结点建立一个带表头结点的单链表.设表中元素的类型为整型,元素值从键盘输入. 3 从表尾不断插入结点建立一个带表头结点的单链表.设表中元素的类型为整型,元素值从键盘输入. 4 打印一个带表头结点的单链表. 5 清空一个带表头结点的单链表. 代码:(只是把各个函数写好,并给出了调用数据,其他根据实验要求改就行了) #include<stdio.h> #include<stdlib.h> #include<mallo