📌  相关文章
📜  数据结构示例-循环链表的元素排序

📅  最后修改于: 2020-10-15 06:22:56             🧑  作者: Mango

问：程序来排序循环链表的元素。

说明

在此程序中，我们将创建一个循环链接列表，并按升序对列表进行排序。在此示例中，我们维护两个节点：current将指向head的节点和index将指向current的下一个节点。第一个循环跟踪当前，第二个循环跟踪索引。在第一个迭代中，当前将指向9。索引将指向当前旁边的节点，在本例中为5。将9与5进行比较，因为9> 5，将索引节点的数据与当前节点交换。现在，当前将有5。现在，将5与2作比较。再次5> 2，交换数据。现在，电流将保持2，索引将保持7。2 <7，将不会执行任何操作。索引将增加并指向3。2 <3。将不执行任何操作。这样，我们将在第一个位置具有一个最小值节点。然后，我们将继续在列表的其余部分中查找最小元素，直到列表完全排序为止。

9-> 5-> 2-> 7-> 3 2-> 9-> 5-> 7-> 3 2-> 3-> 9-> 7-> 5 2-> 3-> 5-> 9- > 7 2-> 3-> 5-> 7-> 9

算法

  • 定义一个Node类，该类代表列表中的一个节点。它具有两个属性数据，下一个将指向下一个节点。
  • 定义另一个用于创建循环链接列表的类，它具有两个节点：head和tail。
  • sortList()将对列表进行排序：
    1. 我们将保持两个节点当前指向头，索引将指向当前节点旁边。
    2. 从索引开始遍历列表，直至到达末尾。
    3. 如果current.data大于index.data，请在它们之间交换数据。
    4. 在第一次迭代中，我们将在列表的开头获得最小的元素。
    5. 然后，当前将指向current.next。
    6. 重复步骤b到e，直到获得下一个最小节点。
    7. 在两个循环的末尾，将对列表进行排序。

示例：

Python

#Represents the node of list.
class Node:
    def __init__(self,data):
        self.data = data;
        self.next = None;

class CreateList:
    #Declaring head and tail pointer as null.
    def __init__(self):
        self.head = Node(None);
        self.tail = Node(None);
        self.head.next = self.tail;
        self.tail.next = self.head;
    
    #This function will add the new node at the end of the list.
    def add(self,data):
        newNode = Node(data);
        #Checks if the list is empty.
        if self.head.data is None:
            #If list is empty, both head and tail would point to new node.
            self.head = newNode;
            self.tail = newNode;
            newNode.next = self.head;
        else:
            #tail will point to new node.
            self.tail.next = newNode;
            #New node will become new tail.
            self.tail = newNode;
            #Since, it is circular linked list tail will point to head.
            self.tail.next = self.head;
    
    #This function sorts the list in ascending order
    def sortList(self):
        #Current will point to head
        current = self.head;
        if(self.head == None):
            print("List is empty");
        else:
            while(True):
                #Index will point to node next to current
                index = current.next;
                while(index != self.head):
                    #If current node is greater than index data, swaps the data
                    if(current.data > index.data):
                        temp = current.data;
                        current.data = index.data;
                        index.data = temp;
                    index= index.next;
                current =current.next;
                if(current.next == self.head):
                    break;
                    
    #Displays all the nodes in the list
    def display(self):
        current = self.head;
        if self.head is None:
            print("List is empty");
            return;
        else:
            #Prints each node by incrementing pointer.
            print(current.data, end= ' ');
            while(current.next != self.head):
                current = current.next;
                print(current.data,end=' ');
        print("\n");
            
class CircularLinkedList:
    cl = CreateList();
    #Adds data to the list
    cl.add(70);
    cl.add(90);
    cl.add(20);
    cl.add(100);
    cl.add(50);
    
    #Displaying original list
    print("Original list: ");
    cl.display();
    
    #Sorting list
    cl.sortList();
    
    #Displaying sorted list
    print("Sorted list: ");
    cl.display();

输出：

Original list: 
 70 90 20 100 50
