数据结构之链表构建及应用

最新推荐文章于 2021-12-01 19:46:00 发布
最新推荐文章于 2021-12-01 19:46:00 发布
阅读量407 收藏
点赞数 1
分类专栏： java数据结构与算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sdshdutx/article/details/102468929
版权

单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。其存储的各节点不一定连续，链表中的数据是以结点来表示的，每个结点的构成:元素(数据元素的映象) + 指针(指示后继元素存储位置)，next指向下一个节点
1.定义单链

package List;
//链节点，有数据域和指针域构成
public class Node {
   public long data; //数据域
   public Node next; //指针域
   
   public Node(long value) {
	   this.data = value;
   }
   public void display() {
	   System.out.print(data+" ");
   }
}

2.链表实现

package List;
//链表，
public class Linklist {
     private Node first;// 首个链接点，相当于车头
     public Linklist() {
    	 first = null; //其链默认指向null
     }
     //在头节点前插入一个节点
     public void insertfirst(long value) {
    	 Node curr = new Node(value);
    	 curr.next = first;  //插入节点指向首节点指向的节点
    	 first = curr;       //首节点更新
     }
     //在头节点后删除一个节点
    public Node removefirst() {
    	Node temp = first;  //定义当前节点
    	first = temp.next;  //直接跳过first.next,从而指向第三个节点
    	return temp;
    }
    //显示链表
    public void display1() {
    	Node curr = first;
    	while(curr != null) //判断当前有元素存在
    	{
    		curr.display();  //调用Node里面的显示方法
    		curr = curr.next;//继续遍历下个节点
    	}
    	System.out.println();
    }
    //查找链节点
    public  Node  find(long value) {
    	Node curr = first;
    	while(curr.data!=value) {
    		if(curr.next==null) {
    			return null;
    		}
    		curr = curr.next;
    	}
    	return curr;		
    }
    //删除节点
    public Node delete(long value) {
    	Node curr = first;
    	Node prev = first;
    	while(curr.data!=value) {
    		if(curr.next==null) {
    			return null;
    		}
    		prev = curr;     //之前的要指向当前的链接点
    		curr = curr.next;//当前的链接点要指向下一个
    		if(curr==first) //判断删除节点是否为首节点
    		{
    			first = first.next;
    			}
    		else {
    				prev.next = curr.next; //删除当前的节点prev(prev.next)》curr(curr.next)》node
    			}
    	}
    	return curr;
    }
}

3.测试代码

package List;
public class TestLinklist {
  public static void main(String[] args) {
	Linklist l1 = new Linklist();
	l1.insertfirst(25);
	l1.insertfirst(36);
	l1.insertfirst(18);
	l1.insertfirst(43);
	l1.display1();
	l1.removefirst();
	l1.display1();
	//查找某个值
	Node t1 = l1.find(36);
	t1.display();
	System.out.println();
	//删除某个值
	Node t2 = l1.delete(36);
	t2.display();
	System.out.println();
	l1.display1();
}
}

4.写在一起便于阅读
这里构建水浒传里面的英雄，参数列表：排名，名字，昵称
通过创建节点类属性来管理节点，创建链表属性来构建链表

package List;
public class singlelinklist {
	public static void main(String[] args) {
		HeroNode hero1 = new HeroNode(1,"宋江","及时雨");
		HeroNode hero2 = new HeroNode(2,"卢俊义","玉麒麟");
		HeroNode hero3 = new HeroNode(3,"吴用","智多星");
		HeroNode hero4 = new HeroNode(4,"林冲","豹子头");
		HeroNode hero5 = new HeroNode(5,"史进","九纹龙");
		//创建单链表
		Singlelist st =new Singlelist();
		st.add(hero1); //添加节点数据
		st.add(hero2);
		st.add(hero3);
		st.add(hero4);
		st.add(hero5);
		st.show(); //显示数据
		
	}
	
}
//创建单链表属性
class Singlelist{
	//初始化一个头节点，好在后部添加数据
	HeroNode head = new HeroNode(0,"","");
	//添加节点方法
	public void add(HeroNode hero) {
		//要找到链尾，向其添加数据，然后将其next指向下一个节点
		HeroNode temp = head; //指向了head
		while(true) {
			//找到链表的最后
			if(temp.next==null) {
				break;//找到了最后节点结束
			}
			temp = temp.next; //指针后移，继续查找
		}//退出循环就指向了最后节点，将该节点指向新节点
		temp.next = hero; //添加进去
	}
	public void show() {
			if(head.next==null) {
				System.out.println("无节点数据");
				return;//找到了最后节点结束
			}
			HeroNode temp = head.next; //指向了head
			while(true) {
				if(temp ==null) {
					break;
				}
				System.out.println(temp); //打印当前节点
				temp = temp.next; //指针后移，继续遍历
		}//退出循环就指向了最后节点，将该节点指向新节点
	}
}
//创建节点属性
class HeroNode {
	public int num;  //编号
	public String name; //名字
	private String pname; //昵称
	public HeroNode next;//指向下一节点
	//构造方法
	public HeroNode(int numb,String nameb,String pnameb ) {
		this.num = numb;
		this.name = nameb;
		this.pname= pnameb;
	}
	//重写toString方法，方便输出信息
	@Override
	public String toString() {
		return "HeroNode [num=" + num + ", name=" + name + ", pname=" + pname + "]";
	}
}

