链表的相关算法--c语言版_链表c语言算法-CSDN博客

本文链接：https://blog.csdn.net/qq_51636863/article/details/135004405

//－－－－－ 单链表的存储结构－－－－－
typedef struct LNode {
	ElemType data;          //结点的数据域
	struct LNode *next;     //结点的指针域
} LNode, *LinkList;         //LinkList 为指向结构体 LNode 的指针类型
//返回结点
LNode ListDelete(LinkList &L, int i) {}
//返回整个链表
LinkList ListDelete(LinkList &L, int i) {
	LNode *pre=L,*p=pre->next;
}

增

在带头结点的循环单链表的第k个位置插入新元素v，若表长小于k，则插在表尾。

void addElem(LinkList &L,int k) {
	LNode *p = L,*q;
	q->data=v; 
	int i;
	while(p) {
		if(L.length<k) {
			while(p->next!=L) {
				p=p->next;
			}
			p->next=q;
			q->next=L;
		} else {
			for(i=1;i<k;i++)
				p=p->next;
			q->next=p->next;
			p->next=q;
		}
	}
}

将非空单链表hb插入到单链表ha的第i（0<i<表长）个结点前。

//单链表ha,hb带头结点
void insertLinkList(LinkList &ha,LinkList &hb,int i) {
	LinkList *p,*q;
	for(p=hb; p->next; p=p->next);
	int j;
	for(j=1; j<i; j++) {
		q=q->next;
	}
	p->next=q->next;
	q->next=hb->next;
}

删

删除值为x的重复结点（使用单链表）

void Delete(LinkList* L, ElemType x) {
	// L为带头结点的链表
	LinkList *p = L->next, *pre = L, *q;
	if (p == NULL)
	{
		printf("链表为空！\n");
		return;
	}
	while (p) {
		if (p->data == x) {
			q = p;           // 让q指向p（要删除的结点）
			p = p->next;     // 将指针p向后移动一个结点
			pre->next = p;   // 改变pre指针域的指向，使q从链表中删除
			free(q);         // 释放q（要删除的结点）
		}
		else {
			pre = p;        // pre向下后移
			p = p->next;    // p与pre同步向后移，这两步不能调换顺序
		}
	}
}

删除数值相同的元素，有序表

void del_same(LinkList &L) {
    LNode *p=L->next,*q;
    if(p==NULL)
        return;
    while(p->next!=NULL) {
        q=p->next;
        if(p->data==q->data) {
            p->next=q->next;
            free(q);
        } else
            p=p->next;
    }
}

带有头结点的单链表L中删除一个最大值结点

LinkList del_maxnode(LinkList &L)
{
	LNode *pre=L,*p=pre->next;
	LNode *maxpre=pre,*maxp=p;
	while(p!=NULL){
		if(maxp->data<p->data){
			maxp = p;
			maxpre = pre;
		}
		pre = p;
		p=p->next;
	}
	maxpre->next=maxp->next;
	free(maxp);
	return L;
}

删除带有头结点的单链表L中数据域小于max，大于min的所有结点，并释放其所占空间。

LinkList DeleteList(LinkList L,int min,int max)
{
	LinkList p,s;
	s=L;//前驱
	p=L->next;//工作指针
	while(p!=NULL)
	{
		if(p->data>min&&p->data<max)
		{
			LinkList del;
			del=p;
			s->next=p->next;
			free(del);
			p=s->next;
		}
		else
		{
			s=s->next;
			p=p->next;
		}		
	}
    return L;		
}

改

将带头的单链表L改成带头的循环单链表

void LinkModi(LinkList &L){
	p=L;
	while(p->next!=NULL){
		p=p->next;
	}
	p->next=L;
}

逆置带头的单链表L（头插法）

void reverse(LinkList &L) {
	LinkList *p;
	p=L->next;
	L->next=NULL;
	for(p; p!=NULL; p=p->next) {
		p->next=L->next;
		L->next=p;
	}
}

将两个线性表合并成一个，形成一个带头单链表

LinkList ListUnion(LinkList &La, LinkList Lb) {
	LNode *pa=La->next,*pb=Lb->next;
	while(pa) {	
		pa=pa->next;
	}
	pa->next=pb;
	free(Lb);
	Lb=La;
}

A、B（元素递增有序）中公共元素存放在单链表C中

void get_common(LinkList A,LinkList B) {
    LNode *p=A->next,*q=B->next,*r,*s;
    LinkList C=(LinkList)malloc(sizeof(LNode));
    r=C;
    while(p!=NULL&&q!=NULL) {
        if(p->data<q->data)
            p=p->next;
        else if(p->data>q->data)
            q=q->next;
        else {
            s=(LNode*)malloc(sizeof(LNode));
            s->data=p->data;
            r->next=s;
            r=s;
            p=p->next;
            q=q->next;
        }
    }
    r->next=NULL;
}

