单链表的三大基础语言（Java、python、c/c++）

        本文总结了在实现单链表上Java、python、c/c++的代码总结。

        本文的单链表包含以下功能：

1. 初始化单链表
2. 头插法尾插法建立单链表
3. 销毁单链表
4. 空表判断
5. 链表输出
6. 链表的增删查
7. 手动输入数据建立链表
8. txt文件读取建立链表（单列数据）
9. excel文件读取建立链表（单列数据）

代码如下：

C/C++

#include <iostream>
#include <fstream> // 用于读取文件
#include <string>
#include <vector> // 用于保存从文件中读取的数据
#include <sstream> // 用于分割字符串
#include <iomanip> // 用于输出Excel数据

using namespace std;

struct ListNode {
    int val;          // 数据域
    ListNode* next;   // 指向下一个节点的指针
    ListNode(int x) : val(x), next(NULL) {}  // 构造函数
};

class LinkedList {
private:
    ListNode *head;   // 头指针

public:
    LinkedList() {
        head = NULL;   // 初始化单链表
    }

    // 头插法构建单链表
    void insertAtHead(int val) {
        ListNode *node = new ListNode(val);
        if (head != NULL) {
            node->next = head;
        }
        head = node;
    }

    // 尾插法构建单链表
    void insertAtTail(int val) {
        ListNode *node = new ListNode(val);
        if (head == NULL) {
            head = node;
        } else {
            ListNode *temp = head;
            while (temp->next != NULL) {
                temp = temp->next;
            }
            temp->next = node;
        }
    }

    // 销毁单链表
    void destroyList() {
        ListNode *temp = head;
        while (temp != NULL) {
            ListNode *tempToDelete = temp;
            temp = temp->next;
            delete tempToDelete;
        }
        head = NULL;
    }

    // 判断是否为空表
    bool isEmpty() {
        return head == NULL;
    }

    // 获取单链表的长度
    int getLength() {
        int length = 0;
        ListNode *temp = head;
        while (temp != NULL) {
            length++;
            temp = temp->next;
        }
        return length;
    }

    // 输出链表
    void printList() {
        ListNode *temp = head;
        while (temp != NULL) {
            cout << temp->val << " ";
            temp = temp->next;
        }
        cout << endl;
    }

    // 按序号求表中元素
    int getElementAtIndex(int index) {
        if (index < 0 || head == NULL) {
            return -1;
        }
        ListNode *temp = head;
        int count = 0;
        while (temp != NULL) {
            if (count == index) {
                return temp->val;
            }
            count++;
            temp = temp->next;
        }
        return -1;
    }

    // 按元素值查找元素
    int search(int val) {
        ListNode *temp = head;
        int index = 0;
        while (temp != NULL) {
            if (temp->val == val) {
                return index;
            }
            index++;
            temp = temp->next;
        }
        return -1;
    }

    // 在指定位置插入数据元素
    void insert(int index, int val) {
        if (index < 0 || head == NULL) {
            return;
        }
        ListNode *node = new ListNode(val);
        ListNode *temp = head;
        int count = 0;
        while (temp != NULL) {
            if (count == index) {
                node->next = temp->next;
                temp->next = node;
                break;
            }
            count++;
            temp = temp->next;
        }
    }

    // 删除指定位置数据元素
    void remove(int index) {
        if (index < 0 || head == NULL) {
            return;
        }
        ListNode *temp = head;
        ListNode *prev = NULL;
        int count = 0;
        while (temp != NULL) {
            if (count == index) {
                if (prev == NULL) {
                    head = temp->next;
                } else {
                    prev->next = temp->next;
                }
                delete temp;
                break;
            }
            count++;
            prev = temp;
            temp = temp->next;
        }
    }

    // 从用户手动输入构建单链表（尾插）
    void buildFromUserInput() {
        int val;
        cout << "请输入单链表的节点值（以-1结束）：";
        while (cin >> val && val != -1) {
            insertAtTail(val);
        }
    }

    // 从txt文件读取数据构建单链表（尾插）
    void buildFromTxtFile(string filename) {
        ifstream inputFile(filename);
        if (!inputFile) {
            cout << "无法打开文件" << filename << endl;
            return;
        }

        int val;
        while (inputFile >> val) {
            insertAtTail(val);
        }

        inputFile.close();
    }

    // 从Excel文件读取第一列数据构建单链表（尾插）
    void buildFromExcelFile(string filename) {
        ifstream inputFile(filename);
        if (!inputFile) {
            cout << "无法打开文件" << filename << endl;
            return;
        }

        string line;
        vector<int> values;

        while (getline(inputFile, line)) {
            stringstream ss(line);
            int val;
            ss >> val;
            values.push_back(val);
        }

        for (int i = 0; i < values.size(); i++) {
            insertAtTail(values[i]);
        }

        inputFile.close();
    }
};