测试结果：
在这里插入图片描述
4.2按排名的方式进行节点插入
重写添加方法与新插入的节点进行序号比较，按排序顺序进行插入，思路如下：
在这里插入图片描述
方法重写如下：

//根据num编号排名进行添加到节点
			public void add2(HeroNode hero) {
				boolean flag = false;//定义排名大小标记，默认新加的节点大
				HeroNode temp = head; //指向了head节点
				while(true){
						if(temp.next==null) {break;}//已经在链表的最后，还要进行序号判断
						//下面进行序号判断
					    if(temp.next.num>hero.num) {
					    	break;//找到插入的位置，在temp与temp.next之间插入
					    	}
					    else if(temp.next.num==hero.num) {
					    	  flag = true;
						      break;
					    }
					       temp =temp.next;//指针后移,进行遍历
					   }
				     if(flag) {  System.out.println("此号码已插入过: num="+hero.num);}
						//下面进行插入操作，插在temp与temp.next之间
				     else { hero.next =temp.next; //新节点指向上一个节点
					        temp.next =hero; //temp的指向由新节点
				       }
		}

根据编号匹配进行信息修改：

					//根据编号进行数据更新，编号是一定的
					public void update(HeroNode newhero) {
					if(head.next==null) {System.out.println("链表为空");
					return;} //判断是否为空，为空不用更新数据
					boolean flag = false; //匹配的标记
					HeroNode temp = head.next;
					while(true) {
					if(temp==null) {  
								break; //已经遍历完 
					 }if(newhero.num ==temp.num) {
						 flag = true;//找到修改的地方
						 break;
						 }
					 temp= temp.next; //继续遍历搜索
					}
					if(flag) {
						newhero.name = temp.name;
						newhero.pname = temp.pname;
					}else {System.out.println("无修改信息");}
				}

删除节点：依据编号相同进行删除
在这里插入图片描述

//删除节点
		public void delete(int num) {
			boolean flag = false; //匹配的标记
			HeroNode temp = head;
			while(true) {
			if(temp.next==null) {  
						break; //已经遍历完 
			 }if(temp.next.num ==num) {
				 flag = true;//找到修改的地方
				 break;
				 }
			 temp= temp.next; //继续遍历搜索
			}
			if(flag) {
				temp.next =temp.next.next;//跳过需要删除的节点
			}else {System.out.println("无修改信息");}
		}

统计节点的有效个数，不包括头结点：传入参数为头节点

		//统计节点的有效个数，不包含头节点
				public  static int getLength(HeroNode head) {
					//判断为不为空
					if( head.next==null) {return 0;}
					int length = 0;//标记个数
					HeroNode temp = head.next; //指向头结点的下一个节点
					while(temp!=null) {
						length++;
						temp = temp.next; //向下进行遍历
					}
					return length;
				}

