单链表删除重复元素java 单链表去重 java

//链表操作//1-基础//是否空//链表长度-用成员变量表示，增删操作同步(效果同调用函数遍历)//2-操作//添加节点-末尾//插入节点-索引//根据索引删除节点//根据值-删除节点(所有)//根据值-删除重复节点(除了第一个所有)//根据值-删除节点(第一个)//更新节点//清空链表//3-查询//表中是否存在某值//根据索引获取某一节点值//根据值获取节点索引[数组]//根据值获取第一个节点索引//4-遍历//正向遍历//反转链表//反向遍历//5-判断//创建有环链表//是否有环//去除重复元素，//链表排序
importjava.util.ArrayList;public classMyLinkedList {private int length=0;private Node head=newNode();//构造函数默认就行，创建再添加节点//是否空
public booleanisEmpty(){if(this.length==0)return true;else
return false;
}//添加节点-末尾
public void add(intdata){
Node newNode=newNode(data);
Node p=this.head;//空表
if(length==0){
head.next=newNode;
}//非空表
else{//遍历至链表尾部
while(p.next!=null)
p=p.next;
p.next=newNode;
}this.length++;
}//插入节点-索引 [1-length+1]
public void insert(int index,intdata){
Node p=this.head;
Node newNode=newNode(data);//插入位置保错
if(index<1||index>length+1){
System.out.println("插入位置出错");
}//插在末尾
else if(index==length+1){this.add(data);
}//插在表头
else if(index==1){
newNode.next=head.next;
head.next=newNode;
length++;
}else{//遍历到插入位置前
for(int i=0;i
p=p.next;
}
newNode.next=p.next;
p.next=newNode;
length++;
}
}//根据索引删除节点
public void delete(intindex){if(!isEmpty()){//插入位置保错
if(index<1||index>length){
System.out.println("删除位置出错");
}//删除头节点
else if(index==1){
Node p=head.next;
head.next=p.next;
length--;
}else{//遍历至待删节点前
Node p=head;for(int i=0;i
p=p.next;
}
Node dp=p.next;
p.next=dp.next;
length--;
}
}elseSystem.out.println("链表空，无法进行删除操作");
}//根据值-删除节点(所有)
public void deleteall(intdata){
ArrayList indexs=getAllIndex(data);if(indexs.size()==0){return;
}else{//从后往前删除，不用变index;
for(int i=indexs.size()-1;i>=0;i--){
delete(indexs.get(i));
}
}
}//根据值-删除重复节点(除了第一个所有)
public void deletellARepeat(intdata){
ArrayList indexs=getAllIndex(data);if(indexs.size()==0){return;
}else{//从后往前删除，不用变index;留下index[0]即可
for(int i=indexs.size()-1;i>=1;i--){
delete(indexs.get(i));
}
}
}//根据值-删除节点(第一个)
public void deletefirst(intdata){int index=getFirstIndex(data);if(index==-1){return;
}else{
delete(index);
}
}//更新节点
public void update(int index,intdata){if(!isEmpty()){//更新位置保错
if(index<1||index>length){
System.out.println("更新位置出错");
}else if(index==1){
head.next.data=data;
}else{//遍历至更新节点
Node p=head;for(int i=0;i
p=p.next;
}
p.data=data;
}
}elseSystem.out.println("链表空，无法进行更新操作");
}//清空链表
public voidclear(){
head.next=null;
length=0;
}//表中是否存在某值
public boolean isHave(intdata){if(!isEmpty()){
Node p=head;while(p.next!=null){
p=p.next;if(p.data==data)return true;
}return false;
}else{
System.out.println("链表空，无数据");return false;
}
}//根据索引获取某一节点值
public int getData(intindex){if(!isEmpty()){if(index<1||index>length){
System.out.println("index出错");return -1;
}else if(index==1){returnhead.next.data;
}else{//遍历至待删节点前
Node p=head;for(int i=0;i
p=p.next;
}returnp.data;
}
}else{
System.out.println("链表空，无数据");return -1;
}
}//根据值获取节点索引[数组]
public ArrayList getAllIndex(intdata){
ArrayList indexs=new ArrayList();if(isHave(data)){
Node p=head;int i=0;while(p.next!=null){
p=p.next;
i++;if(p.data==data)
indexs.add(i);
}returnindexs;
}else{
System.out.println("链表无此数据");
ArrayList in=new ArrayList();returnin;
}
}//根据值获取第一个节点索引
public int getFirstIndex(intdata){if(isHave(data)){//遍历到节点
Node p=head;int i=0;while(p.next!=null){
p=p.next;
i++;if(p.data==data)break;
}returni;
}else{
System.out.println("链表无此数据");return -1;
}
}//正向遍历
public voidprint_1(){if(!isEmpty()){
System.out.print("链表为：");
Node p=head;while(p.next!=null){
p=p.next;
System.out.print(p.data+"->");
}
System.out.println("null");
}elseSystem.out.println("链表空，无数据，无输出");
}//反转链表
publicMyLinkedList reverse(MyLinkedList myLinkedList){if(!isEmpty()){if(length==1)returnmyLinkedList;else{
Node curNode=head.next;
Node preNode=null;while(curNode!=null){
Node nextNode=curNode.next;
curNode.next=preNode;
preNode=curNode;
curNode=nextNode;
}
head.next=preNode;returnmyLinkedList;
}
}else{
System.out.println("链表空，无法反转");
MyLinkedList mylist=newMyLinkedList();returnmylist;
}
}//反向遍历//反转-正向遍历//正向遍历，入栈-出栈
public voidprint_2(){if(!isEmpty()){
MyLinkedList mylist1=reverse(this);
MyLinkedList mylist=reverse(mylist1);
System.out.print("反转");
mylist.print_1();
}elseSystem.out.println("链表空，无数据，无输出");
}//创建有环链表//将最后一个节点next指向前一个
public voidtoRinged(){
Node curNode=head;
Node nextNode=curNode.next;while(curNode.next!=null&&curNode.next.next!=null){
curNode=nextNode;
nextNode=nextNode.next;
}
nextNode.next=curNode;
}//是否有环//判断链表是否有环：//设置快指针和慢指针，慢指针每次走一步，快指针每次走两步//当快指针与慢指针相等时，就说明该链表有环
public booleanisRinged(){if(!isEmpty()){if(length==1){
System.out.println("链表长度=1，无环");return false;
}else{
Node slow=head;
Node fast=head;while(fast.next!=null&&fast.next.next!=null){
slow=slow.next;
fast=fast.next.next;if(fast==slow)return true;
}return false;
}
}else{
System.out.println("链表空，无环");return false;
}
}//去除重复元素
public voiddeleteRepeatData(){if(length<2){
System.out.println("链表长度<2，无重复数据");
}else{
MyLinkedList mylist=newMyLinkedList();
Node p=head.next;//将原链表中无重复数据添加到新链表；
mylist.add(p.data);while(p.next!=null){
p=p.next;//System.out.print(p.data+" "+!mylist.isHave(p.data)+ " ");
if(!mylist.isHave(p.data))
mylist.add(p.data);
}//对新链表的每一个data执行this(原链表).deleteAllRepeat(data)
Node p1=mylist.head;while(p1.next!=null){
p1=p1.next;//System.out.print(p1.data+" " );
this.deletellARepeat(p1.data);
}
}
}//排序-冒泡//交换函数
public voidswip(Node p1,Node p2){int a=p1.data;
p1.data=p2.data;
p2.data=a;
}public voidbubbleSort(){if(length<2){
System.out.println("链表长度<2,无法排序");
}else{for(int i=1;i
Node p=head;for(int j=0;j
p=p.next;
}//第二个循环比大小，交换，将最大值上浮至末尾
Node curNode=p;
Node nextNode=curNode.next;if(curNode.data>nextNode.data)
swip(curNode,nextNode);while(curNode.next!=null&&curNode.next.next!=null){
curNode=nextNode;
nextNode=nextNode.next;if(curNode.data>nextNode.data)
swip(curNode,nextNode);
}//将末尾最大值放到本层循环挑出来的，未排序的首部，下层未排序首部加1
swip(p,nextNode);
}
}
}
}