//功能测试模块，可按需求进行更改。
int main() {
    LinkedList linkedList;

    // 通过手动输入构建单链表
    linkedList.buildFromUserInput();

    // 输出构建的链表
    cout << "手动输入构建的链表：";
    linkedList.printList();

    // 从txt文件读取数据构建单链表
    string txtFilename = "data.txt";
    linkedList.buildFromTxtFile(txtFilename);

    // 输出构建的链表
    cout << "从txt文件读取构建的链表：";
    linkedList.printList();

    // 从Excel文件读取第一列数据构建单链表
    string excelFilename = "data.xlsx";
    linkedList.buildFromExcelFile(excelFilename);

    // 输出构建的链表
    cout << "从Excel文件读取构建的链表：";
    linkedList.printList();

    linkedList.destroyList();

    return 0;
}

Java

import java.io.*;
import java.util.*;

class ListNode {
    int val;          // 数据域
    ListNode next;   // 指向下一个节点的指针
    
    public ListNode(int x) {
        val = x;
        next = null;
    }
}

class LinkedList {
    private ListNode head;   // 头指针

    public LinkedList() {
        head = null;   // 初始化单链表
    }

    // 头插法构建单链表
    public void insertAtHead(int val) {
        ListNode node = new ListNode(val);
        if (head != null) {
            node.next = head;
        }
        head = node;
    }

    // 尾插法构建单链表
    public void insertAtTail(int val) {
        ListNode node = new ListNode(val);
        if (head == null) {
            head = node;
        } else {
            ListNode temp = head;
            while (temp.next != null) {
                temp = temp.next;
            }
            temp.next = node;
        }
    }

    // 销毁单链表
    public void destroyList() {
        ListNode temp = head;
        while (temp != null) {
            ListNode tempToDelete = temp;
            temp = temp.next;
            tempToDelete = null;
        }
        head = null;
    }

    // 判断是否为空表
    public boolean isEmpty() {
        return head == null;
    }

    // 获取单链表的长度
    public int getLength() {
        int length = 0;
        ListNode temp = head;
        while (temp != null) {
            length++;
            temp = temp.next;
        }
        return length;
    }

    // 输出链表
    public void printList() {
        ListNode temp = head;
        while (temp != null) {
            System.out.print(temp.val + " ");
            temp = temp.next;
        }
        System.out.println();
    }

    // 按序号求表中元素
    public int getElementAtIndex(int index) {
        if (index < 0 || head == null) {
            return -1;
        }
        ListNode temp = head;
        int count = 0;
        while (temp != null) {
            if (count == index) {
                return temp.val;
            }
            count++;
            temp = temp.next;
        }
        return -1;
    }

    // 按元素值查找元素
    public int search(int val) {
        ListNode temp = head;
        int index = 0;
        while (temp != null) {
            if (temp.val == val) {
                return index;
            }
            index++;
            temp = temp.next;
        }
        return -1;
    }

    // 在指定位置插入数据元素
    public void insert(int index, int val) {
        if (index < 0 || head == null) {
            return;
        }
        ListNode node = new ListNode(val);
        ListNode temp = head;
        int count = 0;
        while (temp != null) {
            if (count == index) {
                node.next = temp.next;
                temp.next = node;
                break;
            }
            count++;
            temp = temp.next;
        }
    }

    // 删除指定位置数据元素
    public void remove(int index) {
        if (index < 0 || head == null) {
            return;
        }
        ListNode temp = head;
        ListNode prev = null;
        int count = 0;
        while (temp != null) {
            if (count == index) {
                if (prev == null) {
                    head = temp.next;
                } else {
                    prev.next = temp.next;
                }
                temp = null;
                break;
            }
            count++;
            prev = temp;
            temp = temp.next;
        }
    }

    // 从用户手动输入构建单链表（尾插）
    public void buildFromUserInput() {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入单链表的节点值（以-1结束）：");
        while (scanner.hasNextInt()) {
            int val = scanner.nextInt();
            if (val == -1) {
                break;
            }
            insertAtTail(val);
        }
        scanner.close();
    }

    // 从txt文件读取数据构建单链表（尾插）
    public void buildFromTxtFile(String filename) {
        try (Scanner scanner = new Scanner(new File(filename))) {
            while (scanner.hasNextInt()) {
                int val = scanner.nextInt();
                insertAtTail(val);
            }
        } catch (FileNotFoundException e) {
            System.out.println("无法打开文件" + filename);
        }
    }

    // 从Excel文件读取第一列数据构建单链表（尾插）
    public void buildFromExcelFile(String filename) {
        try (Scanner scanner = new Scanner(new File(filename))) {
            List<Integer> values = new ArrayList<>();
            while (scanner.hasNextLine()) {
                String line = scanner.nextLine();
                Scanner lineScanner = new Scanner(line);
                if (lineScanner.hasNextInt()) {
                    int val = lineScanner.nextInt();
                    values.add(val);
                }
                lineScanner.close();
            }
            for (int i = 0; i < values.size(); i++) {
                insertAtTail(values.get(i));
            }
        } catch (FileNotFoundException e) {
            System.out.println("无法打开文件" + filename);
        }
    }
}