Sorted list: 
 20 50 70 90 100

C

#include 
#include 
#include 

//Represents the node of the list.

struct node{
    int data;
    struct node *next;
};

//Declaring head and tail pointer as null.
struct node *head = NULL;
struct node *tail = NULL;

//This function will add the new node at the end of the list.
void add(int data){
    //Create new node
    struct node *newNode = (struct node*)malloc(sizeof(struct node));
    newNode->data = data;
    //Checks if the list is empty.
    if(head == NULL){
        //If list is empty, both head and tail would point to new node.
        head = newNode;
        tail = newNode;
        newNode->next = head;
    }else {
        //tail will point to new node.
tail->next = newNode;
//New node will become new tail.
tail = newNode;
//Since, it is circular linked list tail will point to head.
tail->next = head;
}
}

//This function sorts the list in ascending order
void sortList() {
//Current will point to head
struct node *current = head, *index = NULL;
int temp;
if(head == NULL) {
printf("List is empty");
}
else {
do{
//Index will point to node next to current
index = current->next;
while(index != head) {
//If current node is greater than index data, swaps the data
if(current->data > index->data) {
temp =current->data;
current->data= index->data;
index->data = temp;
}
index= index->next;
}
current =current->next;
}while(current->next != head); 
}
}
//This function will display the nodes of circular linked list
void display(){
    struct node *current = head;
    if(head == NULL){
        printf("List is empty");
    }
    else{
do{
     //Prints each node by incrementing pointer.
printf("%d ", current->data);
current = current->next;
}while(current != head);
printf("\n");
    }
}
    
int main()
{
   //Adds data to the list
   add(70);
   add(90);
   add(20);
   add(100);
   add(50);
   //Displaying original list
   printf("Original list: \n");
   display();
   //Sorting list
   sortList();
   //Displaying sorted list
   printf("Sorted list: \n");
   display();
   
   return 0;
}

输出：

Original list: 
 70 90 20 100 50
Sorted list: 
 20 50 70 90 100

JAVA

public class SortList {
//Represents the node of list.
public class Node{
int data;
Node next;
public Node(int data) {
this.data = data;
}
}
//Declaring head and tail pointer as null.
public Node head = null;
public Node tail = null;
//This function will add the new node at the end of the list.
public void add(int data){
//Create new node
Node newNode = new Node(data);
//Checks if the list is empty.
if(head == null) {
 //If list is empty, both head and tail would point to new node.
head = newNode;
tail = newNode;
newNode.next = head;
}
else {
//tail will point to new node.
tail.next = newNode;
//New node will become new tail.
tail = newNode;
//Since, it is circular linked list tail will points to head.
tail.next = head;
}
}
//This function sorts the list in ascending order
public void sortList() {
//Current will point to head
Node current = head, index = null;
int temp;
if(head == null) {
System.out.println("List is empty");
}
else {
do{
//Index will point to node next to current
index = current.next;
while(index != head) {
//If current node is greater than index data, swaps the data
if(current.data > index.data) {
temp =current.data;
current.data= index.data;
index.data = temp;
}
index= index.next;
}
current =current.next;
}while(current.next != head); 
}
}
//Displays all the nodes in the list
public void display() {
Node current = head;
if(head == null) {
System.out.println("List is empty");
}
else {
 do{
//Prints each node by incrementing pointer.
System.out.print(" "+ current.data);
current = current.next;
}while(current != head);
System.out.println();
}
}
public static void main(String[] args) {
SortList cl = new SortList();
//Adds data to the list
cl.add(70);
cl.add(90);
cl.add(20);
cl.add(100);
cl.add(50);
//Displaying original list
System.out.println("Original list: ");
cl.display();
//Sorting list
cl.sortList();
//Displaying sorted list
System.out.println("Sorted list: ");
cl.display();
}
}

输出：

Original list: 
 70 90 20 100 50
Sorted list: 
 20 50 70 90 100

C＃

