精华内容
下载资源
问答
  • 循环双链表

    2013-06-09 19:08:45
    循环双链表采用纯C编写,其中包含初始化、增加结点、修改结点和删除结点等
  • 循环双链表的实现,包括链表建立,插入,删除,显示等 代码无误,可以运行
  • 循环双向链表

    2014-04-04 10:58:25
    今天Mayuyu要讲的是循环双向链表,其实循环双向链表对于单向链表来说,对于链表的遍历更方便了,既可以向前 遍历,又可以向后遍历,缺点是占用空间比单向链表大。   现在Mayuyu来带领你们一步一步实现循环双向...

    今天Mayuyu要讲的是循环双向链表,其实循环双向链表对于单向链表来说,对于链表的遍历更方便了,既可以向前

    遍历,又可以向后遍历,缺点是占用空间比单向链表大。

     

    现在Mayuyu来带领你们一步一步实现循环双向链表的基本操作。

     

    (1)初始化循环双向链表

        同单向链表一样,循环双向链表同样有一个头节点,它的每一个节点包含3个域,即prior,val,next,分

        别指当前节点的前驱,值和后继,开始循环双向链表只有一个head节点,它的前驱和后继都指向自己。如图:

     

        

     

    代码如下:

    void Create()
    {
        head = new DList();
        head->prior = head;
        head->next = head;
        p = head;
    }

     

    (2)元素的插入操作

     

        如图,插入元素q,指针修改情况如下

     

       

     

       指针修改完毕后,再把p指针移动到q指针位置就行了,因为我们始终在p指针和head指针之间插入元素。

     

    代码如下:

    void Insert(int x)
    {
        q = new DList();
        q->val = x;
        p->next = q;
        q->prior = p;
        q->next = head;
        head->prior = q;
        p = q;
    }


    嗯,挺好理解吧?Mayuyu讲到这里,相信你能完成更多的操作,比如元素查找等等。

     

    完整代码:

    #include <iostream>
    #include <string.h>
    #include <stdio.h>
    
    using namespace std;
    
    struct DList
    {
        int val;
        DList *prior;
        DList *next;
    };
    
    DList *head,*p,*q;
    
    void Create()
    {
        head = new DList();
        head->prior = head;
        head->next = head;
        p = head;
    }
    
    void Insert(int x)
    {
        q = new DList();
        q->val = x;
        p->next = q;
        q->prior = p;
        q->next = head;
        head->prior = q;
        p = q;
    }
    
    void Print()
    {
        DList *p = head;
        p = p->next;
        while(p != head)
        {
            printf("%d ",p->val);
            p = p->next;
        }
    }
    
    int main()
    {
        int n;
        Create();
        cin>>n;
        for(int i=0;i<n;i++)
        {
            int x;
            cin>>x;
            Insert(x);
        }
        Print();
        return 0;
    }
    


     

     

    展开全文
  • 循环双链表与双循环链表差别Solution: 解: Input: The data of each node 输入:每个节点的数据 Output: The circular doubly linked list 输出:圆形双向链表 Data structure used: A circular doubly ...

    循环双链表与双循环链表差别

    Solution:

    解:

    Input: The data of each node

    输入:每个节点的数据

    Output: The circular doubly linked list

    输出:圆形双向链表

    Data structure used: A circular doubly linked list where each node contains a data part, say data and two link parts say prev (to store the address of immediate previous node) and say next (to store the address of immediate next node).

    使用的数据结构:环形双链表,其中每个节点包含一个数据部分,例如data和两个链接部分说prev (存储紧邻的前一个节点的地址)和next (存储紧邻的下一个节点的地址)。

    Algorithm:

    算法:

    Begin
    head=NULL
    //get a memory block of type node and store it in the pointer temp
    temp=getnode(node)		
    If(temp!=NULL)
    	Print("Enter the element in the list : ",temp->data)
    	temp->next=head;
    	If(head=NULL)
    		head=temp
    		temp->prev=head
    		temp->next=head
    	Else
    		temp1=head;
    		while(temp1->next!=head)
    			begin
    			temp1=temp1->next;
    		End while
    			temp1->next=temp;
    			temp->prev=temp1;
    	End IF-Else	
    Else
    	Printf ("Memory not avilable...node allocation is not possible")
    End IF-ELSE
    End
    
    

    C code:

    C代码:

    #include <stdio.h>
    #include <stdlib.h>
    
    //cicular double linked list structure
    typedef struct list 
    {
    	int data; 
    	struct list *next;
    	struct list *prev;
    }node;
    
    void display(node *temp){
    	//now temp1 is head basically
    	node *temp1=temp; 
    	printf("The list is as follows :\n%d->",temp->data);
    	temp=temp->next;
    	//which not circle back to head node 
    	while(temp!=temp1) 
    	{
    		printf("%d->",temp->data);
    		temp=temp->next;
    	}
    	printf("%d\n",temp1->data);
    	return;
    }
    
    int main(){
    	node *head=NULL,*temp,*temp1;
    	int choice;
    	
    	//building circular double linked list as input
    	do
    	{
    		temp=(node *)malloc(sizeof(node));
    		if(temp!=NULL)
    		{
    			printf("\nEnter the element in the list : ");
    			scanf("%d",&temp->data);
    			temp->next=head;
    			if(head==NULL)
    			{	
    				head=temp;
    				temp->prev=head;
    				temp->next=head;
    			}
    			else
    			{
    				temp1=head;
    				while(temp1->next!=head)
    				{
    					temp1=temp1->next;
    				}
    				temp1->next=temp;
    				temp->prev=temp1;
    			}
    		}
    		else
    		{
    		printf("\nMemory not avilable...node allocation is not possible");
    		}
    		printf("\nIf you wish to add more data on the list enter 1 : ");
    		scanf("%d",&choice);
    	}while(choice==1);
    	
    	display(head);
    	
    	return 0;
    }
    
    

    Output

    输出量

    Enter the element in the list : 1
    
    If you wish to add more data on the list enter 1 : 1
    
    Enter the element in the list : 2
    
    If you wish to add more data on the list enter 1 : 1
    
    Enter the element in the list : 3
    
    If you wish to add more data on the list enter 1 : 1
    
    Enter the element in the list : 4
    
    If you wish to add more data on the list enter 1 : 1
    
    Enter the element in the list : 5
    
    If you wish to add more data on the list enter 1 : 0
    The list is as follows :
    1->2->3->4->5->1
    
    
    

    翻译自: https://www.includehelp.com/c-programs/implement-circular-doubly-linked-list.aspx

    循环双链表与双循环链表差别

    展开全文
  • 循环链表、双链表、循环双链表循环链表循环链表的创建循环链表的头插循环链表的尾插循环链表的任意位置插入循环链表按位置删除循环链表的逆序循环链表的销毁双链表双链表的创建双链表的头插双链表的尾插双链表按任意...

    循环链表

    • 循环链表最后一个结点node->next重新指向头结点ls->head
    • 在单向链表的基础上将所有NULL的判断改写成是否为头结点

    循环链表的创建

    1. 链表没有结点的时候,头结点指向自身
      ls->head->next = ls->head;
    List *CreateList()
    {
    	List *ls = (List*)malloc(sizeof(List)/sizeof(char));
    	if (NULL == ls)
    		return NULL;
    	
    	// 创建头结点
    	ls->head = (Node*)malloc(sizeof(Node)/sizeof(char));
    	if(NULL == ls->head)
    	{
    		free(ls);
    		return NULL;
    	}
    	
    	ls->head->next = ls->head;   // 空链表
    	
    	return ls;
    }
    

    循环链表的头插

    BOOL Insert_Head(List *ls, Data data)
    {
    	if (NULL == ls)
    		return ERROR;
    	
    	Node *node = (Node *)malloc(sizeof(Node)/sizeof(char));
    	if (NULL == node)
    		return ERROR;
    	
    	node->data = data;
    	node->next = ls->head->next;
    	ls->head->next = node;
    	
    	return TRUE;
    }
    

    循环链表的尾插

    
    BOOL Insert_Last(List *ls, Data data)
    {
    	if (NULL == ls)
    		return ERROR;
    	
    	Node *node = (Node *)malloc(sizeof(Node)/sizeof(char));
    	if (NULL == node)
    		return ERROR;
    	
    	node->data = data;
    	node->next = ls->head;
    	
    	Node *tmp = ls->head;         // 头结点
    	while (tmp->next != ls->head)
    	{
    		tmp = tmp->next;
    	}
    	
    	tmp->next = node;
    	
    	return TRUE;
    }
    

    循环链表的任意位置插入

    BOOL Insert_Pos(List *ls, int pos, Data data)
    {
    	if(NULL == ls|| pos<1)
    		return ERROR;
    	
    	Node *tmp = ls->head;
    	int i;
    	for (i = 0; i<pos-1; i++)
    	{
    		tmp = tmp->next;
    		if (tmp == ls->head)  // 越界
    		{
    			printf ("长度越界: %d\n", pos);
    			return ERROR;
    		}
    	}
    	
    	Node *node = (Node *)malloc(sizeof(Node)/sizeof(char));
    	if (NULL == node)
    		return ERROR;
    	
    	node->data = data;
    	node->next = tmp->next; 		
    	tmp->next  = node;
    	
    				
    	return TRUE;
    }
    

    循环链表按位置删除

    BOOL Delete_Pos(List *ls, int pos)
    {
    	if(NULL == ls|| pos<1)
    		return ERROR;
    	
    	Node *tmp = ls->head;
    	int i;
    	for (i = 0; i<pos-1; i++)
    	{
    		tmp = tmp->next;
    		if (tmp == ls->head || tmp->next == ls->head)  // 越界
    		{
    			printf ("长度越界: %d\n", pos);
    			return ERROR;
    		}
    	}
    	
    	Node *p = tmp->next;
    	tmp->next = p->next;
    	free(p);
    				
    	return TRUE;
    }
    

    循环链表的逆序

    BOOL Reverse(List *ls)
    {
    	// NULL ==ls || NULL == ls->head    链表不存在
    	// NULL == ls->head->next           空链表
    	// NULL == ls->head->next->next     只有一个结点的链表
    	if (NULL == ls || NULL == ls->head || ls->head == ls->head->next || ls->head == ls->head->next->next)
    		return ERROR;
    	
    	Node *pre = ls->head->next;    // 第一个结点
    	Node *cur = pre->next;         // 第二个结点
    	Node *tmp;                     // 保存当前结点的下一个结点
    	
    	while (cur != ls->head)
    	{
    		tmp = cur->next;
    		cur->next = pre;
    		
    		pre = cur;
    		cur = tmp;
    	}
    	
    	ls->head->next->next = ls->head;	//将原来第一个结点的指针域指向NULL
    	ls->head->next = pre;				//将头结点的next指向最后一个元素
    	
    	return TRUE;
    }
    

    循环链表的销毁

    void Destroy(List *ls)
    {
    	if (NULL == ls)
    		return;
    	
    	Node *tmp = ls->head;
    	while (tmp->next != ls->head)
    	{
    		Node *p = tmp->next;
    		tmp->next = p->next;
    		free(p);
    	}
    	
    	free(ls->head);
    	free(ls);
    }
    

    双链表

    双链表有指针域有两个指针,一个指向下一个结点,一个指向前一个结点

    双链表的创建

    vList *CreateList()
    {
    	List *ls = (List*)malloc(sizeof(List)/sizeof(char));
    	if (NULL == ls)
    		return NULL;
    	
    	// 创建头结点
    	ls->head = (Node*)malloc(sizeof(Node)/sizeof(char));
    	if(NULL == ls->head)
    	{
    		free(ls);
    		return NULL;
    	}
    	
    	ls->head->next = NULL;   // 空链表
    	ls->head->pre  = NULL;     //包含两个指针
    	
    	return ls;
    }
    

    双链表的头插

    BOOL Insert_Head(List *ls, Data data)
    {
    	if (NULL == ls)
    		return ERROR;
    	
    	Node *node = (Node *)malloc(sizeof(Node)/sizeof(char));
    	if (NULL == node)
    		return ERROR;
    	
    	node->data = data;
    
    	node->next = ls->head->next;
    	ls->head->next = node;
    	node->pre = ls->head;
    	if (NULL != node->next)
    	node->next->pre = node;
    	
    	return TRUE;
    }
    

    双链表的尾插

    BOOL Insert_Last(List *ls, Data data)
    {
    	if (NULL == ls)
    		return ERROR;
    	
    	
    	Node *tmp = ls->head;         // 头结点
    	while (tmp->next)
    	{
    		tmp = tmp->next;
    	}
    	
    	Node *node = (Node *)malloc(sizeof(Node)/sizeof(char));
    	if (NULL == node)
    		return ERROR;
    	
    	node->data = data;
    
    	node->next = NULL;
    	tmp->next = node;
    	node->pre = tmp;
    	
    	return TRUE;
    }
    

    双链表按任意位置插

    BOOL Insert_Pos(List *ls, int pos, Data data)
    {
    	if(NULL == ls|| pos<1)
    		return ERROR;
    	
    	Node *tmp = ls->head;
    	int i;
    	for (i = 0; i<pos-1; i++)
    	{
    		tmp = tmp->next;
    		if (tmp == NULL)  // 越界
    		{
    			printf ("长度越界: %d\n", pos);
    			return ERROR;
    		}
    	}
    	
    	Node *node = (Node *)malloc(sizeof(Node)/sizeof(char));
    	if (NULL == node)
    		return ERROR;
    	
    	node->data = data;
    
    
    	node->next = tmp->next; 		
    	tmp->next  = node;
    	if (node->next != NULL)
    		node->next->pre = node;
    	
    				
    	return TRUE;
    }
    
    

    双链表按位置删除

    BOOL Delete_Pos(List *ls, int pos)
    {
    	if(NULL == ls|| pos<1)
    		return ERROR;
    	
    	Node *tmp = ls->head;
    	int i;
    	for (i = 0; i<pos-1; i++)
    	{
    		tmp = tmp->next;
    		if (tmp == NULL || tmp->next == NULL)  // 越界
    		{
    			printf ("长度越界: %d\n", pos);
    			return ERROR;
    		}
    	}
    	
    	Node *p = tmp->next;
    	tmp->next = p->next;
    
    	if (NULL != p->next)
    		p->next->pre = tmp;
    	free(p);
    				
    	return TRUE;
    }
    

    双链表的逆序

    BOOL Reverse(List *ls)
    {
    	// NULL ==ls || NULL == ls->head    链表不存在
    	// NULL == ls->head->next           空链表
    	// NULL == ls->head->next->next     只有一个结点的链表
    	if (NULL == ls || NULL == ls->head || NULL == ls->head->next || NULL == ls->head->next->next)
    		return ERROR;
    	
    /*	Node *pre = ls->head->next;    // 第一个结点
    	Node *cur = pre->next;         // 第二个结点
    	Node *tmp;                     // 保存当前结点的下一个结点
    	
    	while (cur)
    	{
    		tmp = cur->next;
    		cur->next = pre;
    		
    		pre = cur;
    		cur = tmp;
    	}
    	
    	ls->head->next->next = NULL;	//将原来第一个结点的指针域指向NULL
    	ls->head->next = pre;			//将头结点的next指向最后一个元素*/
    
    	Node *cur = ls->head->next;
    	while(cur->next)//最后结点不交换
    	{
    		Node *tmp = cur->next;	//保存cur的next指针
    		cur->next = cur->pre;	//next和pre交换
    		cur->pre = tmp;			
    		cur = tmp;				//移动
    
    	}
    	
    	ls->head->next->next = NULL;//第一个元素nextNULL
    	ls->head->next = cur;
    	cur->next = cur->pre;	//手动交换
    	cur->pre = ls->head;
    
    	return TRUE;
    }
    

    双链表的销毁

    void Destroy(List *ls)
    {
    	if (NULL == ls)
    		return;
    	
    	Node *tmp = ls->head;
    	while (tmp->next)
    	{
    		Node *p = tmp->next;
    		tmp->next = p->next;
    		free(p);
    	}
    	
    	free(ls->head);
    	free(ls);
    }
    
    

    双向循环链表

    双向循环链表在双链表的基础上,将最后一个结点的尾指针重新指向头结点

    双向循环链表的创建

    List *ls = (List*)malloc(sizeof(List)/sizeof(char));
    	if (NULL == ls)
    		return NULL;
    	
    	// 创建头结点
    	ls->head = (Node*)malloc(sizeof(Node)/sizeof(char));
    	if(NULL == ls->head)
    	{
    		free(ls);
    		return NULL;
    	}
    	
    	ls->head->next = ls->head;   // 空链表
    	ls->head->pre  = ls->head;
    	
    	return ls;
    

    双向循环链表的头插

    	if (NULL == ls)
    		return ERROR;
    	
    	Node *node = (Node *)malloc(sizeof(Node)/sizeof(char));
    	if (NULL == node)
    		return ERROR;
    	
    	node->data = data;
    
    	node->next = ls->head->next;
    	ls->head->next = node;
    	node->pre = ls->head;
    	node->next->pre = node;
    	
    	return TRUE;
    

    双向循环链表的尾插

    BOOL Insert_Last(List *ls, Data data)
    {
    	if (NULL == ls)
    		return ERROR;
    	
    	
    	Node *tmp = ls->head;         // 头结点
    	while (tmp->next != ls->head)
    	{
    		tmp = tmp->next;
    	}
    	
    	Node *node = (Node *)malloc(sizeof(Node)/sizeof(char));
    	if (NULL == node)
    		return ERROR;
    	
    	node->data = data;
    
    	node->next = ls->head;
    	tmp->next = node;
    	node->pre = tmp;
    	ls->head->pre = node;
    	
    	return TRUE;
    }
    
    

    双向循环链表的按任意位置插

    BOOL Insert_Pos(List *ls, int pos, Data data)
    {
    	if(NULL == ls|| pos<1)
    		return ERROR;
    	
    	Node *tmp = ls->head;
    	int i;
    	for (i = 0; i<pos-1; i++)
    	{
    		tmp = tmp->next;
    		if (tmp == ls->head)  // 越界
    		{
    			printf ("长度越界: %d\n", pos);
    			return ERROR;
    		}
    	}
    	
    	Node *node = (Node *)malloc(sizeof(Node)/sizeof(char));
    	if (NULL == node)
    		return ERROR;
    	
    	node->data = data;
    
    
    	node->next = tmp->next; 		
    	tmp->next  = node;
    	node->next->pre = node;
    	
    				
    	return TRUE;
    }
    

    双向循环链表的按任意位置删除

    BOOL Delete_Pos(List *ls, int pos)
    {
    	if(NULL == ls|| pos<1)
    		return ERROR;
    	
    	Node *tmp = ls->head;
    	int i;
    	for (i = 0; i<pos-1; i++)
    	{
    		tmp = tmp->next;
    		if (tmp == NULL || tmp->next == NULL)  // 越界
    		{
    			printf ("长度越界: %d\n", pos);
    			return ERROR;
    		}
    	}
    	
    	Node *p = tmp->next;
    	tmp->next = p->next;
    
    	if (NULL != p->next)
    		p->next->pre = tmp;
    	free(p);
    				
    	return TRUE;
    }
    

    双向循环链表的逆序

    BOOL Reverse(List *ls)
    {
    	// NULL ==ls || NULL == ls->head    链表不存在
    	// NULL == ls->head->next           空链表
    	// NULL == ls->head->next->next     只有一个结点的链表
    	if (NULL == ls || NULL == ls->head || NULL == ls->head->next || NULL == ls->head->next->next)
    		return ERROR;
    	
    /*	Node *pre = ls->head->next;    // 第一个结点
    	Node *cur = pre->next;         // 第二个结点
    	Node *tmp;                     // 保存当前结点的下一个结点
    	
    	while (cur)
    	{
    		tmp = cur->next;
    		cur->next = pre;
    		
    		pre = cur;
    		cur = tmp;
    	}
    	
    	ls->head->next->next = NULL;	//将原来第一个结点的指针域指向NULL
    	ls->head->next = pre;			//将头结点的next指向最后一个元素*/
    
    	Node *cur = ls->head->next;
    	while(cur->next != ls->head)
    	{
    		Node *tmp = cur->next;	//保存cur的next指针
    		cur->next = cur->pre;	//next和pre交换
    		cur->pre = tmp;			
    		cur = tmp;				//移动
    
    	}
    	
    	cur->next = cur->pre;
    	cur->pre = ls->head;
    	ls->head->pre = ls->head->next;	//逆序
    	ls->head->next = cur;
    
    	return TRUE;
    }
    

    双向循环链表的销毁

    void Destroy(List *ls)
    {
    	if (NULL == ls)
    		return;
    	
    	Node *tmp = ls->head;
    	while (tmp->next != ls->head)
    	{
    		Node *p = tmp->next;
    		tmp->next = p->next;
    		free(p);
    	}
    	
    	free(ls->head);
    	free(ls);
    }
    
    展开全文
  • 文章目录前言1. 循环双链表2. 基本操作3....2. 基本操作操作名称操作说明InsertInHead(val_list)头插法创建循环双链表InsertInTail(val_list)尾插法创建循环双链表IsEmpty()判断循环双链表是否为空LengthL...

    文章目录

    前言

    1. 循环双链表

    2. 基本操作

    3. 代码实现前言

    本篇章主要介绍线性表中的循环双链表,并用Python实现其基本操作。

    1. 循环双链表

    循环双链表就是循环单链表和双链表的集合体了。

    f07e925127982b214c7896bf979d0174.png

    2. 基本操作

    操作名称

    操作说明

    InsertInHead(val_list)

    头插法创建循环双链表

    InsertInTail(val_list)

    尾插法创建循环双链表

    IsEmpty()

    判断循环双链表是否为空

    LengthList()

    返回循环双链表的长度

    TraverseList()

    打印出循环双链表里的数据元素

    InsertInPosition(pos, data)

    在指定位置插入

    SearchWithPosition(pos)

    按位置查找结点

    SearchWithVal(data)

    按值查找结点

    RemoveWithPosition(pos)

    移除指定位置的结点

    RemoveWithVal(data)

    移除指定值的结点

    3. 代码实现

    class CircularDoubleLinkList(object):

    def __init__(self):

    self.__head = DoubleLinkNode(None)

    self.__head.next = self.__head

    def InsertInHead(self, val_list):

    """

    头插法

    :param val_list:

    :return:

    """

    prehead = self.__head

    for val in val_list:

    new_node = DoubleLinkNode(val)

    if self.IsEmpty():

    prehead.next = new_node

    new_node.prior = prehead

    new_node.next = self.__head

    self.__head.prior = new_node

    else:

    new_node.next = prehead.next

    prehead.next.prior = new_node

    prehead.next = new_node

    new_node.prior = prehead

    def InsertInTail(self, val_list):

    """

    尾插法

    :param val_list:

    :return:

    """

    prehead = self.__head

    for val in val_list:

    new_node = DoubleLinkNode(val)

    prehead.next = new_node

    new_node.prior = prehead

    new_node.next = self.__head

    self.__head.prior = new_node

    prehead = prehead.next

    def IsEmpty(self):

    """

    判断循环双链表是否为空, 空表返回True

    :return:

    """

    if self.__head.next == self.__head:

    return True

    def LengthList(self):

    """

    返回循环双链表的长度

    :return:

    """

    prehead = self.__head

    count = 0

    if self.IsEmpty():

    return count

    while prehead.next != self.__head:

    count += 1

    prehead = prehead.next

    return count

    def TraverseList(self):

    """

    遍历循环双链表, 并打印

    :return:

    """

    prehead = self.__head

    if self.IsEmpty():

    print('链表为空!')

    return 0

    while prehead.next != self.__head:

    prehead = prehead.next

    print(prehead.data, end=' ')

    print('')

    def InsertInPosition(self, pos, data):

    """

    在某个位置插入

    :param pos: [1, LengthSingleLinkList + 1]

    :param data:

    :return:

    """

    prehead = self.__head

    new_node = DoubleLinkNode(data)

    if pos <= 0 or pos > self.LengthList() + 1:

    print('插入位置错误!')

    return 0

    count = 0

    while count < pos - 1:

    prehead = prehead.next

    count += 1

    if prehead.next != self.__head:

    new_node.next = prehead.next

    prehead.next.prior = new_node

    else:

    new_node.next = self.__head

    self.__head.prior = new_node

    new_node.prior = prehead

    prehead.next = new_node

    def SearchWithPosition(self, pos):

    """

    按位置查找元素

    :param pos: [1, LengthSingleLinkList]

    :return:

    """

    prehead = self.__head

    if pos <= 0 or pos > self.LengthList():

    print('位置错误!')

    return -1

    count = 0

    while count < pos:

    prehead = prehead.next

    count += 1

    data = prehead.data

    return data

    def SearchWithVal(self, data):

    """

    按值查找元素

    :param data:

    :return:

    """

    prehead = self.__head

    count = 0

    while prehead.next != self.__head:

    prehead = prehead.next

    count += 1

    if prehead.data == data:

    return count

    print('该节点不存在!')

    return -1

    def RemoveWithPosition(self, pos):

    """

    按位置移除元素

    :param pos: [1, LengthSingleLinkList]

    :return:

    """

    prehead = self.__head

    if pos <= 0 or pos > self.LengthList():

    print('位置错误!')

    return 0

    count = 0

    while count < pos - 1:

    prehead = prehead.next

    count += 1

    temp = prehead.next

    if temp.next == self.__head:

    prehead.next = self.__head

    self.__head.prior = prehead

    else:

    prehead.next = temp.next

    temp.next.prior = prehead

    del temp

    def RemoveWithVal(self, data):

    """

    按值移除元素

    :param data:

    :return:

    """

    prehead = self.__head

    while prehead.next != self.__head:

    prehead = prehead.next

    if prehead.data == data:

    if prehead.next == self.__head:

    prehead.prior.next = self.__head

    self.__head.prior = prehead.prior

    else:

    prehead.prior.next = prehead.next

    prehead.next.prior = prehead.prior

    return -1

    print('该节点不存在!')

    测试代码如下:

    from LinkList import CircularDoubleLinkList

    if __name__ == '__main__':

    l1 = CircularDoubleLinkList()

    print('头插法创建循环双链表l1: ', end='')

    l1.InsertInHead([1, 3, 5, 7])

    l1.TraverseList()

    l2 = CircularDoubleLinkList()

    print('尾插法创建循环双链表l2: ', end='')

    l2.InsertInTail([1, 3, 5, 7])

    l2.TraverseList()

    print('链表l2的长度为: %d' % l2.LengthList())

    print('在链表l2的第3个位置上插入值为2的节点: ', end='')

    l2.InsertInPosition(3, 2)

    l2.TraverseList()

    print('链表l2的第4个位置上的节点的值为: %d' % l2.SearchWithPosition(4))

    print('链表l2值为7的节点的位置为: %d' % l2.SearchWithVal(7))

    print('移除链表l2的第5个位置上的节点: ', end='')

    l2.RemoveWithPosition(5)

    l2.TraverseList()

    print('移除链表l2值为1的节点: ', end='')

    l2.RemoveWithVal(1)

    l2.TraverseList()

    运行结果如下:

    aea2b332c8b4d5c67a7b38e04bcab959.png

    文章来源: https://blog.csdn.net/qq_42730750/article/details/107869233

    展开全文
  • 双链表和循环双链表复习

    千次阅读 2018-08-10 08:40:32
    首先不管是单链表还是双链表或者循环双链表,都是为了提高访问效率,比如同样的插入操作,顺序表需要用数组移动元素,访问效率比较差,相反链表只需要移动指针,而且顺序表是有最大空间的,而链表没有。 双链表格式...
  • 文章目录循环链表循环单链表循环双链表静态链表说明 循环链表  循环链表一般包括循环单链表和循环双链表,如下图所示: 循环单链表   循环单链表与单链表的区别在于,表中最后一个结点的指针不是NULL,而改为...
  • 目录循环双链表循环双链表的操作插入头节点插入尾节点插入指定位置插入删除头节点删除尾节点删除指定位置删除遍历查找循环双链表的C语言实现 循环双链表 循环双链表 循环双链表的操作 插入 头节点插入 尾节点插入 ...
  • 基于java的循环双链表

    2015-12-22 22:40:15
    使用java语言编译循环双链表,有三个类,分别是一个接口类,一个循环双链表继承接口的实现类,一个循环双链表的测试类
  • 第二,大家在很多书上看到的是使用单链表实现队列,我这里将会使用带头结点尾结点的非循环双链表实现,虽然多维护了两个节点和指针域,但是在链表头尾进行插入删除的时候不需要遍历链表了,队列操作变得非常
  • 7循环双链表

    2020-10-10 19:59:08
    7循环双链表 数据结构持续总结ing //初始化、判空、//判断节点p是否为循环单链表的表尾结点 #include <stdio.h> #include <stdlib.h>//malloc,free函数库 typedef int ElemType;//int另命名 typedef ...
  • 循环双链表详解

    千次阅读 2019-03-20 10:59:56
    循环双链表创建以及排序 1. 创建双链表 完整代码如下 #include<stdio.h> #include<stdlib.h> typedef struct node { int data; struct node *nex; struct node *pre; }NODE; void...
  • 循环双向链表的实现

    2016-11-23 21:29:53
    本文主要介绍循环双向链表的实现,以及循环双向链表与双向链表之间的差异
  • /*** 循环双链表**@authorclarck**@param*/public class CirDoublyLinkedList implements LList{/*** 头节点*/public DLinkNodehead;/*** 默认构造方法,构造空循环双链表** 创建头结点,3个域值均为null*/pub...
  • 带头循环双链表

    2018-08-22 18:45:52
    带头循环双链表,顾名思义“带头”就是说你能知道头结点的位置,“循环”就是说这个链表是循环的,“双链表”就是说这个链表除了有一个指针指向下一个结点还有一个指针指向前一个结点 typedef int DataType; ...
  • 创建循环单链表和循环双链表 循环单链表 //初始化与一个循环链表 bool InitList(LinkList &L){ L=(LNode *)malloc(sizeof(LNode)); //分配一个头结点 if (L==NULL) //内存不足,分配失败 return false...
  • 循环双链表算法

    2020-04-11 21:44:21
    设一个带头结点的循环双链表 DL,结点的值可能重复。设 计一个算法输出 DL 所有元素的值,参数 d=0 时按照前驱方向输出,d=1 时按照 后继方向输出。 (记得那次作业里有一个写的很麻烦没啥意思好像就是这个) //创建...
  • 算法导论 循环双链表

    2015-09-18 10:21:26
    循环双链表1. 什么是循环双链表循环双链表:循环,即是首尾相连的链表。双链表,即是在原来单链表的基础上,使结点不单只能指向下一个结点,也能指向上一个结点。 2. 循环双链表的基本操作(伪代码) LIST-...
  • 删除循环双向链表中的第一个节点,有两种情况。在第一种情况下,要删除的节点是链表中存在的唯一节点。在这种情况下,条件head->next == head将为true,因此需要完全删除列表。通过将链表的头指针指定为null并...
  • 循环双链表教程(个人笔记)

    千次阅读 热门讨论 2021-03-13 22:54:40
    循环双链表教程(个人笔记) 前言 作为一个C语言初学者的我,用博客来存放我的笔记 循环双链表教程循环双链表教程(个人笔记)前言一、定义结构体二、创建空表三、插入方法1.尾插法2.选插法四、查找方法1.按位置查找2....
  • 题目:设计一个算法判断带头结点的循环双链表是否对称 分析: 简单分析,我们可以设置两个指针,pre和next,从头结点出发,进行比较,若pre与next所指值不同,则不对称,若pre和next指向了同一个节点 则该循环双...
  • 双链表、循环双链表

    2018-04-14 11:16:07
    //双向链表 #include&lt;iostream&gt; using namespace std; struct DNode { int data; DNode *prior, *next; }; typedef DNode DNode, *DLinkList; //初始化双向链表 void initDLink(DLinkLi...
  • 循环双链表--JAVA

    2017-07-21 13:15:20
    这一篇来写循环双链表循环双链表,包含两个关键字:双链表,循环。 先说双链表,双链表是在单链表的基础上加上一个指向前面的指针。较之单链表,双链表可以从任意位置进行遍历,而不需要每一次遍历都要从头开始。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,101
精华内容 4,440
关键字:

循环双链表