//测试函数，可根据实际需要进行修改
public class Main {
    public static void main(String[] args) {
        LinkedList linkedList = new LinkedList();

        // 通过手动输入构建单链表
        linkedList.buildFromUserInput();

        // 输出构建的链表
        System.out.print("手动输入构建的链表：");
        linkedList.printList();

        // 从txt文件读取数据构建单链表
        String txtFilename = "data.txt";
        linkedList.buildFromTxtFile(txtFilename);

        // 输出构建的链表
        System.out.print("从txt文件读取构建的链表：");
        linkedList.printList();

        // 从Excel文件读取第一列数据构建单链表
        String excelFilename = "data.xlsx";
        linkedList.buildFromExcelFile(excelFilename);

        // 输出构建的链表
        System.out.print("从Excel文件读取构建的链表：");
        linkedList.printList();

        linkedList.destroyList();
    }
}

Python

class ListNode:
    def __init__(self, val):
        self.val = val   #数据域
        self.next = None #头指针

class LinkedList:
    #初始化单链表
    def __init__(self):
        self.head = None

    #头插法建立单链表
    def insertAtHead(self, val):
        node = ListNode(val)
        if self.head is not None:
            node.next = self.head
        self.head = node

    #尾插法建立单链表
    def insertAtTail(self, val):
        node = ListNode(val)
        if self.head is None:
            self.head = node
        else:
            temp = self.head
            while temp.next is not None:
                temp = temp.next
            temp.next = node

    #销毁单链表
    def destroyList(self):
        temp = self.head
        while temp is not None:
            tempToDelete = temp
            temp = temp.next
            del tempToDelete
        self.head = None

    #判断链表是否为空
    def isEmpty(self):
        return self.head is None

    #获取链表长度
    def getLength(self):
        length = 0
        temp = self.head
        while temp is not None:
            length += 1
            temp = temp.next
        return length

    #输出单链表
    def printList(self):
        temp = self.head
        while temp is not None:
            print(temp.val, end=" ")
            temp = temp.next
        print()

    #按序号求表中元素
    def getElementAtIndex(self, index):
        if index < 0 or self.head is None:
            return -1
        temp = self.head
        count = 0
        while temp is not None:
            if count == index:
                return temp.val
            count += 1
            temp = temp.next
        return -1

    #按元素值查找元素
    def search(self, val):
        temp = self.head
        index = 0
        while temp is not None:
            if temp.val == val:
                return index
            index += 1
            temp = temp.next
        return -1

    #指定位置插入数据
    def insert(self, index, val):
        if index < 0 or self.head is None:
            return
        node = ListNode(val)
        temp = self.head
        count = 0
        while temp is not None:
            if count == index:
                node.next = temp.next
                temp.next = node
                break
            count += 1
            temp = temp.next

    #指定位置删除元素
    def remove(self, index):
        if index < 0 or self.head is None:
            return
        temp = self.head
        prev = None
        count = 0
        while temp is not None:
            if count == index:
                if prev is None:
                    self.head = temp.next
                else:
                    prev.next = temp.next
                del temp
                break
            count += 1
            prev = temp
            temp = temp.next

    #手动输入数据建立单链表（尾插）
    def buildFromUserInput(self):
        print("请输入单链表的节点值（以-1结束）：")
        while True:
            val = int(input())
            if val == -1:
                break
            self.insertAtTail(val)
    #读取txt文件建立单链表（尾插）
    def buildFromTxtFile(self, filename):
        try:
            with open(filename, 'r') as inputFile:
                for line in inputFile:
                    val = int(line.strip())
                    self.insertAtTail(val)
        except FileNotFoundError:
            print(f"无法打开文件{filename}")

    #读取excel文件建立单链表（尾插）
    def buildFromExcelFile(self, filename):
        try:
            with open(filename, 'r') as inputFile:
                values = [int(line.strip()) for line in inputFile]
                for val in values:
                    self.insertAtTail(val)
        except FileNotFoundError:
            print(f"无法打开文件{filename}")













#测试函数，可根据实际需要进行修改
def main():
    linkedList = LinkedList()

    # 通过手动输入构建单链表
    linkedList.buildFromUserInput()

    # 输出构建的链表
    print("手动输入构建的链表：", end=" ")
    linkedList.printList()

    # 从txt文件读取数据构建单链表
    txtFilename = "data.txt"
    linkedList.buildFromTxtFile(txtFilename)

    # 输出构建的链表
    print("从txt文件读取构建的链表：", end=" ")
    linkedList.printList()

    # 从Excel文件读取第一列数据构建单链表
    excelFilename = "data.xlsx"
    linkedList.buildFromExcelFile(excelFilename)

    # 输出构建的链表
    print("从Excel文件读取构建的链表：", end=" ")
    linkedList.printList()

    linkedList.destroyList()


if __name__ == "__main__":
    main()