精华内容
下载资源
问答
  • 链表的添加和删除

    2013-03-16 17:40:40
    个人原创的链表处理函数代码,能够实现添加 删除等功能
  • 最近学习C语言的链表操作,看了很多例子,学习完成后我自己总结了一下,并写了比较完整的代码。下面是我写的代码代码的量可能有点大,请谅解。...包括两种情况,分为删除指定位置节点和删除指定数据所在节点...
    		最近学习C语言的链表操作,看了很多例子,学习完成后我自己总结了一下,并写了比较完整的代码。下面是我写的代码,代码的量可能有点大,请谅解。如果有错误或者不合适之处请指出。我用的开发环境是windows的VS。
    		在该代码中主要的内容有
    		** 
    		1 链表的创建。创建方法有头插法和尾插法
    		2 链表的增添。
    		3 链表的删除。包括两种情况,分为删除指定的位置节点和删除指定数据所在的节点
    		4 链表的修稿。包括两种情况,分为修改指定的位置节点和修改指定数据所在的节点
    		5 链表的释放。释放方法有两种,分为从头部释放和从尾部释放
    		**
    
    #include "stdafx.h"
    #include<stdbool.h>
    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    #include<stdarg.h>
    #define SIZE 20
    typedef struct mydata
    {
    	char *str = (char *)malloc(sizeof(char) * 20);
    	struct mydata *forward = NULL;
    	struct mydata *backward = NULL;
    }Node,*Mydata;
    char *GetInput(char *str);
    int Initializ(Mydata *head);
    int CreatFromHead(Mydata head);
    int OutPutLinkedListInforward(Mydata head);
    int OutPutLinkedListFromBackward(Mydata head);
    int AddAccordingToLocation(Mydata head,unsigned int location, char *str);//在指定的位置增加节点(前插)
    int AddAccordingToLocationUseAfter(Mydata head,unsigned int location, char *str);
    int DeletAccordingToLocation(Mydata head,unsigned int location);
    int DeletAccordingToStr(Mydata head, char *str);
    int ModificationAccordingToLocation(Mydata head,unsigned int location, char *str);
    int ModificationAccordingToStr(Mydata head, char *str,char *replacestr);
    int FreeFromBackward(Mydata head);
    int main()
    {
    	Mydata head;
    	int location = 1;
    	Initializ(&head);//初始化表头
    	CreatFromHead(head);//创建链表
    	OutPutLinkedListInforward(head);//输出最原始的链表(从前输出)
    	OutPutLinkedListFromBackward(head);//输出最原始的链表(从后输出)
    	AddAccordingToLocation(head, 1, "adcdefg");//在指定位置添加数据(前插)
    	puts("After add one node is:");
    	OutPutLinkedListInforward(head);//输出修改后的链表
    	AddAccordingToLocationUseAfter(head,1, "110");//在指定位置添加数据(后插)
    	puts("After add one node is:");
    	OutPutLinkedListInforward(head);//输出修改后的链表
    	puts("enter the location that you want to delet:");
    	scanf_s("%d", &location);
    	DeletAccordingToLocation(head, location);//删除指定位置的数据
    	puts("after deleting one node is:");
    	OutPutLinkedListInforward(head);//输出修改后的链表
    	puts("enter the string that you want to delet:");
    	getchar();
    	char *str1 = (char *)malloc(sizeof(char)*SIZE);
    	GetInput(str1);
    	DeletAccordingToStr(head,str1);//删除指定数据所在的节点
    	puts("After delete one node is:");
    	OutPutLinkedListInforward(head);//输出修改后的链表
    	puts("enter the location that you want to modification:");
    	scanf_s("%d", &location);
    	ModificationAccordingToLocation(head, location, "119");//修改指定位置的节点的数据为指定的数据
    	puts("After modificationing one node is:");
    	OutPutLinkedListInforward(head);//输出修改后的链表
    	puts("enter the str that you want to modification:");
    	getchar();
    	char *str2 = (char *)malloc(sizeof(char)*SIZE);
    	GetInput(str2);
    	puts("enter the new str that you want to interposition:");
    	char *str = (char *)malloc(sizeof(char)*SIZE);
    	GetInput(str);
    	ModificationAccordingToStr(head, str2,str);//修改指定数据所在的节点的数据为指定的数据
    	puts("After modificationing one node is:");
    	OutPutLinkedListInforward(head);//输出修改后的链表
    	FreeFromBackward(head);
    	system("pause");
        return 0;
    }
    char *GetInput(char *str)//得到所需的字符串
    {
    	char *find;
    	char *start = fgets(str, SIZE, stdin);
    	if (start)
    	{
    		find = strchr(start, '\n');
    		if (find)
    			*find = '\0';
    		else
    			while (getchar() != '\n');
    	}
    	return start;
    
    }
    int Initializ(Mydata *head)//初始化表头
    {
    	(*head) = (Mydata)malloc(sizeof(Node));
    	if ((*head) == NULL)
    		return 0;
    	else
    	{
    		(*head)->forward = NULL;
    		(*head)->backward = NULL;
    		return 1;
    	}
    }
    int CreatFromHead(Mydata head)//创建链表(头插法)
    {
    	if (head == NULL)
    	{
    		puts("there is no header.");
    		return 0;
    	}
    	else
    	{
    		puts("Please enter one number to start:(enter \"Q\" to quit)");
    		while (getchar()!='Q')
    		{
    			while (getchar() != '\n');
    			Mydata now = (Mydata)malloc(sizeof(Node));
    			if (now == NULL)
    			{
    				puts("mamery allocation failed.");
    				return 0;
    			}
    			else
    			{
    				puts("Please enter one string:");
    				char *str = (char *)malloc(sizeof(char)*SIZE);//创建新的节点
    				now->str = GetInput(str);
    				now->forward = head->forward;
    				if (head->backward == NULL)//将头节点的backward指向最后一个节点
    				{
    					head->backward = now;
    					now->forward = NULL;
    				}
    				if (head->forward != NULL)//如果链表不是空的将上个节点的backward指向新的节点
    					head->forward->backward = now;
    				head->forward = now;
    				now->backward = head;
    				puts("Please enter one number to continue:(enter \"Q\" to quit)");
    			}
    		}
    		return 1;
    	}
    }
    int CreatFromTail(Mydata tail)//创建链表(尾插法)
    {
    	Mydata replace = tail;
    	puts("Please enter one number to start:(enter \"Q\" to quit)");
    	while (getchar() != 'Q')
    	{
    		while (getchar() != '\n');
    		Mydata now = (Mydata)malloc(sizeof(Node));
    		if (now == NULL)
    			return 0;
    		else
    		{
    			puts("Please enter  one string :");
    			char *str = (char *)malloc(sizeof(char) * 20);
    			now->str = GetInput(str);
    			replace->forward = now;
    			now->backward = replace;
    			now->forward = NULL;
    			replace = now;
    			puts("Please enter one number to contnue:");
    		}
    		
    	}
    	tail->backward = replace;
    	return 1;
    }
    int OutPutLinkedListInforward(Mydata head)//从头部进行输出
    {
    	Mydata replace = head->forward;
    	int location = 1;
    	if (replace == NULL)
    	{
    		puts("there is nothing.");
    		return 0;
    	}
    	else
    	{
    		puts("Output according to from forward to backward is:");
    		while (true)
    		{
    			printf("the %-2d is %s\n", location, replace->str);
    			replace = replace->forward;
    			if (replace == NULL)
    				break;
    			location++;
    		}
    	}
    	return location;
    }
    int OutPutLinkedListFromBackward(Mydata head)//从尾部进行输出
    {
    	Mydata  replace = head->backward;
    	int location = 1;
    	if (replace == NULL)
    		return 0;
    	else
    	{
    		puts("Output according from backward to forward is:");
    		while (true)
    		{
    			printf("the %-2d is %s\n", location, replace->str);
    			replace = replace->backward;
    			if (replace == head)//如果当前节点和头节点相同,跳出循环,结束
    				break;
    			location++;
    		}
    	}
    	return 1;
    }
    int AmountOfNode(Mydata head)//计算链表中节点的个数
    {
    	Mydata replace = head->forward;
    	if (replace == NULL || head == NULL)
    		return 0;
    	else
    	{
    		int amount = 1;
    		while (true)
    		{
    			replace = replace->forward;
    			if (replace == NULL)
    				break;
    			amount++;
    		}
    		return amount;
    	}
    }
    int FreeFromBackward(Mydata head)//从尾部进行资源释放
    {
    	Mydata replace;
    	Mydata replaceHead = head;
    	if (head == NULL)
    		return 0;
    	else
    	{
    		head = head->backward;
    		while (true)
    		{
    			replace = head;
    			head = head->backward;
    			free(replace);
    			if (head == replaceHead)//如果当前节点和头节点相同,跳出循环,结束
    				break;
    		}
    	}
    	return 1;
    }
    int AddAccordingToLocation(Mydata head,unsigned int location,char *str)//在指定的位置增加节点(前插)
    {
    	if (location == 0)
    	{
    		puts("enter location(location must greater then 0) is error.");
    		return 0;
    	}
    	else
    	{
    		Mydata replace = head->forward;
    		if (head == NULL)
    		{
    			puts("there is no header.");
    			return 0;
    		}
    		else
    		{
    			if (location > AmountOfNode(head) + 1)//允许插入链表的末尾
    			{
    				puts("location out of range");
    				return 0;
    			}
    			else
    			{
    				int i = 1;
    				Mydata previous = NULL;
    				while (i++ != location)//找到目标节点,之后在该节点的前面插入新的节点
    				{
    					previous = replace;
    					replace = replace->forward;
    				}
    				Mydata now = (Mydata)malloc(sizeof(Node));
    				if (now == NULL)//如果内存分配失败,结束
    				{
    					puts("Memory allocation failed.");
    					return 0;
    				}
    				else
    				{
    
    					now->str = str;						//前插法
    					now->forward = replace;
    					if (replace != NULL)
    					{
    						now->backward = replace->backward;
    						replace->backward->forward = now;
    						replace->backward = now;
    					}
    					else
    					{
    						head->backward = now;
    						now->backward = previous;
    						previous->forward = now;
    					}
    					return 1;
    				}
    			}
    		}
    	}
    }
    int AddAccordingToLocationUseAfter(Mydata head,unsigned int location, char *str)//在指定的位置增加节点(后插)
    {
    	if (location == 0)
    	{
    		puts("enter location(location must greater then 0) is error.");
    		return 0;
    	}
    	else
    	{
    		Mydata replace = head;
    		if (head == NULL)
    		{
    			puts("there is no header.");
    			return 0;
    		}
    		else
    		{
    			if (location > AmountOfNode(head) + 1)//同样允许在链表的末尾插入节点
    			{
    				puts("location out of range");
    				return 0;
    			}
    			else
    			{
    				int i = 0;
    				while (i++<location - 1)//找到目标节点的前一个节点
    					replace = replace->forward;
    				Mydata now = (Mydata)malloc(sizeof(Node));
    				if (now == NULL)
    				{
    					puts("Memory allocation failed.");
    					return 0;
    				}
    				else
    				{
    					now->str = str;
    					now->backward = replace;
    					now->forward = replace->forward;
    					if (replace->forward != NULL)
    						replace->forward->backward = now;
    					else
    						head->backward = now;
    					replace->forward = now;
    					return 1;
    				}
    			}
    		}
    	}
    }
    int DeletAccordingToLocation(Mydata head,unsigned int location)//在指定的位置删除节点
    {
    	if (location == 0)
    	{
    		puts("enter location(location must greater then 0) is error.");
    		return 0;
    	}
    	else
    	{
    		Mydata replace = head;
    		if (replace == NULL)
    		{
    			puts("the Linked list is NULL.");
    			return 0;
    		}
    		else
    		{
    			if (location>AmountOfNode(head))
    			{
    				puts("location out of range.");
    				return 0;
    			}
    			int i = 0;
    			while (i++ != location)//找到目标节点
    			{
    				replace = replace->forward;
    			}
    			replace->backward->forward = replace->forward;
    			if (replace->forward != NULL)
    				replace->forward->backward = replace->backward;
    			else
    			{
    				head->backward = replace->backward;
    			}
    			if (head->backward == head)
    			{
    				puts("now the Linked list is NULL.");
    				head->forward = NULL;
    				head->backward = NULL;
    			}
    			free(replace);
    			return 1;
    		}
    	}
    }
    int DeletAccordingToStr(Mydata head, char *str)//删除指定数据所在的节点
    {
    	Mydata replace = head->forward;
    	if (replace == NULL)
    	{
    		puts("the Linked list is NULL.");
    		return 0;
    	}
    	else
    	{
    		while (true)
    		{
    			if (replace==NULL || strcmp(replace->str, str) == 0)//找到目标数据或者循环到链表结尾
    				break;
    			replace = replace->forward;
    		}
    		if (replace == NULL)//如果没找到 ,退出,结束
    		{
    			puts("no one is mathing.");
    			return 0;
    		}
    		else//如果找到目标字符串
    		{
    			replace->backward->forward = replace->forward;
    			if (replace->forward != NULL)
    				replace->forward->backward = replace->backward;
    			else
    			{
    				head->backward = replace->backward;
    			}
    			if (head->forward == head)//如果删除后链表是空的,将表头重新初始化
    			{
    				puts("now the Linked list is NULL.");
    				head->forward = NULL;
    				head->backward = NULL;
    			}
    			free(replace);
    			return 1;
    		}
    	}
    }
    int ModificationAccordingToLocation(Mydata head,unsigned int location, char *str)//修改指定位置的节点的数据
    {
    	if (location == 0)
    	{
    		puts("enter location(location must greater then 0) is error.");
    		return 0;
    	}
    	else
    	{
    		Mydata replace = head->forward;
    		if (replace == NULL)
    		{
    			puts("the Linked list is NULL.");
    			return 0;
    		}
    		else
    		{
    			if (location > AmountOfNode(head))
    			{
    				puts("location out of range.");
    				return 0;
    			}
    			else
    			{
    				int i = 1;
    				while (i++ < location)//找到目标节点
    				{
    					replace = replace->forward;
    				}
    				replace->str = str;//修改数据为指定数据
    				return 1;
    			}			
    		}
    	}
    }
    int ModificationAccordingToStr(Mydata head, char *str,char *replacestr)//修改指定数据的节点的数据
    {
    
    	Mydata replace = head->forward;
    	if (replace == NULL)
    	{
    		puts("the Linked list is NULL.");
    		return 0;
    	}
    	else
    	{
    		while (true)
    		{
    			if ( replace==NULL|| strcmp(replace->str, str) == 0)
    				break;
    			replace = replace->forward;
    		}
    		if (replace == NULL)
    		{
    			puts("no one is maching.");
    			return 0;
    		}
    		else
    		{
    			replace->str = replacestr;
    			return 1;
    		}
    	}
    }
    
    以上就是我的代码,代码量比较大 ,但是使用起来比较对用户比较友好。
    
    展开全文
  • 双向链表添加节点和删除结点

    千次阅读 2018-03-26 14:45:48
    以下是添加头节点的代码:void CList::AddHead(DATA data) { SNode*p = new SNode; p-&gt;data = data; if (m_pHead) { m_pHead-&gt;pPrev = p; } else { m_pTail = p;//链表为空第一次添加节点...

    以下是添加头节点的代码:

    void CList::AddHead(DATA data)
    {
    	SNode*p = new SNode;
    	p->data = data;
    	if (m_pHead)
    	{
    		m_pHead->pPrev = p;
    	}
    	else {
    		m_pTail = p;//链表为空第一次添加节点时候才会执行这一步
    	}
    	p->pPrev = nullptr;
    	p->pNext = m_pHead;
    	m_pHead = p;
    	++m_nCount;
    
    }

    以下是添加尾节点的代码:

    void CList::AddTail(DATA data)
    {
    	SNode*p = new SNode;
    	p->data = data;
    	if (m_pTail)
    	{
    		m_pTail->pNext = p;
    	}
    	else {
    		m_pHead = p;//链表为空第一次添加节点时候才会执行这一步
    	}
    	p->pPrev = m_pTail;
    	p->pNext = nullptr;
    	m_pTail = p;
    	++m_nCount;
    }

    以下是删除结点(代码多的是蠢办法,代码少的是大牛的代码):

    //蠢办法
    void CList::RemoveAt(POSITION p)
    {
    	if (m_nCount == 0)
    	{
    		cout << "链表里没有数据" << endl;
    		return;
    	}
    	else if (m_nCount == 1 && (SNode*)p == m_pHead)//要删除的节点是头节点(尾节点)且链表里只有这一个
    	{
    		if (((SNode*)p) == m_pHead)
    		{
    			delete m_pHead;
    			m_pHead = m_pTail = NULL;
    			m_nCount = 0;
    		}
    		else { cout << "链表里没有要删除的数据" << endl; }
    	}
    	else if (m_nCount>1 && (SNode*)p==m_pHead)
    	{
    			m_pHead->pNext->pPrev = NULL;
    			SNode*pSNod = m_pHead;
    			m_pHead = m_pHead->pNext;
    			delete pSNod;
    	}
    	else if (m_nCount>1 && (SNode*)p == m_pTail)
    	{
    			m_pTail->pPrev->pNext = NULL;
    			SNode*pSNod = m_pTail;
    			m_pTail = m_pTail->pPrev;
    			delete pSNod;
    	}
    	else {
    		POSITION pos = GetHeadPosition();
    		while (pos)
    		{
    			if (pos == p)
    			{
    				((SNode*)pos)->pPrev->pNext = ((SNode*)pos)->pNext;
    				((SNode*)pos)->pNext->pPrev = ((SNode*)pos)->pPrev;
    				delete (SNode*)pos;
    				break;
    			}
    			GetNext(pos);
    		}
    		if(!pos)
    			cout<< "链表里没有要删除的数据" << endl;
    	}
    }
    
    //大牛的代码
    void CList::RemoveAt(POSITION pos)
    {
    	SNode*p = (SNode*)pos;
    	if (m_pHead == p)
    		m_pHead=m_pHead->pNext;//如果删除的是头节点,就把m_pHead指向下一个结点
    	else 
    		p->pPrev->pNext = p->pNext; //否则前一个结点指向后一个结点
    
    	if (m_pTail == p)
    		m_pTail = m_pTail->pPrev;//如果删除的是尾节点,就把m_pTail指向前一个结点
    	else
    		p->pNext->pPrev = p->pPrev;//否则后一个结点指向前一个结点
    
    	delete p;
    	--m_nCount;
    }
    


    展开全文
  • 输入三个数:1、2、3,然后把2删除了并且输出删除的链表,然后添加一个数10,并且输出添加的链表 其中需要注意!!! 刚刚发现,head=new node;这样话不能把head->next为NULL,而当head=new node();时...

    输入三个数:1、2、3,然后把2删除了并且输出删除后的链表,然后添加一个数10,并且输出添加后的链表

    其中需要注意!!!

    刚刚发现的,head=new node;这样的话不能把head->next为NULL,而当head=new node();时,head->next就为NULL了

     

    程序代码:

    #include<stdio.h>
    struct data{
    	int note;
    	data *next;
    };
    
    int main()
    {
    	int i;
    	data *p,*head,*q,*r;
    	p=new data;//申请一个空间
    	q=new data;
    	head=new data;
    	head->next=NULL;
    	p=head;
    	for(i=0;i<3;i++)
    	{
    		r=new data;//每用一次都要申请一次空间
    		scanf("%d",&r->note);
    		p->next=r;
    		p=p->next;
    	}
    	p->next=NULL;
    	p=head;
    	while(p!=NULL)//删除操作
    	{
    		if(p->next->note==2)
    		{
    			q=p;
    			q->next=q->next->next;
    			break;
    		}
    		p=p->next;
    	}
    	p=head->next;
    	while(p!=NULL)
    	{
    		printf("%d\n",p->note);
    		p=p->next;
    	}
    
    
    	printf("\n");
    	r=new data;
    	r->note=10;
    	r->next=NULL;
    	p=head;
    	while(p!=NULL)//添加操作
    	{
    		if(p->note==1)
    		{
    			r->next=p->next;
    			p->next=r;
    			break;
    		}
    		p=p->next;
    	}
    	p=head->next;
    	while(p!=NULL)
    	{
    		printf("%d\n",p->note);
    		p=p->next;
    	}
    	return 0;	
    }
    

    单链表的删除:

    #include<stdio.h>
    #include<stdlib.h>
    #include<algorithm>
    using namespace std;
    
    struct node{
        int data;
        struct node *next;
    };
    
    int main()
    {
        node *q,*p,*head;
        int n,i;
        head=new node;//也可以head=(node*)malloc(sizeof(node));
        head->next=NULL;//建立有头单链表
        scanf("%d",&n);
        q=new node;
        q=head;
        for(i=0;i<n;i++)
        {
            p=new node;
            scanf("%d",&p->data);
            p->next=NULL;
            q->next=p;
            q=p;
        }
        p=new node;
        scanf("%d",&p->data);
        p->next=NULL;
    
        q=head;
        while(q!=NULL)
        {
            if(q->next==NULL||q->next->data>p->data)
            {
                p->next=q->next;
                q->next=p;
                break;
            }
            q=q->next;
        }
        q=head->next;
        while(q!=NULL)
        {
            printf("%d ",q->data);
            q=q->next;
        }
        printf("\n");
        return 0;
    }
    

     

    展开全文
  • 分析双向链表的遍历,添加,删除的操作思路 1、遍历方法单链表一样,只是可以向前,也可以向后查找 2、添加操作(默认添加到...比如要删除的节点为temp,删除代码为: Temp.pre.next = temp.next Temp.next.pre = t

    分析双向链表的遍历,添加,删除的操作思路

    1、遍历方法和单链表一样,只是可以向前,也可以向后查找

    2、添加操作(默认添加到双向链表的最后
    (1)先找到双向链表的最后一个节点
    (2)temp.next = newHeroNode; hewHeroNode.pre = temp
    3、修改操作思路和原来的单向链表一样

    4、删除操作,因为是双向链表,我们可以实现自我删除某个节点
    比如要删除的节点为temp,删除代码为:

      Temp.pre.next = temp.next
      Temp.next.pre = temp.pre
    

    代码:

    package com.suanfa;
    
    public class DoubleLinkListDemo {
    
    	public static void main(String[] args) {
    		// 测试一下
    		System.out.println("双向链表的测试");
    		// 先创建节点
    		HeroNode2 hero1 = new HeroNode2(1, "宋江", "及时雨");
    		HeroNode2 hero2 = new HeroNode2(2, "卢俊义", "玉麒麟");
    		HeroNode2 hero3 = new HeroNode2(3, "吴用", "智多星");
    		HeroNode2 hero4 = new HeroNode2(4, "林冲", "豹子头");
    		//创建双向链表对象
    		DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
    		doubleLinkedList.add(hero1);
    		doubleLinkedList.add(hero2);
    		doubleLinkedList.add(hero3);
    		doubleLinkedList.add(hero4);
    		//doubleLinkedList.showList();
    		
    		//修改测试
    		HeroNode2 newnode = new HeroNode2(4, "修改了", "我也改了");
    		doubleLinkedList.update(newnode);
    		doubleLinkedList.showList();
    		
    		//删除测试
    		//doubleLinkedList.delete(4);
    		//doubleLinkedList.showList();
    		
    		
    
    	}
    
    }
    
    //创建双向链表的类
    class DoubleLinkedList {
    	// 先初始化一个头结点,头节点不要动,且不存放具体数据
    	private HeroNode2 head = new HeroNode2(0, "", "");
    
    	/*
    	 * 函数:添加节点到单向链表 思路:当不考虑编号的顺序时 找到当前的链表的最后一个节点,将最后节点的next指向新的节点
    	 */
    	public HeroNode2 getHead() {
    		return head;
    	}
    
    	// 遍历双向链表的方法
    	public void showList() {
    		// 判断链表是否为空
    		if (head.next == null) {
    			System.out.println("链表为空");
    			return;
    		}
    		// 因为head头节点不能动,我们需要一个辅助遍历temp
    		HeroNode2 temp = head.next;
    		while (true) {
    			// 判断是否到链表最后
    			if (temp == null) {
    				break;
    			}
    			// 输出节点信息
    			System.out.println(temp.toString());
    			// 将temp后移,一定注意
    			temp = temp.next;
    		}
    
    	}
    
    	// 添加一个节点到链表的最后
    	public void add(HeroNode2 heroNode) {
    
    		// 因为head头节点不能动,我们需要一个辅助变量temp
    		HeroNode2 temp = head;
    		// 遍历链表,找到最后
    		while (true) {
    			// 找到的链表的最后
    			if (temp.next == null) {
    				break;// 弹出后就改变next值
    			}
    			// 如果没找到最后,就将temp后移
    			temp = temp.next;
    		}
    		// 当while循环结束时,temp就指向了链表的最后
    		// 形成一个双向链表
    		temp.next = heroNode;
    		heroNode.pre = temp;
    	}
    
    	// 修改一个节点的内容,可以看到双向链表修改和单向链表一样,只是节点的类型改成HeroNode2
    	// 修改节点的信息,根据no修改除no之外的节点信息,no是不能改变的
    	// 根据heroNode的no来修改
    	public void update(HeroNode2 heroNode) {
    		if (head.next == null) {
    			System.out.println("链表为空");
    			return;
    		}
    		// 需要找到要修改的节点
    		// 先定义一个辅助节点
    		HeroNode2 temp = head.next; // √ 这里改成temp = head,结果会有什么变化?为什么没有变化
    		boolean flag = false;
    		while (true) {
    			if (temp == null) {
    				break;// 链表遍历
    			}
    			if (temp.no == heroNode.no) {
    				flag = true;// 说明找到这个编号为no的节点了
    				break;
    			}
    			temp = temp.next;
    		}
    		// 根据flag判断是否找到修改的节点
    		if (flag) {
    			temp.name = heroNode.name;
    			temp.nickname = heroNode.nickname;
    		} else {
    			System.out.println("没有找到编号等于这个的节点,不能修改");
    		}
    
    	}
    
    	// 从双向链表中删除一个节点
    	// 对于双向链表,我们直接找到需要删除的节点,找到之后自我删除就可
    	public void delete(int no) {
    
    		if (head.next == null) {
    			System.out.println("链表为空,无法删除");
    			return;
    		}
    		HeroNode2 temp = head;
    		boolean flag = false;
    		while (true) {
    			if (temp.no == no) {
    				flag = true;
    				break;
    			} else if (temp.next == null) {
    
    				break;
    			}
    			temp = temp.next;
    		}
    		if (flag) {
    			// 删除核心代码
    			temp.pre.next = temp.next;
    			// 这里代码有问题,删除的节点可能是最后一个
    			// 如果是最后一个节点,就不要执行下面这句话,否则空指针异常
    			if (temp.next != null) {
    				temp.next.pre = temp.pre;
    			}
    		} else {
    			System.out.println("不存在该节点,无法删除");
    		}
    
    	}
    
    }
    
    //定义一个HereoNode
    class HeroNode2 {
    	public int no;
    	public String name;
    	public String nickname;
    	public HeroNode2 next;// 指向下一节点,默认为null
    	public HeroNode2 pre;// 指向前一个节点,默认为null
    
    	// 定义构造器
    	public HeroNode2(int hNo, String Hname, String Hnickname) {
    		this.no = hNo;
    		this.name = Hname;
    		this.nickname = Hnickname;
    
    	}
    
    	// 为了显示方便,重写tostring
    	@Override
    	public String toString() {
    		return "HeroNode [no=" + no + ", name=" + name + ", nickname=" + nickname + "]";
    	}
    }
    
    展开全文
  • 双向链表 1.双线链表的定义和引入 引入: 单链表的缺点: (1)单向链表查找的方向只能是一个方向,而双向链表可以双向查找 (2)单向链表不能自我删除,...注意:在执行添加和删除操作时要判断当前结点是否为最后一个结点
  • 二、双链表的添加原理 三、双链表的删除原理 四、设计双链表+实现代码 关于我 一、双链表的基本原理 我们在前面的单链表的基本原理实战中介绍了单链表。 单链接列表中的结点具有 val 字段,以及用于顺序链接结点...
  • 如题,若只是将链表指针作为参数传递。代码如下: struct ListNode { int m_Value; ListNode* m_Next; }; void AddToTail(ListNode *pHead,int value) { ListNode *newNode = new ListNode(); newNode->m_...
  • 链表是一种最常用的数据结构,其他的...最后一个节点的Next指针指向NULL,有的情况下,还为链表添加一个头节点,可以防止在删除链表的第一个元素时,丢失链表,如下图所示: 对链表的操作通常是创建一个链表,...
  • 双向循环链表特点:一个节点分为3部分,上节点(preNode)、下节点(nextNode) nodeData(当前节点数据) 节点代码 //创建一个节点类 class MyNode{ public Object obj; //当前节点节点元素 public MyNode nextNode;...
  • 一、在双向链表的尾部添加节点数据的思路分析示意图 二、删除双向链表节点数据的思路分析示意图 三、双向链表(Double Linked List)的修改、删除、查询及在双向链表尾部添加节点的代码示例 1、定义一个人员节点类...
  • 目录一、单链表添加节点数据的方式二、在链表的尾部添加节点数据的思路分析示意图三、在链表的尾部添加节点数据代码示例 一、单链表添加节点数据的方式 添加节点数据时,直接添加链表的尾部 根据节点数据的编号...
  • 链表的按条件删除

    2017-04-04 22:24:54
    链表的建立和各种操作建立在单个删除和单个添加的函数之上,一般来说只要写好了这两个基本的函数,其他的函数只要判断好添加和删除的条件再调用这两个基本的函数就好了。 除此之外,链表的内存问题依旧要注意…...
  • 双向链表比单项链表多了一个指向...还有一个区别是在有序添加数据时向尾节点添加数据链表中间添加数据在单向链表中时相同操作,在双向链表中必须加以区分。 代码如下: ```java package linkedlist; public ...
  • 链表的情况单链表类似,只是增加了一个前置而已。 ,不多说,直接看代码; // DoubleLink.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include using namespace std; struct ...
  • 链表的实现 基本概念 每一个节点都存储上一个下一个节点的指针 实现思路 创建一个节点结构体 每个节点都有上节点指针与下节点指针 每个节点都有一个key => value 创建一个链表结构体 链表容量大小属性 链表大小...
  • 有头链表,链表的添加和删除元素时,情况是相同的,除了初始化和销毁需要传入头指针的内容外,其他时候都不需要传入, 无头链表的话在面试中较多,除过头插,头删外,和有头链表的操作差别不大。 2.话不多说,贴上...
  • 一、双向链表(Double Linked List)的修改、删除、查询及按编号顺序添加节点到双向链表的代码示例 1、定义一个人员节点类,每一个PersonNode对象就是一个节点 package ...
  • 剑指Offer学习总结-链表添加尾结点-删除结点 本系列为剑指Offer学习总结,主要是代码案例分析实现: 书籍链接:http://product.dangdang.com/24242724.html 原作者博客:...
  • 在上一次了解了单链表的代码实现,以及对...双向链表的遍历,添加,修改,删除的操作思路分析: 1)遍历:单链表一样,只是可以向前,也可以向后查找。 2)添加(默认添加到双向链表的最后。)  步骤:先找到双链
  • 给出一个链表和一个整数 num,输出删除链表中节点值等于 num 节点之后的链表。 输入描述: 第一行一个整数 n,n 表示单链表节点数量。 第二行 n 个整数表示单链表各个节点值。 第三行一个整数 num。 输出描述...
  • 文章目录一、单链表1.1 链表介绍1.2 单链表的应用实例1.2.1 定义链表的节点1.2.2 添加节点(1)直接添加到尾部(2)根据某个条件插入到指定位置1.2.3 显示(遍历)链表1.2.4 修改节点1.2.5 删除节点1.2.6 测试代码...
  • 顺序表每个数据元素包括学号、姓名、性别、出生年月、是否党员、手机号码、家庭住址、成绩链表的头指针;成绩链表每个结点的数据域包括课程名与成绩。 结构体定义:学生信息 ``` typedef struct snode { char No...
  • 以下代码包括了我能想到的链表基本功能 1:建立一个男生链表和女生链表,包含姓名年龄 2:查看链表成员 3:二个链表相连 4:成员按年龄大小排序 5:寻找指定年龄最相近成员 6:删除成员 7:添加成员 ...
  • 双向链表的特点就是节点与节点之间相互连接,相比单项链表而言,它能够任意位置对节点进行添加和删除操作,能够快捷地找到一个节点的上一个或下一个节点。 双向链表的实现 我们逐一开始实现以上内容。 实现链表...
  • 单向链表的时间复杂度 在单向链表原理和实现中已经和动态数组相比对比并分析了单向链表的时间复杂度: ...因为对节点的添加和删除操作需要查找对于index的节点,首先分析以下查找节点的代码: - (JKRLinkedListNode...
  • 本题,关键是要考虑有可能第一个节点第二个结点就重复,所以需要先添加一个头结点,后续判断可以加入 pre 指针表示前驱,last 指针表示工作指针负责往后搜索 二、代码 public class Test_14 { public
  • 在一个排序的链表中,存在重复结点,请删除链表中重复结点,重复结点不保留,返回链表头指针。 例如,链表1->2->3->3->4->4->5 处理后为 1->2->5 非递归的代码思路: 首先添加一个...
  • Java新手,现在在学习链表,发现链表的插入和删除操作不能很好的掌握,不参考代码不知道先修改哪一个reference,再比如...所以请教大家添加和删除连接点有什么通用的原则吗?怎样才能灵活的掌握各个连接点引用的修改?
  • 单链表的添加每次都在链表尾部插入元素,所以在添加时需要遍历链表找到尾部节点,将其尾节点的next指针指向被添加的元素。删除元素时需要找到被删除节点的前驱节点,使其指向被删除元素的后继节点。 代码: public ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 436
精华内容 174
关键字:

链表的添加和删除代码