笔试java--链表
package java_basic;
import java.util.ArrayList;
import java.util.Stack;
/**
* 从尾到头遍历链表 输入一个链表，按链表值从尾到头的顺序返回一个ArrayList
*
* @author Administrator
*/
class ListNode {// 单链表节点构建 //不能是public
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}
public class java_链表_1 {
static ListNode head = null;// 创建一个头节点
public static void main(String[] args) {
addNode(1);
addNode(2);
addNode(3);
addNode(4);
addNode(5);
addNode(6);
//逆序打印
System.out.println("输出逆序链表：");
ArrayList<Integer> list = printListFromTailToHead(head);// 没有改变链表的顺序
System.out.println(list);
// 反转
ListNode invListNode= ReverseIteratively_ws(head);// 改变顺序
System.out.println(invListNode.val);
System.out.println(invListNode.next.val);
printListReversely(invListNode);//没有改变顺序，只是用递归方式打印
// System.out.println("先逆置，再输出：");
}
// 队列和栈是一对好基友，从尾到头打印链表，当然离不开借助栈的帮忙啦
// 所以，先把链表里的东西，都放到一个栈里去，然后按顺序把栈里的东西pop出来，就这么简单
public static ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
Stack<Integer> stack = new Stack<Integer>();
while (listNode != null) {
stack.push(listNode.val);
listNode = listNode.next;
}
ArrayList<Integer> list = new ArrayList<Integer>();
while (!stack.isEmpty()) {
list.add(stack.pop());
}
return list;
}
// input
public static void addNode(int d) {
// System.out.println("add-begin:"+d);
ListNode newNode = new ListNode(d);
if (head == null) {
head = newNode;
//return;
// ws加的，如果不加return,那么，执行tmp.next=newNode的时候，会将next指针指向自己，
//或是加个else，呀么执行head==null时的，要么执行head!=null的条件
} else {
ListNode tmp = head;
while (tmp.next != null) {
// System.out.println("tmp.next != null");
// System.out.println("tmp:"+tmp);
// System.out.println("tmp.next:"+tmp.next);
tmp = tmp.next;
}
tmp.next = newNode;
// System.out.println("tmp.next.val:"+ tmp.next.val);
}
// System.out.println("add-end:"+d);
}
// delete
public boolean deleteNode(int index) {
if (index < 1 || index > length()) {
return false;// 如果当前index在链表中不存在
}
if (index == 1) {// 如果index指定的是头节点
head = head.next;
return true;
}
int i = 2;
ListNode preNode = head;// 前一个节点（从头节点开始）
ListNode curNode = preNode.next;// 当前节点
while (curNode != null) {
if (i == index) {
preNode.next = curNode.next;// 删除当节点，前节点连接到下节点
return true;
}
preNode = curNode;
curNode = curNode.next;
i++;
}
return false;
}
// 返回节点长度
public int length() {
int length = 0;
ListNode tmp = head;
while (tmp != null) {
length++;
tmp = tmp.next;
}
return length;
}
// 链表反转
public ListNode ReverseIteratively(ListNode head) {
ListNode pReversedHead = head;
ListNode pNode = head;
ListNode pPrev = null;
while (pNode != null) {
ListNode pNext = pNode.next;
if (pNext == null) {
pReversedHead = pNode;
}
pNode.next = pPrev;//
pPrev = pNode;//
pNode = pNext;//
}
this.head = pReversedHead;
return this.head;
}
// 链表反转-ws
public static ListNode ReverseIteratively_ws(ListNode head) {
ListNode pNext=null;
ListNode pNewHead = null;
ListNode pReversedHead = null;
ListNode pNode = head;
while (pNode != null) {
pNext = pNode.next;
// pNode是从原链表拿下来，并放到新链表的那个被转移的节点
pNode.next = pNewHead;// ws 把原来新链表的头结点 拼到pNode上
pNewHead = pNode;// ws pNewHead头衔易主，pNewHead是pNewHead，即新链表的头节点点，
pNode = pNext;//ws pNode的头衔易主，pNext这个元素称为新的pNode，，，，pNode是原来链表的头节点
}
head=pNewHead;
return head;
}
// 查找单链表的中间节点
public ListNode SearchMid(ListNode head) {
ListNode p = this.head, q = this.head;
while (p != null && p.next != null && p.next.next != null) {
p = p.next.next;
q = q.next;
}
System.out.println("Mid:" + q.val);
return q;
}
// 查找倒数 第k个元素
public ListNode findElem(ListNode head, int k) {
if (k < 1 || k > this.length()) {
return null;
}
ListNode p1 = head;
ListNode p2 = head;
for (int i = 0; i < k; i++)
// 前移k步
p1 = p1.next;
while (p1 != null) {
p1 = p1.next;
p2 = p2.next;
}
return p2;
}
// 排序
public ListNode orderList() {
ListNode nextNode = null;
int tmp = 0;
ListNode curNode = head;
while (curNode.next != null) {
nextNode = curNode.next;
while (nextNode != null) {
if (curNode.val > nextNode.val) {
tmp = curNode.val;
curNode.val = nextNode.val;
nextNode.val = tmp;
}
nextNode = nextNode.next;
}
curNode = curNode.next;
}
return head;
}
// 从尾到头输出单链表，采用递归方式实现
public static void printListReversely(ListNode pListHead) {
if (pListHead != null) {
printListReversely(pListHead.next);
System.out.println("printListReversely:" + pListHead.val);
}
}
// 判断链表是否有环，单向链表有环时，尾节点相同
public boolean IsLoop(ListNode head) {
ListNode fast = head, slow = head;
if (fast == null) {
return false;
}
while (fast != null && fast.next != null) {
fast = fast.next.next;
slow = slow.next;
if (fast == slow) {
System.out.println("该链表有环");
return true;
}
}
return !(fast == null || fast.next == null);
}
// 找出链表环的入口
public ListNode FindLoopPort(ListNode head) {
ListNode fast = head, slow = head;
while (fast != null && fast.next != null) {
slow = slow.next;
fast = fast.next.next;
if (slow == fast)
break;
}
if (fast == null || fast.next == null)
return null;
slow = head;
while (slow != fast) {
slow = slow.next;
fast = fast.next;
}
return slow;
}
}// class
-
------------------------------------------------------------------------------------------------------------
package java_basic;
//--------------------------test---------------------------------
public class java_链表_2 {
public static void main(String[] args) {
LinkList linkList = new LinkList();
linkList.addFirstNode("A");// 作为第一个，放上去
linkList.addFirstNode("B");
linkList.addFirstNode("C");
linkList.add(1, "D");
linkList.add(2, "E");
linkList.add(3, "F");
linkList.addLastNode("Z1");
linkList.displayAllNodes();
//
Node node = linkList.deleteByData("A");
System.out.println("node : " + node.data);
linkList.displayAllNodes();
Node node1 = linkList.findByPos(0);
System.out.println("node1: " + node1.data);
Node node2 = linkList.findByData("E");
System.out.println("node2: " + node2.data);
}
}// class
// ---------------定义链表的节点类--------------
class Node {
Node next; // 下一节点
String data;// 数据
public Node(String data) {
this.data = data;
}
// 显示此节点
public void show() {
System.out.print(data + "、");
}
}
// ----------------- 定义链表类及其操作方法-----------------
class LinkList {
public Node first; // 定义头结点
private int pos = 0;// 节点的位置
public LinkList() {
this.first = null;
}
// ws:
public void addLastNode(String string) {
Node newNode = new Node(string);
if (first == null) {
first = newNode;
} else {
Node node=first;
while(node.next!=null){
node=node.next;
}
node.next=newNode;
}
}
// 插入一个头节点
public void addFirstNode(String data) {
Node node = new Node(data);
node.next = first;
first = node;
}
// 删除一个头结点,并返回头结点
public Node deleteFirstNode() {
Node tempNode = first;
first = tempNode.next;
return tempNode;
}
// 在任意位置插入节点 在index的后面插入
public void add(int index, String data) {
Node node = new Node(data);
Node current = first;
Node previous = first;
while (pos != index) {
previous = current;
current = current.next;
pos++;
}
node.next = current;
previous.next = node;
pos = 0;
}
// 删除任意位置的节点
public Node deleteByPos(int index) {
Node current = first;
Node previous = first;
while (pos != index) {
pos++;
previous = current;
current = current.next;
}
if (current == first) {
first = first.next;
} else {
pos = 0;
previous.next = current.next;
}
return current;
}
// 根据节点的data删除节点(仅仅删除第一个)
public Node deleteByData(String data) {
Node current = first;
Node previous = first; // 记住上一个节点
while (current.data != data) {
if (current.next == null) {
return null;
}
previous = current;
current = current.next;
}
if (current == first) {
first = first.next;
} else {
previous.next = current.next;
}
return current;
}
// 显示出所有的节点信息
public void displayAllNodes() {
Node current = first;
while (current != null) {
current.show();
current = current.next;
}
System.out.println();
}
// 根据位置查找节点信息
public Node findByPos(int index) {
Node current = first;
if (pos != index) {
current = current.next;
pos++;
}
return current;
}
// 根据数据查找节点信息
public Node findByData(String data) {
Node current = first;
while (current.data != data) {
if (current.next == null)
return null;
current = current.next;
}
return current;
}
}
笔试java--链表相关推荐
- JAVA链表中迭代器的实现
注:本文代码出自<java数据结构和算法>一书. PS:本文中类的名字定义存在问题,Link9应改为Link.LinkList9应该为LinkList.由于在同包下存在该名称,所以在后面接 ...
- java 增 删 查 改_如何对java链表进行增、删、查、改操作
如何对java链表进行增.删.查.改操作 发布时间:2020-06-23 10:41:33 来源:亿速云 阅读:79 作者:Leah 如何对java链表进行增.删.查.改操作?针对这个问题,今天小编总 ...
- java链表奇数倒序偶数顺序_将链表中的所有元素为奇数的节点移到元素为偶数节点的前面，并保证奇数之间顺序不变，偶数之间顺序不变。...
2.将链表中的所有元素为奇数的节点移到元素为偶数节点的前面,并保证奇数之间顺序不变,偶数之间顺序不变. 示例: 交换前链表的顺序 交换后链表的顺序 4→5→3→1→2 == ...
- 亚信科技笔试java
亚信科技笔试java base上海 选择题有java基础.jsp.web.linux.数据结构 1. java的核心包 2. 字符串拼接 3. 实现Runable接口,run方法和start方法 4. ...
- 对java 链表删除节点 引用误区理解：对局部变量 cur= cur.next及cur.next=cur.next.next,及cur.next = cur.next.next.next的理解图解
对java 链表删除节点 引用误区理解: 对java 链表删除节点 引用误区理解: 对局部变量 cur= cur.next及cur.next=cur.next.next,及cur.next = cur ...
- 上海汉得校招笔试-Java
上海汉得校招笔试-Java 一.单项选择题(2分/题,共20分) 二.多项选择题 (4分/题,共20分) 三.填空题(4分/题,共20分) 四.简答题(5分/题,共20分) 五.编程题(20分) 一. ...
- 普元信息笔试java
普元信息笔试java base北京 选择题.填空题.简答题混合的形式 1. TreeSet.HashMap是有序.无序还是排序 这里选的TreeSet排序.HashMap无序 2. linux强制删除 ...
- 【笔试】三七互娱笔试 JAVA服务端
博主前天做了三七互娱的web后端工程师方向的笔试,下面的链接为笔试后的总结: https://blog.csdn.net/applying/article/details/80587129 然后第二天 ...
- java链表list_java集合之linkedList链表基础
LinkedList链表: List接口的链接列表实现.允许存储所有元素(包含null).使用频繁增删元素. linkedList方法: void addFirst(E e) 指定元素插入列表的开头 ...
- java单链表例子_写一个java链表的例子？随便举例说一下。
展开全部 //单链表类 package dataStructure.linearList; import dataStructure.linearList.Node; //导入单链表结点类 impor ...
最新文章
- 【高级数据类型2】- 10. 接口
- ubuntu 配置dns访问外网
- Linux学习：shell 命令（软件安装和卸载）
- 实验7.2 二维数组 7-4 判断上三角矩阵
- 怎么用python读取大文件_使用Python读取大文件的方法
- gradle 上传jar包_Gradle学习记录014 关于依赖的声明
- mysql示例数据库
- EasyUI笔记（六）数据表格
- NEW:SlickEdit Pro 27.0 KEY
- maven下载安装及配置
- 服务器状态显示异常,进lol显示服务器异常请稍后再试
- Linux正则表达式grep,egrep 及相应的正则表达式用法详解
- 蓝桥杯 方格问题 6x6的方格，沿着格子的边线剪开成两部分。 要求这两部分的形状完全相同
- 2023中国人民公安大学计算机考研信息汇总
- HTML文字阴影火焰,本教程火焰字效果非常逼真
- 【已开源】Flutter 穿山甲广告插件的集成-FlutterAds
- 分析classpath、path、JAVA_HOME的作用及JAVA环境变量配置（转发博客园）
- 24C01SC芯片介绍
- sysvol 域控制器 文件_[转载]重建域控制器上的SYSVOL和NETLOGON共享
- ubuntu上安装视频插件