每日一题 为了工作 2020 0324 第二十二题
/**
* 题目：将单向链表按某值划分成左边小、中间相等、右边大的形式(进阶)
*
* 要求：
* 给定一个单向链表的头节点 head, 节点的值类型是整型， 再给定一个整数 pivot。实现
*一个调整链表的函数， 将链表调整为左部分都是值小于pivot的节点， 中间部分都是值等于pivot
*的节点， 右部分都是值大于pivot的节点。除这个要求外， 对调整后的节点顺序没有更多的要求。
*例如： 链表 9->0->4->5->1, pivot=3。同时区域节点要求有序，即为 0->1->4->5->9。
* 给定的时间复杂度为O(N)，额外空间复杂度为 O(1),
*
* 分析：
* 由于对每部分都增加了节点顺序要求， 同时时间复杂度仍然为O(N),额外空间复杂度为0(1)。
*既然额外空间复杂度为0(1), 说明实现时只能使用有限的几个变量来完成所有的调整。
*
*进阶解法的具体过程如下：
*1.将原链表中的所有节点依次划分进三个链表， 三个链表分别为small代表左部分，equal代表中间部分， big代表右部分。
*
*例如， 链表7->9-> 1->8->5->2->5, pivot=5。在划分之后， small、equal、big分别为：
* small: 1->2->null
* equal: 5->5->null
* big: 7->9->8->null
*2. 将 small、equal和 big三个链表重新串起来即可。
*3. 整个过程需要特别注意对null节点的判断和处理。
* @author 雪瞳
*
*/
*代码
public class Node {
public int value;
public Node next;
public Node(int data) {
this.value=data;
}
}
public class ListPart {
private ListPart list = null;
public Node listPartNode(Node head,int pivot) {
Node smallHead = null;
Node smallTail = null;
Node equalHead= null;
Node equalTail= null;
Node bigHead= null;
Node bigTail= null;
Node currentNext= null;
//将原链表内的所有节点都放到三个链表内
while(head!=null) {
currentNext = head.next;
head.next=null;
if(head.value < pivot) {
if(smallHead == null) {
smallHead = head;
smallTail = head;
}else {
smallTail.next=head;
smallTail=head;
}
}else if(head.value ==pivot) {
if(equalHead==null) {
equalHead= head;
equalTail = head;
}else {
equalTail.next=head;
equalTail = head;
}
}else {
if(bigHead==null) {
bigHead=head;
bigTail=head;
}else {
bigTail.next=head;
bigTail=head;
}
}
head =currentNext;
}
//链表内部排序
list = new ListPart();
if(smallHead!=null) {
smallHead=list.listArraySwap(smallHead);
}
if(equalHead!=null) {
equalHead=list.listArraySwap(equalHead);
}
if(bigHead!=null) {
bigHead=list.listArraySwap(bigHead);
}
currentNext = smallHead;
while(currentNext.next!=null) {
currentNext=currentNext.next;
}
smallTail = currentNext;
//小的和相等的连接
if(smallTail !=null) {
if(equalHead!=null) {
equalHead=smallTail.next;
}else {
equalHead=smallTail;
equalTail=smallTail;
}
}
//连接所有节点
if(equalTail!=null) {
equalTail.next=bigHead;
}
return smallHead != null?smallHead:(equalHead!=null)?equalHead:bigHead;
}
public Node listArraySwap(Node head) {
Node current =null;
Node nodeArray[] = null;
int length =0;
current =head;
//获取链表长度
while(current!=null) {
length++;
current=current.next;
}
//将链表内元素存入到数组中
nodeArray = new Node[length];
current=head;
for(int i=0;i<nodeArray.length;i++) {
nodeArray[i]=current;
current=current.next;
}
//排序
int i=0;
int j=0;
int currentValue = 0;
int currentNextValue =0;
for(i=0;i<length;i++) {
currentValue=nodeArray[i].value;
for(j=0;j<length;j++) {
currentNextValue=nodeArray[j].value;
if(currentValue<currentNextValue) {
swapElement(nodeArray, i, j);
}
}
}
//连接节点
for(i=1;i!=length;i++) {
nodeArray[i-1].next=nodeArray[i];
}
nodeArray[length-1].next=null;
head = nodeArray[0];
return head;
}
public void swapElement(Node nodeArray[],int a,int b) {
Node transElement = nodeArray[a];
nodeArray[a] = nodeArray[b];
nodeArray[b] = transElement;
}
}
import java.util.Random;
import java.util.Scanner;
public class TestListPart {
public static void main(String[] args) {
ListPart list = new ListPart();
TestListPart test = new TestListPart();
//获取初始信息
Random rand = new Random();
Scanner sc = new Scanner(System.in);
System.out.println("请输入链表长度");
int K = sc.nextInt();
System.out.println("请输入位置元素值");
int privot = sc.nextInt();
//随机生成链表
Node nodes[]=new Node[K];
for(int i=0;i<nodes.length;i++) {
nodes[i]=new Node(rand.nextInt(20)+1);
}
for(int i =0;i<nodes.length-1;i++) {
nodes[i].next=nodes[i+1];
}
Node head = nodes[0];
//test
test.showNode(head);
Node partNode = list.listPartNode(head, privot);
test.showNode(partNode);
}
public void showNode(Node head) {
System.out.println("链表内的元素如下所示...");
while(head != null) {
System.out.print(head.value+"\t");
head = head.next;
}
System.out.println();
}
}
*运行结果