使数据元素递增有序

void sort(LinkList *&L) {
	LinkList *p,*pre,*q;
	p=L->next->next;        //p指向L的第2个数据节点
	L->next->next=NULL;     //构造只含一个数据节点的有序表
	while (p!=NULL) {
		q=p->next;          //q保存*p节点后继节点的指针
		pre=L;              //从有序表开头进行比较,pre指向插入*p的前驱节点
		while (pre->next!=NULL && pre->next->data<p->data)
			pre=pre->next;  //在有序表中找插入*p的前驱节点*pre
		p->next=pre->next;  //将*pre之后插入*p
		pre->next=p;
		p=q;                //扫描原单链表余下的节点
	}
}

查

比较两链表的长度

int compare(Linklist la,Linklist lb) {
	Linklist *p=la;
	Linklist *q=lb;
	while(p->next!=NULL&&q->next!=NULL) {
		p=p->next;
		q=q->next;
	}
	if(p==NULL&&q==NULL) {
		return 0;
	} else if(p==NULL) {
		return -1;
	} else {
		return 1;
	}
}

结点值为偶数的，结点的个数。

int CountEven(LinkList L)
{
	LNode *p = L->next;//从第一个元素结点开始
	int sum = 0;//结点值为偶数的结点的个数
	if (p == NULL)
	   return 0 ;	   
	while(p)//为空遍历结束
	{
		if (p->data % 2 == 0)
		    sum++;
		p = p->next;//向后遍历 
	}
	return sum ;
}

带头结点的单链表从尾到头反向输出每个结点的值

void r_print(LinkList L) {
    if(L->next!=NULL)
        r_print(L->next);
    if(L!=NULL)
        print(L->data);
}
void r_ignore_head(LinkList L) {
    if(L->next!=NULL)
        r_print(L->next);
}

带头结点的单链表A分解为两个带头结点的单链表A（序号为奇数的）和B（序号为偶数的），保持相对位置不变

LinkList disCreat(LinkList &A){
	int i=0;
	LinkList B=(LinkList)malloc(sizeof(LNode));
	B->next=NULL;
	LNode *ra=A,*rb=B,*p;
	p=A->next;
	A->next=NULL;
	while(p!=NULL){
		i++;
		if(i%2==0){
			rb->next=p;
			rb=p; 
		}else{
			ra->next=p;
			ra=p;
		}
		p=p->next;
	}
	ra->next=NULL;
	rb->next=NULL;
	return B;
}

判断序列B是否是序列A的连续子序列

int pattern(LinkList A,LinkList B) {
    LNode *p=A,*pre=p,*q=B;
    while(p&&q) {
        if(p->data==q->data) {
            p=p->next;
            q=q->next;
        } else {
            pre=pre->next;
            p=pre;
            q=B;
        }
        if(q==NULL)
            return 1;
        else
            return 0;
    }
}

判断带头结点的循环双链表是否对称

int Symmetry(DLinkList L) {
    DNode *p=L->next,*q=L->prior;
    while(p!=q&&q->next!=p) {
        if(p->data==q->data) {
            p=p->next;
            q=q->prior;
        } else
            return 0;
    }
    return 1;
}

反复找到头结点的循环单链表的最小值结点输出，然后删除，直到单链表为空

void dele_all(LinkList &L) {
    LNode *p,*pre,*minp,*minpre;
    while(L->next!=L) {
        p=L->next;
        pre=L;
        min=p;
        minpre=pre;
        while(p!=L) {
            if(p->data<min->data) {
                minp=p;
                minpre=pre;
            }
            pre=p;
            p=p->next;
        }
        printf("%d",minp->data);
        minpre->next=minp->next;
        free(minp);
    }
    free(L);
}

判断单链表是否存在环

LNode *findLoopStart(LNode *head) {
    LNode *fast=head,*slow=head;
    while(fast!=NULL&&fast->next!=NULL) {
        slow=slow->next;
        fast=fast->next;
        if(slow==fast) break;
    }
    if(fast==NULL || fast->next==NULL)
        return NULL;//不存在环 
    LNode *p1=head,*p2=slow;
    while(p1!=p2){
    	p1=p1->next;
    	p2=p2->next;
	}
	return p1;//返回还的入口 
}

查找带头结点的单链表中倒数第K个位置上的结点

int search_k(LinkList L,int k) {
    LNode *p=L->next,*q=L->next;
    int count=0;
    while(p!=NULL) {
        if(count<k) count++;
        else q=q->next;
        p=p->next;
    }
    if(count<k)
        return 0;
    else {
        print("%d",q->data);
        return 1;
    }
}