using System; 
namespace CircularLinkedList 
{  
public class Program
{
//Represents the node of list.
public class Node{
public T data;
public Node next;
public Node(T value) {
data = value;
next = null;
}
}
public class CreateList  where T : IComparable {
protected Node head = null;             
  protected Node tail = null;
//This function will add the new node at the end of the list.
public void add(T data){
//Create new node
Node newNode = new Node(data);
//Checks if the list is empty.
if(head == null){
head = newNode;
tail = newNode;
newNode.next = head;
}else{
//tail will point to new node.
tail.next = newNode;
//New node will become new tail.
tail = newNode;
//Since, it is circular linked list tail will point to head.
tail.next = head;
}
}
//This function sorts the list in ascending order
public void sortList() {
//Current will point to head
Node current = head, index = null;
T temp;
if(head == null) {
Console.WriteLine("List is empty");
}
else {
do{
//Index will point to node next to current
index = current.next;
while(index != head) {
//If current node is greater than index data, swaps the data
if(current.data.CompareTo(index.data) > 0) {
temp = current.data;
current.data= index.data;
index.data = temp;
}
index= index.next;
}
current =current.next;
}while(current.next != head); 
}
}
//Displays all the nodes in the list
public void display(){
Node current = head;
if(head == null){
Console.WriteLine("List is empty");
}
else{
 do{
//Prints each node by incrementing pointer.
Console.Write(" "+ current.data);
current = current.next;
}while(current != head);
Console.WriteLine();
}
} 
}
public static void Main()
{
CreateList cl = new CreateList();
//Adds data to the list
cl.add(70);
cl.add(90);
cl.add(20);
cl.add(100);
cl.add(50);
//Displaying original list
Console.WriteLine("Original list: ");
cl.display();
//Sorting list
cl.sortList();
//Displaying sorted list
Console.WriteLine("Sorted list: ");
cl.display();
} 
}
}

输出：

Original list: 
 70 90 20 100 50
Sorted list: 
 20 50 70 90 100

PHP：




data = $data;
        $this->next = NULL;
    }
}
class CreateList{
    //Declaring head and tail pointer as null.
    private $head;
    private $tail;
    function __construct(){
        $this->head = NULL;
        $this->tail = NULL;
    }
    //This function will add the new node at the end of the list.
    function add($data){
        //Create new node
        $newNode = new Node($data);
        //Checks if the list is empty.
        if($this->head == NULL){
            //If list is empty, both head and tail would point to new node.
            $this->head = $newNode;
            $this->tail = $newNode;
            $newNode->next = $this->head;
        }
        else{
            //tail will point to new node.
            $this->tail->next = $newNode;
            //New node will become new tail.
            $this->tail = $newNode;
            //Since, it is circular linked list tail will point to head.
            $this->tail->next = $this->head;
        }
    }
    
    //This function sorts the list in ascending order
function sortList() {
//Current will point to head
$current = $this->head;
if($this->head == NULL) {
echo "List is empty";
}
else {
do{
//Index will point to node next to current
$index = $current->next;
while($index != $this->head) {
//If current node is greater than index data, swaps the data
if($current->data > $index->data) {
$temp = $current->data;
$current->data= $index->data;
$index->data = $temp;
}
$index= $index->next;
}
$current = $current->next;
}while($current->next != $this->head); 
}
}
    
    //Displays all the nodes in the list
    function display() {
        $current = $this->head;
        if($this->head == NULL) {
            echo "List is empty";
        }
        else {
             do{
                //Prints each node by incrementing pointer.
                echo(" $current->data");
                $current = $current->next;
            }while($current != $this->head);
            echo "
";
        }
    }   
}
$cl = new CreateList();
//Adds data to the list
$cl->add(70);
$cl->add(90);
$cl->add(20);
$cl->add(100);
$cl->add(50);

//Displaying original list
echo "Original list:
";
$cl->display();

//Sorting list
$cl->sortList();

//Displaying sorted list
echo "Sorted list:
";
$cl->display();
?>

输出：

Original list: 
 70 90 20 100 50
Sorted list: 
 20 50 70 90 100