「算法旋转链表java」链表的转置算法

本篇文章给大家谈谈算法旋转链表java，以及链表的转置算法对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

• 1、java:已知单链表H,利用栈的原理写一个算法将其倒置
• 2、java版递归算法实现单链表的求长度、查找、替换等操作
• 3、双向循环链表java
• 4、用java来编写一个单链表类的成员函数，实现对头结点的单链表就地逆置的操作

java:已知单链表H,利用栈的原理写一个算法将其倒置

import myjava.Node;

import myjava.SinglyLinkedList;

import myjava.SeqStack;

public class ReverseLinkedListE extends SinglyLinkedListE {

public ReverseLinkedList(){

super();

}

public void reverse(ReverseLinkedListE list){

SeqStackE stack = new SeqStackE();

NodeE p = this.head ;

while(p != null){

stack.push(p.data);

p = p.next;

}

list.clear();

while(!stack.isEmpty()){

list.add(stack.pop());

}

}

public static void main (String[] args) {

ReverseLinkedListInteger list = new ReverseLinkedListInteger();

for(int i = 1;i 6;i++){

list.add(0,new Integer(i));

}

System.out.println("单列表 "+list.toString());

list.reverse(list);

System.out.println("逆转后 "+list.toString());

}

}

java版递归算法实现单链表的求长度、查找、替换等操作

首先，你实现链表的时候肯定是有一个变量记录链表大小的，求长度，直接获取链表大小就可以。

查找：有两种，一种是下标查找，还有一种是对象查找。其实底层归根结底都是用的index下标查找。 替换也是同道理。你要明白链表的原理，我相信你就不会问递归去做这些操作。

因为你查找只要给出下标，直接在for循环在0到你给定的下标内循环就能取到，如果你给的下标在链表大小/2 的后半部分，你可以倒序循环；当然这只是一种思路，希望能帮到你

双向循环链表java

我们也做这个，，你是是吧

package KeCheng1;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.util.Iterator;

import java.util.Scanner;

//定义节点类

class NodeAnyType {

public AnyType data;

public NodeAnyType prev;

public NodeAnyType next;

public Node(AnyType d,NodeAnyType p,NodeAnyType n){

data=d;

prev=p;

next=n;}}

public class MyLinkedListAnyType {

private int theSize;

private NodeAnyType beginMarker; //头标记或头节点

private NodeAnyType endMarker; //尾标记或尾节点

public MyLinkedList(){

beginMarker=new NodeAnyType(null,endMarker,endMarker);

endMarker = new NodeAnyType(null,beginMarker,beginMarker);

beginMarker.next = endMarker;

theSize = 0;}

public int size(){

return theSize;}

public boolean add(AnyType x){

add(size(),x);

return true;}

public void add(int idx,AnyType x){

NodeAnyType p;

p=getNode(idx);

addBefore(p,x);}

private NodeAnyType getNode(int idx) {

NodeAnyType p;

if( idx 0 || idx size( ) )

throw new IndexOutOfBoundsException( );

if( idx size( ) / 2 ) {

p = beginMarker.next;

for( int i = 0; i idx; i++ )

p = p.next;}

else

{ p = endMarker;

for( int i = size( ); i idx; i-- )

p = p.prev; }

return p;}

private void addBefore( NodeAnyType p, AnyType x ) {

NodeAnyType newNode = new NodeAnyType( x, p.prev, p );

newNode.prev.next = newNode;

p.prev = newNode;

theSize++;}

public AnyType remove( int idx ){

return remove( getNode(idx));}

private AnyType remove(NodeAnyType p){

p.next.prev = p.prev;

p.prev.next = p.next;

theSize--;

return p.data;}

public void print(){//输出链表

for(NodeAnyTypex=beginMarker.next;x.next!=beginMarker;x=x.next)

System.out.print(x.data+" ");

System.out.print("\n");}

public AnyType get( int idx ){

return getNode( idx ).data; }

public static void main(String[] args){

MyLinkedListInteger La = new MyLinkedListInteger();

int Length;

Scanner sc = new Scanner(System.in);

System.out.println("请输入要创建的双向链表的长度：(大于6)");

Length = sc.nextInt();

System.out.println("请输入"+Length+"个元素创建La双向链表：");

for(int i=0;iLength;i++)

{La.add(sc.nextInt());}

System.out.println("输入的原La双向链表：");

La.print();

System.out.println("在双向链表的第3个位置插入20:");

La.add(3,20);

La.print();

System.out.println("删除第五位置上的数:");

La.remove(5);

La.print();

System.out.println("插入最后一个节点:99");

La.add(Length,99);

La.print();

System.out.println("插入第一个节点0:");

La.add(0,0);

La.print();

System.out.println("就地逆置:");

int M=Length+2;

int b=0;

for(Length=Length+1;Length=0;Length--){

int a=La.get(M-1);

La.add(b,a);

b=b+1;

La.remove(M);

}

La.print();

}

}

用java来编写一个单链表类的成员函数，实现对头结点的单链表就地逆置的操作

逆置有两种方法，第一是把所有节点反过来。还有一种就是改变节点中的值。

第一种情况，其实可以考虑用头插法，来实现逆置。

下面的算法是基于头插法的思想，逆置链表的，仅供参考。

LinkList anti_linklist(LinkList demo)

{

LInkList *p,*q;//work pointer

LinkList head;

head=new LinkList();

head-next=null;//init head pointer

p=demo-head-next;//make p points to the first node

if(p==null)

return null;//the linklist is null

while(p!=null)

{

q=p;

q-next=head-next;

head-next=q;

p=p-next;

}

}

关于算法旋转链表java和链表的转置算法的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。