52.【Java 数据结构—

线性表

1.什么是线性表?
2.线性表的定义:
3.线性表图解:
4.线性表的长度:
5.线性表的顺序储存结构：
- 5.1定义:
- 5.2顺序储存结构的插入元素:
- 5.3线性表的顺序结构的删除元素:
- 5.4线性表顺序储存结构的优缺点
6.顺序存储结构的全部用法:(ArrayList)
7.单链表的全部用法
- 7.1练习:
8.循环链表(双指针快慢)
- 8.1判断是否是循环链表
- 8.2求循环链表的入口元素
- 8.3指定点循环链表的建立
- 8.4不指定点循环链表建立
- 8.5约瑟夫问题
9.双向链表:
- 9.1双向链表结点的定义：
- 9.2双向链表添加末尾元素:
- 9.3获取双向链表的结点:
- 9.4向指定位置添加元素
- 9.5删除元素
9.双向链表的全部用法

1.什么是线性表?

线性表是最基本、最简单、也是最常用的一种数据结构。线性表（linear list）是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。
线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的（注意，这句话只适用大部分线性表，而不是全部。比如，循环链表逻辑层次上也是一种线性表（存储层次上属于链式存储，但是把最后一个数据元素的尾指针指向了首位结点）。

2.线性表的定义:

线性表（linear list）是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。数据元素是一个抽象的符号，其具体含义在不同的情况下一般不同。(直接前驱和直接后继)

3.线性表图解:

有限:数据元素是有限个的
序列:小朋友排队是有顺序的.

4.线性表的长度:

线性表的元素个数n就是线性表的长度: 当n=0时,那么就是空表.i称为序列！
线性表的长度不等于数组的长度，通常数组的长度大于等于线性表的长度:

5.线性表的顺序储存结构：

5.1定义:

顺序储存结构:是指的时一段地址连续的储存单元依次存储线性表的数据元素.

5.2顺序储存结构的插入元素:

注意事项:

阐述:

表长+1并不是说数组的长度+1，而是指的时数据元素+1

方法:

public static int[] InsertNumber(int []nums,int idex,int number){if(nums.length==5){    //假设数组的最大为5个，假如说表的长度等于5，返回nullreturn null;}if(idex==nums.length-1){  //假如说插入元素的下表在线性表中的最后一个，那么就执行下面这样的循环nums[idex]=number;    //插入return nums;}if(idex<nums.length-1){   //假如说插入元素的下表不是线性表的最后一个，那么就执行一下程序for(int k=nums.length-1;k>idex;k--){nums[k]=nums[k-1];   //插入元素后的所有元素后退}nums[idex ]=number;   //插入return nums;}return null;}
}

主函数:

import java.sql.SQLOutput;
import java.util.*;
import java.awt.*;
public class hello {public static void main(String []avgs) {int []nums=new int[4];nums[0]=1;  //线性表nums[1]=2;  //线性表nums[2]=3;  //线性表int []arr=InsertNumber(nums,0 ,5);  //数组 插入坐标 插入元素for(int i=0;i<arr.length;i++){    //打印输出System.out.println(arr[i]);}}

5.3线性表的顺序结构的删除元素:

删除算法的思路:
(1)如果删除位置不合理，抛出异常;(2)取出删除元素;
(3)从删除元素位置开始遍历至到最后一个元素位置，分别将它们都向前移动一个位置;
(4)表长减1。

方法:

  public static int[] InsertNumber(int []nums,int idex){if(nums.length==0){    //假设线性表为0return null;}if(idex>nums.length){  //假如说删除的数据大于线性表长度return null;}if(idex<nums.length){for(int k=idex;k<nums.length-1;k++)  //中间条件目的是为了防止线性表超限{nums[k]=nums[k+1];}return nums;}return null;}
}

主函数:

import java.sql.SQLOutput;
import java.util.*;
import java.awt.*;
public class hello {public static void main(String []avgs) {int []nums=new int[4];nums[0]=1;  //线性表nums[1]=2;  //线性表nums[2]=3;  //线性表int []arr=InsertNumber(nums,1 );  //数组 插入坐标 插入元素for(int i=0;i<arr.length;i++){    //打印输出System.out.println(arr[i]);}}

*切记哈，删除和插入的是线性表=====并不是数组*

5.4线性表顺序储存结构的优缺点

6.顺序存储结构的全部用法:(ArrayList)

判断是否清空

 public boolean isEmpty(){return N==0;}

线性表的长度`

 public int getLength(){return N;}

索引所在的值

 public T getNumber(int i){return elem[i];}

在线性表中插入元素

 public void Insert(T t){elem[N++]=t;}

在指定索引i处增加t

 public void add(int idex,T t){for(int i=N;i>idex;i--){elem[i]=elem[i-1];}N++;elem[idex]=t;}
}

删除指定索引i的值，并返回删除索引的值

   public T remove(int i){T count=elem[i];for(int idex=i;idex<N-1;idex++){elem[idex]=elem[idex+1];}//元素个数-1N--;return count;}

查找元素T，在链表中出现的第一个位置

  public int Find(T t){for(int i=0;i<N;i++){if(elem[i].equals(t)){return i;}}return -1;}

数组的扩容

  public void resize(int size){T [] newelem=(T[]) new Object[size];for(int i=0;i<N;i++){newelem[i]=elem[i];  //老数组赋值给新数组}elem=newelem;   //新数组赋值给老数组}

`类方法展示:

public class SquenceList <T>{private T[]elem;  //定义一个数据类型为T的数组//代表线性表中存放的元素个数private int N;public SquenceList(int capacity){ //构造方法//初始化数组this.elem=(T[])new Object[capacity];this.N=0;}//实现对数组的扩容处理public void resize(int size){T [] newelem=(T[]) new Object[size];for(int i=0;i<N;i++){newelem[i]=elem[i];  //老数组赋值给新数组}elem=newelem;   //新数组赋值给老数组}//清空线性表public void clear(){N=0;}//判断线性表是否为空public boolean isEmpty(){return N==0;}//求线性表的长度public int getLength(){return N;}//获取索引所在的值:public T getNumber(int i){return elem[i];}//向线性表中插入元素public void Insert(T t){elem[N++]=t;}//在指定索引i处增加tpublic void add(int idex,T t){for(int i=N;i>idex;i--){elem[i]=elem[i-1];}N++;elem[idex]=t;}//删除指定索引i的值，并返回删除索引的值public T remove(int i){T count=elem[i];for(int idex=i;idex<N-1;idex++){elem[idex]=elem[idex+1];}//元素个数-1N--;return count;}//查找元素T，在链表中出现的第一个位置public int Find(T t){for(int i=0;i<N;i++){if(elem[i].equals(t)){return i;}}return -1;}
}

主方法:

public class SquenceListTest {public static void main(String []avgs){//创建顺序表对象SquenceList<String> s1=new SquenceList<>(10);//测试插入s1.Insert("李明");s1.Insert("傻子");s1.Insert("王二" );s1.Insert("张三");//测试获取String result=s1.getNumber(1);System.out.println(result);//测试删除String remove1=s1.remove(1);System.out.println("删除的是:"+remove1);//测试清空s1.clear();System.out.println("清空后的元素个数为:"+s1.getLength());}
}

7.单链表的全部用法

创建链表结点

 private class Node1 {   //调用结点类T item;    //数据域Node1 next;   //指针域public Node1(T item, Node1 next) {this.item = item;this.next = next;}}//调用节点类

对链表进行初始化

public LinkedList() { //初始化链表this.head=new Node1(null,null);this.size=0;}

//获取指定位置的元素:

public T get(int idex){Node1 target=this.head.next;  //获取0结点的指针，且目前表示的是第一个结点for(int i=0;i<idex;i++ ){   //移动指针target=target.next;}return target.item;
}

//获取指定位置的结点

public Node1 getNode(int idex){if(idex==-1){   //目的是在指定位置0的时候的作用return head;}Node1 target=this.head.next;for(int i=0;i<idex;i++ ){   //移动指针target=target.next;}return target;
}

//在尾部添加数据

public void add(T t){Node1 node=new Node1(t,null);
if(this.size==0){   //假如说是0结点，那么就添加到零结点this.head.next=node;
}else {  //找到最后一个结点this.getNode(this.size-1).next=node;
}
//链表长度++this.size++;
}

//在指定位置插入数据

public void add(int idex,T t){//获取需要插入点的节点Node1 node2 =new Node1(t,null);//获取被插入点的结点Node1 current=this.getNode(idex);//获取被插入点的前一个为止Node1 BeforeCurrent=this.getNode(idex-1);//把前一个结点的指针指向插入点BeforeCurrent.next= node2;//把插入点的指针指向被插入点node2.next=current;this.size++;
}

//删除指定位置的结点

  public T remove(int idex){//获取删除点的前一个结点Node1 before =this.getNode(idex-1);//获取删除点的结点Node1 current=this.getNode(idex);before.next=current.next;this.size--;return current.item;}

类文件:

import org.jetbrains.annotations.NotNull;public class LinkedList<T> {Node1 head;  //设置头节点int size;   //链表长度public LinkedList() { //初始化链表this.head=new Node1(null,null);this.size=0;}public void reverse2(){reverse1(this.head.next);}//使用快慢指针寻找中间元素public T QuickSlowP(){//设置慢指针Node1 slow=this.head.next;//设置快指针Node1 quick=this.head.next;//设置慢指针计数器:int length=0;//设置快指针计数器int length1=0;while(quick!=null){//慢指针slow=slow.next;//快指针quick=quick.next;quick=quick.next;length++;length1++;}int mid=length1/2;quick=this.head.next;  //这边的node要进行重新初始化for(int i=0;i<mid;i++){quick=quick.next.next;}return quick.item;}//利用慢指针进行寻找中间元素public T Slowp(){//获取第一个结点的指针Node1 node=this.head.next;//定义一个链表的长度的计数器:int length=0;while(node!=null){node=node.next;length++;}//获取中间元素的长度:int mid=length/2;node=this.head.next;  //这边的node要进行重新初始化for(int i=0;i<mid;i++){node=node.next;}return node.item;}//通过递归函数完成链表的反转public Node1 reverse1(@NotNull Node1 curr){if(curr.next!=null){//通过反转下一个结点获取，获取prevNode1 prev=reverse1(curr.next);//将之前的next结点设置成当前的结点prev.next=curr;//返回curr的结点return curr;}else{//当前结点没有下一个结点// 将头部的next结点指向当前结点this.head.next=curr;return curr.next;}}//链表的反转:public void reverseList(){//设置反转头Node1 reverse = new Node1(null, null);//获取正序第一个结点Node1 first=this.head.next;while(first!=null) {//把正序的头节点连接到first的下一个结点this.head.next = first.next;//将反转的next赋值给first的nextfirst.next = reverse.next;//将头节点指向firstreverse.next = first;// 从正序链表中获取第一个原始元素first = this.head.next;}//将原始头的next指向反转头结点的nextthis.head.next=reverse.next;}//获取当前链表的长度:public int size(){return this.size;}//获取指定位置的元素:public T get(int idex){Node1 target=this.head.next;  //获取0结点的指针，且目前表示的是第一个结点for(int i=0;i<idex;i++ ){   //移动指针target=target.next;}return target.item;}//获取指定位置的结点public Node1 getNode(int idex){if(idex==-1){   //目的是在指定位置0的时候的作用return head;}Node1 target=this.head.next;for(int i=0;i<idex;i++ ){   //移动指针target=target.next;}return target;}//在尾部添加数据public void add(T t){Node1 node=new Node1(t,null);if(this.size==0){   //假如说是0结点，那么就添加到零结点this.head.next=node;}else {  //找到最后一个结点this.getNode(this.size-1).next=node;}//链表长度++this.size++;}//在指定位置插入数据public void add(int idex,T t){//获取需要插入点的节点Node1 node2 =new Node1(t,null);//获取被插入点的结点Node1 current=this.getNode(idex);//获取被插入点的前一个为止Node1 BeforeCurrent=this.getNode(idex-1);//把前一个结点的指针指向插入点BeforeCurrent.next= node2;//把插入点的指针指向被插入点node2.next=current;this.size++;}//删除指定位置的结点public T remove(int idex){//获取删除点的前一个结点Node1 before =this.getNode(idex-1);//获取删除点的结点Node1 current=this.getNode(idex);before.next=current.next;this.size--;return current.item;}private class Node1 {   //调用结点类T item;    //数据域Node1 next;   //指针域public Node1(T item, Node1 next) {this.item = item;this.next = next;}}//调用节点类}

主文件:

import java.sql.SQLOutput;
import java.util.*;
import java.awt.*;
public class hello {public static void main(String []avgs) {LinkedList<String> s=new LinkedList<>();s.add("aa");s.add("bb");s.add("cc");s.remove(2);for(int i=0;i<s.size();i++) {System.out.println(s.get(i));}}
}

7.1练习:

类方法:

public class test{private class Node{Node next;  //指针int item;  //数据public Node(int item,Node next){this.next=next;this.item=item;}}//定义节点Node head;//定义头节点int size; //定义长度public test(){int size=0; //对长度进行初始化}public int getSize(){return size;}public Node getNode(int idex){Node target=this.head.next;for(int i=0;i<idex;i++){target=target.next;}return target;}//获得结点public int get(int idex){return getNode(idex).item;}//获得值public void add(int t){Node node=new Node(t,null);if(this.size==0){this.head.next=node;}else{getNode(this.size-1).next=node;}this.size++;}}

主方法:

import java.sql.SQLOutput;
import java.util.*;
import java.awt.*;
import java.lang.Math;
public class hello {public static void main(String []avgs) {LinkedList s=new LinkedList<>();Scanner sc=new Scanner(System.in);System.out.println("请输入您的数据");for(int i=0;i<100;i++){int m=sc.nextInt();s.add(m);if(s.get(i).equals(-1)){System.out.println("链表创建完毕！");break;}}System.out.println("链表的数据为:");for (int i=0;i<s.size();i++){System.out.print(s.get(i)+" ");}}
}

8.循环链表(双指针快慢)

循环链表是另一种形式的链式存储结构。它的特点是表中最后一个结点的指针域指向头结点，整个链表形成一个环。

8.1判断是否是循环链表

利用快慢指针判断是否这个链表是否为环形
基本思路:
因为快指针比慢指针走的快，慢指针比快指针走的慢。会有多次相遇的机会的
方法:

  public boolean QuickSlowP(){//设置慢指针Node1 slow=this.head.next;//设置快指针Node1 quick=this.head.next;while(quick!=null&&quick.next!=null){//慢指针slow=slow.next;//快指针quick=quick.next;quick=quick.next;if(quick!=null&&quick.equals(slow)){return true;}}return false;}

//创建环形链表:
只需要把你想要的结点的指针指向你要循环的地方，就可以构成一个循环链表.

   public void Recle(int start,int end){Node1 node=getNode(start);Node1 node1=getNode(end);node1.next=node;}

全部代码:

主方法:import java.sql.SQLOutput;
import java.util.*;
import java.awt.*;
import java.lang.Math;
public class hello {public static void main(String []avgs) {LinkedList<String> s=new LinkedList<>();//构造一个单链表s.add("aa");s.add("cc");s.add("ee");s.add("zz");System.out.println(s.QuickSlowP());//构造一个环形链表s.Recle(2,s.size()-1);System.out.println(s.QuickSlowP());}
}类方法import org.jetbrains.annotations.NotNull;public class LinkedList<T> {Node1 head;  //设置头节点int size;   //链表长度public LinkedList() { //初始化链表this.head=new Node1(null,null);this.size=0;}public void Recle(int start,int end){Node1 node=getNode(start);Node1 node1=getNode(end);node1.next=node;}//使用快慢指针寻找中间元素public boolean QuickSlowP(){//设置慢指针Node1 slow=this.head.next;//设置快指针Node1 quick=this.head.next;while(quick!=null&&quick.next!=null){//慢指针slow=slow.next;//快指针quick=quick.next;quick=quick.next;if(quick!=null&&quick.equals(slow)){return true;}}return false;}//获取当前链表的长度:public int size(){return this.size;}//获取指定位置的元素:public T get(int idex){Node1 target=this.head.next;  //获取0结点的指针，且目前表示的是第一个结点for(int i=0;i<idex;i++ ){   //移动指针target=target.next;}return target.item;}//获取指定位置的结点public Node1 getNode(int idex){if(idex==-1){   //目的是在指定位置0的时候的作用return head;}Node1 target=this.head.next;for(int i=0;i<idex;i++ ){   //移动指针target=target.next;}return target;}//在尾部添加数据public void add(T t){Node1 node=new Node1(t,null);if(this.size==0){   //假如说是0结点，那么就添加到零结点this.head.next=node;}else {  //找到最后一个结点this.getNode(this.size-1).next=node;}//链表长度++this.size++;}//在指定位置插入数据private class Node1 {   //调用结点类T item;    //数据域Node1 next;   //指针域public Node1(T item, Node1 next) {this.item = item;this.next = next;}}//调用节点类}

8.2求循环链表的入口元素

基本思路:
首先我们要判断这个链表是否是一个循环链表，如果是循环链表的话那么我们就继续执行操作，不是循环链表的话返回一个NULL。判断是否是入口的关键就在于慢指针slow，和一个新的指针（从第一个元素开始）往后遍历，如果新的指针和指针slow相交的位置，就是元素的所在位置.

  public T QuickSlowP(){//设置慢指针Node1 slow=this.head.next;//设置快指针int length=-1;int a=0;Node1 quick=this.head.next;while(quick!=null&&quick.next!=null){//慢指针slow=slow.next;//快指针quick=quick.next;quick=quick.next;if(quick!=null&&quick.equals(slow)){   //假如环形Node1 entry=this.head.next;   //定义一个新的指针while(!entry.equals(slow)){entry=entry.next;slow=slow.next;}return entry.item;}}return null;}

8.3指定点循环链表的建立

  public void Recle(int start,int end){Node1 node=getNode(start);  //开始点Node1 node1=getNode(end);  //结束点node1.next=node;          //首尾相连接}

8.4不指定点循环链表建立

   public void SolveYsf (int m,int n){  //m是元素的个数，n是间隔几个//建立一个链表for(int i=1;i<=m;i++){   //添加链表的元素add((T)(i+""));}//进行加环处理Node1 node=getNode(0);Node1 node1=getNode(this.size-1);node1.next=this.head.next;

8.5约瑟夫问题

进行自杀操作，一共m个人，没间隔n个，那么就第n个人进行自杀操作。

    public void SolveYsf (int m,int n){//建立一个链表for(int i=1;i<=m;i++){   //添加链表的元素add((T)(i+""));}//进行加环处理Node1 node=getNode(0);Node1 node1=getNode(this.size-1);node1.next=this.head.next;//开始处理约瑟夫问题Node1 target=this.head.next;int cn=1;while(target!=target.next){//获取前一个元素Node1 prev=target;  //获取中间元素的前一个位置//游标进行后移target=target.next;  //获取中间元素//计算cn++;if(cn==n){  //假如说cn=指定的n，那么就自杀System.out.println("需要移除的元素是:"+target.item);prev.next=target.next;  //把中间元素的前一个元素指向中间元素后一个元素target=target.next;   //把中间元素指向中间元素的后一个元素.cn=1;}}System.out.println("保留的元素是:"+target.item);}

9.双向链表:

9.1双向链表结点的定义：

private class Node1 {   //设置结点T item;    //数据域Node1 next;   //指针域Node1 prev;Node1 prev;public Node1(Node1 prev,T item, Node1 next) {this.item = item;this.next = next;this.prev=prev;}}//调用节点类

9.2双向链表添加末尾元素:

  public void add(T t){//先把插入点的prev指针指向前一个lastNode1 prev=last;//获取插入的元素Node1 node1=new Node1(prev,t,null);//然后把插入点前的next指针指向插入点的结点if(prev==null){   //假如说插入点的前一个点是nullfirst=node1;}else {prev.next = node1;}//将last指向新插入的元素last=node1;//进行++操作this.size++;}

9.3获取双向链表的结点:

  public Node1 getNode(int idex){int mid=size/2;  //获取中间值if(idex<mid){  //如果小于，那么就从第一个节点开始遍历Node1 x=first;for(int i=0;i<idex;i++){x=x.next;}return x;}else{     //否则，那么就从最后i一个结点遍历Node1 x=last;for(int i=size-1;i>idex;i--){  //这里可不能少x=x.prev;}return x;}}

9.4向指定位置添加元素

   public void add(int idex,T t){if(idex==size){//假如说是最后一个位置add(t);}else{//获取需要插入元素的结点Node1 node1=new Node1(null,t,null);//获取被插入点的结点Node1 current=getNode(idex);if(current==null){first=node1;}else {//获取被插入点前的结点Node1 befor = current.prev;//插入点prev指向前结点node1.prev=befor;//插入点next指向后一个结点node1.next=current;//后一个结点prev指向插入点current.prev=node1;//假如说是第一个位置if(befor==null){first=node1; }else {befor.next = node1;}}this.size++;}}

9.5删除元素

   public void remove(int idex) {//设置删除点Node1 current = getNode(idex);//删除点前面Node1 before = current.prev;//删除点后面Node1 after = current.next;if(before==null){  //假如说删除头部first=after;}else{before.next = after;}if (after == null) {  //假如说删除末尾last = before;} else {after.prev = before;}this.size--;
}

9.双向链表的全部用法

类方法:

import org.jetbrains.annotations.NotNull;public class LinkedList<T> {Node1 first;  //指向第一个结点Node1 last; //指向最后一个结点int size;   //链表长度public LinkedList() { //初始化链表this.size = 0;}//获取指定位置的结点public Node1 getNode(int idex) {int mid = size / 2;  //获取中间值if (idex < mid) {  //如果小于，那么就从第一个节点开始遍历Node1 x = first;for (int i = 0; i < idex; i++) {x = x.next;}return x;} else {     //否则，那么就从最后i一个结点遍历Node1 x = last;for (int i = size - 1; i > idex; i--) {  //这里可不能少x = x.prev;}return x;}}//在指定位置添加元素public void add(int idex,T t){if(idex==size){//假如说是最后一个位置add(t);}else{//获取需要插入元素的结点Node1 node1=new Node1(null,t,null);//获取被插入点的结点Node1 current=getNode(idex);if(current==null){first=node1;}else {//获取被插入点前的结点Node1 befor = current.prev;//插入点prev指向前结点node1.prev=befor;//插入点next指向后一个结点node1.next=current;//后一个结点prev指向插入点current.prev=node1;//假如说是第一个位置if(befor==null){first=node1; }else {befor.next = node1;}}this.size++;}}//获取指定位置的元素public T get(int idex) {return getNode(idex).item;}//在末尾元素进行添加public void add(T t) {//先把插入点的prev指针指向前一个lastNode1 prev = last;//获取插入的元素Node1 node1 = new Node1(prev, t, null);//然后把插入点前的next指针指向插入点的结点if (prev == null) {   //假如说插入点的前一个点是nullfirst = node1;} else {prev.next = node1;}//将last指向新插入的元素last = node1;//进行++操作this.size++;}//在指定位置进行删除public void remove(int idex) {//设置删除点Node1 current = getNode(idex);//删除点前面Node1 before = current.prev;//删除点后面Node1 after = current.next;if(before==null){  //假如说删除头部first=after;}else{before.next = after;}if (after == null) {  //假如说删除末尾last = before;} else {after.prev = before;}this.size--;
}//获取当前链表的长度public int size(){return size;}private class Node1 {   //设置结点T item;    //数据域Node1 next;   //指针域Node1 prev;Node1 prev;public Node1(Node1 prev,T item, Node1 next) {this.item = item;this.next = next;this.prev=prev;}}//调用节点类
}

主方法:

import java.sql.SQLOutput;
import java.util.*;
import java.awt.*;
import java.lang.Math;
public class hello {public static void main(String []avgs) {LinkedList<String> s=new LinkedList<>();s.add("aa");s.add("bb");s.add("cc");s.add("dd");s.add("ee");s.remove(4);for(int i=0;i<s.size();i++){System.out.println(s.get(i));}}
}