找出链表倒数第k个节点，思路：先统计链表有效个数，然后匹配倒数第k个
传入参数为头结点和k

		//查找单链表的倒数第K个节点，先统计有效个数，然后查找第K个
		public  static void search(HeroNode head,int k) {
				//判断为不为空
				if( head.next==null) {
					System.out.println("链表无节点");
				    return;}
					int length = 0;//标记有效个数
					int count = 0;//标记查找个数
					HeroNode temp = head.next;
					HeroNode cur = head.next;
					while(temp!=null) {
						length++;
						temp = temp.next; //向下进行遍历
					}//退出循环后找到有效节点数length
					if(k<=length) { //不能超过边界
					while(cur!=null) {
						count++;
						if(count==length+1-k) {
							System.out.println(cur);
							break;
							}//找到倒数第k个
						cur = cur.next; //向下进行遍历
					}
				}else {System.out.println("输入超过了，有效数据为："+length);}
				
		}
		//统计节点的有效个数，不包含头节点
			public  static int getLength(HeroNode head) {
				//判断为不为空
				if( head.next==null) {return 0;}
				int length = 0;//标记个数
				HeroNode temp = head.next;
				while(temp!=null) {
					length++;
					temp = temp.next; //向下进行遍历
				}
				return length;
				
			}

