Algorithms/JavaAlgorithms
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add linked list sorting (#2882)

Browse Source 
Co-authored-by: Andrii Siriak <siryaka@gmail.com>
This commit is contained in:
Siddhant Swarup Mallick 2022-01-20 01:05:43 +05:30 committed by GitHub
parent 76fbe7c9e9
commit 857c4aafb2
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 386 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

322
src/main/java/com/thealgorithms/sorts/LinkList_Sort.java Normal file
View File

@ -0,0 +1,322 @@
/** Author : Siddhant Swarup Mallick
* Github : https://github.com/siddhant2002
*/
/** Program description - To sort the LinkList as per sorting technique */
package com.thealgorithms.sorts;
import java.util.*;
public class LinkList_Sort {
public static boolean isSorted(int p[] , int option) {
try (Scanner sc = new Scanner(System.in)) {
}
int a[] = p;
// Array is taken as input from test class
int b[] = p;
// array similar to a
int ch = option;
// Choice is choosed as any number from 1 to 3 (So the linked list will be sorted by Merge sort technique/Insertion sort technique/Heap sort technique)
switch (ch) {
case 1:
Task nm = new Task();
Node start = null, prev = null, fresh, ptr;
for (int i = 0; i < a.length; i++) {
// New nodes are created and values are added
fresh = new Node(); // Node class is called
fresh.val = a[i]; // Node val is stored
if (start == null)
start = fresh;
else
prev.next = fresh;
prev = fresh;
}
start = nm.sort_by_mergesort(start);
// method is being called
int i=0;
for (ptr = start;ptr != null; ptr = ptr.next) {
a[i++]=ptr.val;
// storing the sorted values in the array
}
Arrays.sort(b);
// array b is sorted and it will return true when checked with sorted list
LinkList_Sort uu=new LinkList_Sort();
if(uu.compare(a,b))
{
return true;
}
else
{
return false;
}
// The given array and the expected array is checked if both are same then true is displayed else false is displayed
case 2:
Node start1 = null, prev1 = null, fresh1, ptr1;
for (int i1 = 0; i1 < a.length; i1++) {
// New nodes are created and values are added
fresh1 = new Node(); // New node is created
fresh1.val = a[i1]; // Value is stored in the value part of the node
if (start1 == null)
start1 = fresh1;
else
prev1.next = fresh1;
prev1 = fresh1;
}
Task1 kk = new Task1();
start1 = kk.sort_by_insertionsort(start1);
// method is being called
int i1=0;
for (ptr1 = start1; ptr1 != null; ptr1 = ptr1.next) {
a[i1++]=ptr1.val;
// storing the sorted values in the array
}
LinkList_Sort uu1=new LinkList_Sort();
// array b is not sorted and it will return false when checked with sorted list
if(uu1.compare(a,b))
{
return true;
}
else
{
return false;
}
// The given array and the expected array is checked if both are same then true is displayed else false is displayed
case 3:
Task2 mm = new Task2();
Node start2 = null, prev2 = null, fresh2, ptr2;
for (int i2 = 0; i2 < a.length; i2++) {
// New nodes are created and values are added
fresh2 = new Node(); // Node class is created
fresh2.val = a[i2]; // Value is stored in the value part of the Node
if (start2 == null)
start2 = fresh2;
else
prev2.next = fresh2;
prev2 = fresh2;
}
start2 = mm.sort_by_heapsort(start2);
// method is being called
int i3=0;
for (ptr2 = start2; ptr2 != null; ptr2 = ptr2.next) {
a[i3++]=ptr2.val;
// storing the sorted values in the array
}
Arrays.sort(b);
// array b is sorted and it will return true when checked with sorted list
LinkList_Sort uu2=new LinkList_Sort();
if(uu2.compare(a,b))
{
return true;
}
else
{
return false;
}
// The given array and the expected array is checked if both are same then true is displayed else false is displayed
default:
// default is used incase user puts a unauthorized value
System.out.println("Wrong choice");
}
// Switch case is used to call the classes as per the user requirement
return false;
}
boolean compare(int a[] , int b[])
{
for(int i=0;i<a.length;i++)
{
if(a[i]!=b[i])
return false;
}
return true;
// Both the arrays are checked for equalness. If both are equal then true is returned else false is returned
}
/**
* OUTPUT :
* Input - {89,56,98,123,26,75,12,40,39,68,91} is same for all the 3 classes
* Output: [12 26 39 40 56 68 75 89 91 98 123] is same for all the 3 classes
* 1st approach Time Complexity : O(n logn)
* Auxiliary Space Complexity : O(n)
* 2nd approach Time Complexity : O(n^2)
* Auxiliary Space Complexity : O(n)
* 3rd approach Time Complexity : O(n logn)
* Auxiliary Space Complexity : O(n)
*/
}
class Node {
int val;
Node next;
// Node class for creation of linklist nodes
}
class Task {
static int a[];
public Node sort_by_mergesort(Node head) {
if (head == null || head.next == null)
return head;
int c = count(head);
a = new int[c];
// Array of size c is created
int i = 0;
for (Node ptr = head; ptr != null; ptr = ptr.next) {
a[i++] = ptr.val;
}
// values are stored in the array
i = 0;
task(a, 0, c - 1);
// task method will be executed
for (Node ptr = head; ptr != null; ptr = ptr.next) {
ptr.val = a[i++];
// Value is stored in the linklist after being sorted
}
return head;
}
int count(Node head) {
int c = 0;
Node ptr;
for (ptr = head; ptr != null; ptr = ptr.next) {
c++;
}
return c;
// This Method is used to count number of elements/nodes present in the linklist
// It will return a integer type value denoting the number of nodes present
}
void task(int n[], int i, int j) {
if (i < j) {
int m = (i + j) / 2;
task(n, i, m);
task(n, m + 1, j);
task1(n, i, m, j);
// Array is halved and sent for sorting
}
}
void task1(int n[], int s, int m, int e) {
int i = s, k = 0, j = m + 1;
int b[] = new int[e - s + 1];
while (i <= m && j <= e) {
if (n[j] >= n[i])
b[k++] = n[i++];
else
b[k++] = n[j++];
}
// Smallest number is stored after checking from both the arrays
while (i <= m) {
b[k++] = n[i++];
}
while (j <= e) {
b[k++] = n[j++];
}
for (int p = s; p <= e; p++) {
a[p] = b[p - s];
}
}
// The method task and task1 is used to sort the linklist using merge sort
}
class Task1 {
public Node sort_by_insertionsort(Node head) {
if (head == null || head.next == null)
return head;
int c = count(head);
int a[] = new int[c];
// Array of size c is created
a[0] = head.val;
int i;
Node ptr;
for (ptr = head.next, i = 1; ptr != null; ptr = ptr.next, i++) {
int j = i - 1;
while (j >= 0 && a[j] > ptr.val) {
// values are stored in the array
a[j + 1] = a[j];
j--;
}
a[j + 1] = ptr.val;
}
i = 0;
for (ptr = head; ptr != null; ptr = ptr.next) {
ptr.val = a[i++];
// Value is stored in the linklist after being sorted
}
return head;
}
static int count(Node head) {
Node ptr;
int c = 0;
for (ptr = head; ptr != null; ptr = ptr.next) {
c++;
}
return c;
// This Method is used to count number of elements/nodes present in the linklist
// It will return a integer type value denoting the number of nodes present
}
// The method task and task1 is used to sort the linklist using insertion sort
}
class Task2 {
static int a[];
public Node sort_by_heapsort(Node head) {
if (head == null || head.next == null)
return head;
int c = count(head);
a = new int[c];
// Array of size c is created
int i = 0;
for (Node ptr = head; ptr != null; ptr = ptr.next) {
a[i++] = ptr.val;
// values are stored in the array
}
i = 0;
task(a);
for (Node ptr = head; ptr != null; ptr = ptr.next) {
ptr.val = a[i++];
// Value is stored in the linklist after being sorted
}
return head;
}
int count(Node head) {
int c = 0;
Node ptr;
for (ptr = head; ptr != null; ptr = ptr.next) {
c++;
}
return c;
// This Method is used to count number of elements/nodes present in the linklist
// It will return a integer type value denoting the number of nodes present
}
void task(int n[]) {
int k = n.length;
for (int i = k / 2 - 1; i >= 0; i--) {
task1(n, k, i);
}
for (int i = k - 1; i > 0; i--) {
int d = n[0];
n[0] = n[i];
n[i] = d;
task1(n, i, 0);
// recursive calling of task1 method
}
}
void task1(int n[], int k, int i) {
int p = i;
int l = 2 * i + 1;
int r = 2 * i + 2;
if (l < k && n[l] > n[p])
p = l;
if (r < k && n[r] > n[p])
p = r;
if (p != i) {
int d = n[p];
n[p] = n[i];
n[i] = d;
task1(n, k, p);
}
}
// The method task and task1 is used to sort the linklist using heap sort
}

64
src/test/java/com/thealgorithms/others/LinkList_Sort_test.java Normal file
View File

@ -0,0 +1,64 @@
package com.thealgorithms.others;
import org.junit.jupiter.api.Test;
import com.thealgorithms.sorts.LinkList_Sort;
import static org.junit.jupiter.api.Assertions.*;
public class LinkList_Sort_test {
@Test
void testForOneElement()
{
int a[]={56};
assertTrue(LinkList_Sort.isSorted(a,2));
}
@Test
void testForTwoElements()
{
int a[]={6,4};
assertTrue(LinkList_Sort.isSorted(a,1));
}
@Test
void testForThreeElements()
{
int a[]={875,253,12};
assertTrue(LinkList_Sort.isSorted(a,3));
}
@Test
void testForFourElements()
{
int a[]={86,32,87,13};
assertFalse(LinkList_Sort.isSorted(a,2));
}
@Test
void testForFiveElements()
{
int a[]={6,5,3,0,9};
assertTrue(LinkList_Sort.isSorted(a,1));
}
@Test
void testForSixElements()
{
int a[]={9,65,432,32,47,327};
assertTrue(LinkList_Sort.isSorted(a,3));
}
@Test
void testForSevenElements()
{
int a[]={6,4,2,1,3,6,7};
assertTrue(LinkList_Sort.isSorted(a,1));
}
@Test
void testForEightElements()
{
int a[]={123,234,145,764,322,367,768,34};
assertFalse(LinkList_Sort.isSorted(a,2));
}
}