将单链表进行反转，（百度题）
思路：重新连接一条链，首先创建一个新节 点reverseHead = new HeroNode();
从头开始遍历原来的链表，每遍历一个节点，将其取出，放入新节点的链路
即变为：head.next = reverseHead.next;每次添加后都将后面的节点放在前面了
![在这里插入图片描述](https://img-blog.csdnimg.cn/20200515170418616.png
在这里插入图片描述
在这里插入图片描述
//反转链表，改变原有的结构，如下所示

		//统计节点的有效个数，不包含头节点
			public  static void reverse(HeroNode head) {
				//判断为不为空
				if( head.next==null||head.next.next==null) {return ;}
				HeroNode newNode = new HeroNode(0,"","");//创建新链表的链头
				HeroNode cur = head.next; // 指向head的下一个节点
				HeroNode temp = null;
				while(cur!=null) {
					temp= cur.next ; //保留当前节点的下一节点,便于下次的遍历
					cur.next = newNode.next; //转向新链路，建立头节点与下一节点连接
					newNode.next = cur;   //将它的地址用cur来替代，取出cur
					cur =temp;  //往下进行遍历
				}
				head.next = newNode.next;//将链头节点加入
			}

逆序打印链表
在这里插入图片描述
这里采用栈的方式进行，首先给出栈的应用示例：

		//逆序打印，通过栈来实现
				public static void showresvest(HeroNode head) {
					if(head.next==null) {System.out.println("空链表");}
					Stack<HeroNode> st = new Stack();
					HeroNode temp = head.next;
					while(temp!=null) {
						st.push(temp); //进栈,add也可以
						temp = temp.next;
					}
					//出栈
					while(st.size()>0) {
						System.out.println(st.pop());
					}
				}

所有整合的代码

			package List;
			
			import java.util.Stack;
			
			public class singlelinklist {
				public static void main(String[] args) {
					/*
					 * HeroNode hero1 = new HeroNode(1,"宋江","及时雨"); HeroNode hero2 = new
					 * HeroNode(2,"卢俊义","玉麒麟"); HeroNode hero3 = new HeroNode(3,"吴用","智多星");
					 * HeroNode hero4 = new HeroNode(4,"林冲","豹子头"); HeroNode hero5 = new
					 * HeroNode(5,"史进","九纹龙"); //创建单链表 Singlelist st =new Singlelist();
					 * st.add(hero1); //添加节点数据 st.add(hero2); st.add(hero3); st.add(hero4);
					 * st.add(hero5); st.show(); //显示数据
					 */
					HeroNode hero1 = new HeroNode(1,"宋江","及时雨");
					HeroNode hero2 = new HeroNode(2,"卢俊义","玉麒麟");
					HeroNode hero3 = new HeroNode(3,"吴用","智多星");
					HeroNode hero4 = new HeroNode(4,"林冲","豹子头");
					HeroNode hero5 = new HeroNode(5,"史进","九纹龙");
					//创建单链表
					Singlelist st =new Singlelist();
					st.add2(hero4); //添加节点数据
					st.add2(hero1);
					st.add2(hero3);
					st.add2(hero5);
					st.add2(hero2);
					st.add2(hero5);
					st.show(); //显示数据
					//显示有效个数,将头结点传进去
					System.out.println(getLength(st.getHead()));
					//查找倒数第k个节点
					search(st.getHead(),2);
					//反转链表结构
					System.out.println("反转链表");
					reverse(st.getHead());
					st.show(); //显示数据
					//逆序输出
					showresvest(st.getHead());
				}
				//查找单链表的倒数第K个节点，先统计有效个数，然后查找第K个
					public  static void search(HeroNode head,int k) {
						//判断为不为空
						if( head.next==null) {
							System.out.println("链表无节点");
						    return;}
							int length = 0;//标记有效个数
							int count = 0;//标记查找个数
							HeroNode temp = head.next;
							HeroNode cur = head.next;
							while(temp!=null) {
								length++;
								temp = temp.next; //向下进行遍历
							}//退出循环后找到有效节点数length
							if(k<=length) { //不能超过边界
							while(cur!=null) {
								count++;
								if(count==length+1-k) {
									System.out.println(cur);
									break;
									}//找到倒数第k个
								cur = cur.next; //向下进行遍历
							}
						}else {System.out.println("输入超过了，有效数据为："+length);}
						
				}
				//统计节点的有效个数，不包含头节点
					public  static int getLength(HeroNode head) {
						//判断为不为空
						if( head.next==null) {return 0;}
						int length = 0;//标记个数
						HeroNode temp = head.next;
						while(temp!=null) {
							length++;
							temp = temp.next; //向下进行遍历
						}
						return length;
						
					}
				
					//反转链表，改变结构如下所示
					//统计节点的有效个数，不包含头节点
					public  static void reverse(HeroNode head) {
						//判断为不为空
						if( head.next==null||head.next.next==null) {return ;}
						//创建新链表的链头
						HeroNode newNode = new HeroNode(0,"","");
						HeroNode cur = head.next; // 指向head的下一个节点
						HeroNode temp = null;
						while(cur!=null) {
							temp= cur.next ; //保留当前节点的下一节点,便于下次的遍历
							cur.next = newNode.next; //转向新链路，建立头节点与下一节点连接
							newNode.next = cur;   //将它的地址用cur来替代，取出cur
							cur =temp;  //往下进行遍历
						}
						head.next = newNode.next;//将链头节点加入
					}
					//逆序打印，通过栈来实现
					public static void showresvest(HeroNode head) {
						if(head.next==null) {System.out.println("空链表");}
						Stack<HeroNode> st = new Stack();
						HeroNode temp = head.next;
						while(temp!=null) {
							st.add(temp); //进栈
							temp = temp.next;
						}
						//出栈
						while(st.size()>0) {
							System.out.println(st.pop());
						}
					}
				
			}
			//创建单链表属性
			class Singlelist{
				//初始化一个头节点，好在后部添加数据
				HeroNode head = new HeroNode(0,"","");
				
				//返回头结点
				public HeroNode getHead() {
					return head;
				}
			
				//单节点进行，添加节点方法
				public void add(HeroNode hero) {
					//要找到链尾，向其添加数据，然后将其next指向下一个节点
					HeroNode temp = head; //指向了head
					while(true) {
						//找到链表的最后
						if(temp.next==null) {
							break;//找到了最后节点结束
						}
						temp = temp.next; //指针后移，继续查找
					}//退出循环就指向了最后节点，将该节点指向新节点
					temp.next = hero; //添加进去
				}
				
					
					
				//根据num编号排名进行添加到节点
				public void add2(HeroNode hero) {
					boolean flag = false;//定义排名大小标记，默认新加的节点大
					HeroNode temp = head; //指向了head
					while(true){
							if(temp.next==null) {break;}//已经在表的最后
						    if(temp.next.num>hero.num) {
						    	break;//找到插入的位置，在temp与temp.next之间插入
						    	}
						    else if(temp.next.num==hero.num) {
						    	  flag = true;
							      break;
						    }
						       temp =temp.next;//指针后移,进行遍历
						   }
					     if(flag) {  System.out.println("此号码已插入过: num="+hero.num);}
							//下面进行插入操作，插在temp与temp.next之间
					     else { hero.next =temp.next; //新节点指向上一个节点
						        temp.next =hero; //temp的指向由新节点
					       }
			}
			   //根据编号进行数据更新，编号是一定的
				public void update(HeroNode newhero) {
					if(head.next==null) {System.out.println("链表为空");
					return;} //判断是否为空，为空不用更新数据
					boolean flag = false; //匹配的标记
					HeroNode temp = head.next;  //表示下一位数据
					while(true) {
					if(temp==null) {  
								break; //已经遍历完 
					 }if(newhero.num ==temp.num) {
						 flag = true;//找到修改的地方
						 break;
						 }
					 temp= temp.next; //继续遍历搜索
					}
					if(flag) {
						newhero.name = temp.name;
						newhero.pname = temp.pname;
					}else {System.out.println("无修改信息");}
				}
				//删除节点
					public void delete(int num) {
						boolean flag = false; //匹配的标记
						HeroNode temp = head;
						while(true) {
						if(temp.next==null) {  
									break; //已经遍历完 
						 }if(temp.next.num ==num) {
							 flag = true;//找到修改的地方
							 break;
							 }
						 temp= temp.next; //继续遍历搜索
						}
						if(flag) {
							temp.next =temp.next.next;//跳过需要删除的节点
						}else {System.out.println("无修改信息");}
					}
				public void show() {
						if(head.next==null) {
							System.out.println("无节点数据");
							return;//找到了最后节点结束
						}
						HeroNode temp = head.next; //指向了head
						while(true) {
							if(temp ==null) {
								break;
							}
							System.out.println(temp); //打印当前节点
							temp = temp.next; //指针后移，继续遍历
					}//退出循环就指向了最后节点，将该节点指向新节点
				}
			}
			//创建节点属性
			class HeroNode {
				public int num;  //编号
				public String name; //名字
				public String pname; //昵称
				public HeroNode next;//指向下一节点
				//构造方法
				public HeroNode(int numb,String nameb,String pnameb ) {
					this.num = numb;
					this.name = nameb;
					this.pname= pnameb;
				}
				//重写toString方法，方便输出信息
				@Override
				public String toString() {
					return "HeroNode [num=" + num + ", name=" + name + ", pname=" + pname + "]";
				}
			}
hdu_sds
关注
专栏目录
数据结构与算法：链表及其应用
天亮了的博客
10-13 1115
基本介绍 相比数组，链表是一种稍微复杂一点的数据结构。数组和链表都属于线性表，一个是顺序存储结构，一个是链式存储结构，最主要的的差别是底层存储结构。 数组需要一块连续的内存空间来存储，对内存要求较高，如果申请一个100MB大小的数组，当内存中没有连续的、足够大的存储空间时，即使内存剩余空间总和大于100MB，仍然申请失败。 链表恰恰相反，它并不需要一块连续的内存空间，它通过“指针”将一组零散的内存块串联起来使用，所以如果申请的是 100MB 大小的链表，只要剩余内存不小于于100MB根本不会有问题。如果剩余
C语言之链表的创建与应用
m0_59998867的博客
09-03 283
一、添加新结点 代码如下： #include<stdio.h> #include<stdlib.h> struct link* create(int n) //声明创建结点函数 { struct link* headnode, * node; //创建头指针和结点指针 headnode = (struct link*)malloc(sizeof(struct link)); //为headnode申请内存空间 headnode->n.
数据结构与算法--链表实现以及应用
0102的博客
03-05 745
数据结构与算法–链表实现以及应用 链表是面试时候使用最频繁的一种数据结构。链表的结构简单，他由指针将若干个节点链接成链状结构。链表的创建，插入，删除，查询操作都只有几行代码可以完成，代码量比较少，可以在较短的时间内完成，这样可以在短时间内考察出人员对数据结构的理解。而且链表数据结构很灵活，可以用来各种灵活的试题。 链表是一种动态数据结构，因为在建立链表的时候，无需知道链表的长度，当插入一个节点时候，只需要为新节点分配内存，然后调整链表中对应节点的指针指向就可以完成节点的插入。内存分配不是在创建链表的时候一
数据结构-链表及其应用
m0_62464074的博客
12-01 1323
南昌大学实验报告 （以下主要内容由学生完成） 实验项目名称 链表及其应用 实验要求 1．掌握链表的灵活运用； 2．学习链表初始化和建立一个新的链表； 3．知道怎样去实现链表删除结点操作与插入结点； 4．理解链表的基本操作（包括数据域数据的相加）并能灵活运用。 实验内容 1. 实现线性表的链式存储方法，单链表建立、插入、删除、查找等基本操作。 2. 基于单链表的基本操作，编写算法函数LinkListReverse(LinkList L)，实现单链表的就地逆置。 算法分析 L...
数据结构之链表及实现
Better_YZQ的博客
08-29 196
数据结构之链表及实现 线性表的链式表示和实现 线性表的顺序存储结构的特点是逻辑关系上相邻的两个元素在物理位置上也相邻。正由于这种特点，在做插入和删除操作时，需移动大量元素。 链式存储：不要求逻辑上相邻的元素在物理位置上也相邻，特点是用一组任意的存储单元存储线性表的数据元素（可以是连续的，也可以是不连续的）。 为了表示每个数据元素ai与其直接后...
浅谈iOS 数据结构之链表
08-29
链表作为基础的数据结构之一，对于提升程序效率有显著作用。本文将深入探讨链表的概念，特别是单链表和双链表，并提供Objective-C实现的示例。 链表是一种数据结构，它由一系列节点组成，每个节点包含数据以及指向...
JavaScript数据结构之链表的实现
12-08
标题中的"JavaScript数据结构之链表的实现"就是关于如何在JavaScript中构建链表数据结构的讨论。 链表通常有一个头指针`head`，它存储的是第一个节点的地址。当需要在链表中查找、插入或删除元素时，可以从头指针...
链表树-复合数据结构应用实例.zip
最新发布
06-17
在这个"链表树-复合数据结构应用实例.zip"压缩包中，我们可以深入探讨链表树的概念、实现以及它在实际问题中的应用。 首先，链表是一种线性数据结构，它的元素并不在内存中连续存放，而是通过指针链接。每个元素...
数据结构——链表的应用
qq_39637327的博客
12-05 822
假设：有两个整数集合A和B分别用两个线性表LA和LB表示，即：线性表中的数据元素即为集合中的成员。（A/B为纯集合） 要求：一个新的集合A=AUB，A仍然为纯集合，线性表采用链式存储方式。 #include <malloc.h> #include <stdio.h> typedef int ElemType; typedef struct LNode { E...
数据结构 单链表的实现及其应用
04-20
数据结构课程，是关于单链表的实现及其应用程序，希望可以帮助你
数据结构——链表的实现
12-29
数据结构课程的链表类的C++实现，搜索，删除，插入，查找等函数
数据结构 链表-构造
aong4563的博客
09-17 254
转载于:https://www.cnblogs.com/yunshangyue71/p/11535073.html
经典数据结构系列之：链表的应用
思维的持续
04-13 423
1、前言 数据结构，是计算机编程中对数据存储最基本的操作，不同的数据结构适用不同的业务场景。如今大部分情况都是调用开发API封装好的类库，直接调用，几乎不需要程序员再去深究其中背后实现的逻辑，大大简化和减低了对程序员的要求。正是这种，知其然而不知其所以然，导致很多程序员缺乏对于底层结构的了解，分不清楚不同数据结构之间的性能差异，导致出现很多系统性能问题。 2、原理推导 链表的运用，链表是一种特殊的...
数据结构-线性链表的实现和应用
T_Shrimp的博客
10-01 333
采用线性表的链式存储结构，实现线性链表的合并操作：①设有线性链表 La 和 Lb，试设计算法将La 和 Lb 归并为新的线性链表 Lc；②设线性链表 La 和 Lb 中的数据元素为整数，且均已按值非递减有序排列，要求 Lc 中的数据元素也按值非递减有序排列。 #include<malloc.h> #include<stdio.h> #define ERROR 0 #define NULL 0 #define OK 1 typedef int ElemType; typede...
数据结构之链表应用
weixin_43184636的博客
02-13 235
1.单链表LRU算法 package linked.singlelist; import java.util.Scanner; /** * 基于单链表LRU算法（java） */ public class LRUBaseLinkedList&lt;T&gt; { /** * 默认链表容量 */ private final static Integer ...
数据结构链表应用
昨日明眸
09-18 325
#include #include #include typedef struct student                        //学生信息存储结构 {     char num[20];                              //学号     char name[20];                            //姓名    
数据结构链表的应用
b665c90的博客
10-27 225
假设：有两个整数集合 A 和 B 分别用两个线性表 LA 和 LB 表示，即：线性表中的数据元素即为集合中的成员。（A/B为纯集合） 要求：一个新的集合A＝A∪B，A仍然为纯集合，线性表采用链式存储方式。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值