1.系统需要实现的操作：

（1）学生成绩信息包括学号、姓名、性别、班级、高等数学成绩、大学英语成绩、C语言程序设计成绩和软件工程导论成绩等；

（2）系统的主要功能包括：学生成绩信息的创建、输出学生成绩信息、查询学生成绩、增加学生成绩、删除学生成绩。

2.目的：

1. 掌握线性表的定义；

2. 掌握线性表的基本操作，如建立、查找、插入和删除等。

3.成品

点个赞鼓励一下吧哈哈哈哈哈哈

代码设计

1.创建结构体

typedef struct 
{
	char id[20];     // 学号 
	char name[50];   // 姓名 
	char sex[20];    // 性别 
	char grade[20];  // 班级 
	char math[10];        // 数学 
    char english[10];     // 英语 
	char Cyuyan[10];      // C语言 
	char Daolun[10];      // 软工导论 
} Student;

typedef struct LNode
{
	Student data;  //数据域 
	struct LNode *next;  // 指针域 
	
}LNode,*LinkList;

2.输入信息:设置p指向新结点，r指向当前链表的尾结点，然后初始化，是链表为空，使用scanf函数，把输入的值分别存放在p->data中，然后r->next = p;r = r->next。

void input(LNode *head){
	LinkList p,r; //p指向新结点，r指向当前链表的尾结点 
	int i,n; //n 为需要输入的学生人数
	r = head;
	printf("请输入学生的人数：");
	scanf("%d",&n);
	printf("请输入学生的信息");
	for(i=1;i<=n;i++){
		p = (LinkList)malloc(sizeof(LNode));
		p->next = NULL;
		printf("学号\n");
		scanf("%s",p->data.id);
		printf("姓名\n");
		scanf("%s",p->data.name);
		printf("性别\n");
		scanf("%s",p->data.sex);
		printf("班级\n");
		scanf("%s",p->data.grade);
		printf("数学成绩\n");
		scanf("%s",p->data.math);
		printf("英语成绩\n");
		scanf("%s",p->data.english);
		printf("C语言程序设计成绩\n");
		scanf("%s",p->data.Cyuyan);
		printf("软件工程导论成绩\n");
		scanf("%s",p->data.Daolun);
		r->next = p;
		r = r->next;
		printf("---------------------------");
	} 
	printf("************************");
} 

3.输出学生的信息：使用while循环遍历p中的值，然后输出。

 *head){
	LinkList p;
	p=head;
	printf("学号\t姓名\t性别\t班级\t数学\t英语\tC语言程序设计\t软件工程导论\n");
	while(p->next!=NULL){
		p = p->next;
		printf("%s\t%s\t%s\t%s\t%s\t%s\t%s\t\t%s\n",p->data.id,p->data.name,p->data.sex,p->data.grade,p->data.math,p->data.english,p->data.Cyuyan,p->data.Daolun);
		
	} 
	 
}

4.通过学号查看学生的成绩：先获取用户输入的学号，然后做一个判断语句，判断列表是否为真，在使用strcmp函数对比输入的学号与数据哪一个匹配，然后输出。

//通过学号查看学生的成绩 
void research_1(LNode *head,Student e)
{
	LinkList p;
	p=head;
	printf("请输入查找的学号：\n");
	scanf("%s",e.id);
	while((p->next!=NULL)&&strcmp(e.id,p->data.id))
	{
		p=p->next;
	}
	printf("数学\t英语\tC语言程序设计\t软件工程导论\n");
	printf("%s\t%s\t%s\t\t%s\n",p->data.math,p->data.english,p->data.Cyuyan,p->data.Daolun);
}

5.插入学生的信息：获取用户要插入的位置，然后用p->data=e;p->next=r->next;r->next=p;插入。

//插入学生的信息· 
void insert(LNode *head,int i,Student e)
{
	int k;
	LinkList p,r;
	r=head;k=0;
	printf("请输入你要插入的位置：\n");
	scanf("%d",&i);
		printf("学号\n");
		scanf("%s",e.id);
		printf("姓名\n");
		scanf("%s",e.name);
		printf("性别\n");
		scanf("%s",e.sex);
		printf("班级\n");
		scanf("%s",e.grade);
		printf("数学成绩\n");
		scanf("%s",e.math);
		printf("英语成绩\n");
		scanf("%s",e.english);
		printf("C语言程序设计成绩\n");
		scanf("%s",e.Cyuyan);
		printf("软件工程导论成绩\n");
		scanf("%s",e.Daolun);
	while(r!=NULL&&k<i-1)
	{
		r=r->next;
		k=k+1;
	}
	if(r==NULL)
	{
		printf("插入失败！\n");
	}
	p=(LinkList)malloc(sizeof(LNode));
	p->data=e;
	p->next=r->next;
	r->next=p;
	printf("插入成功！\n");
}

6.删除：获取用户的要删除的学号，算法：p=r->next;r->next=p->next;*e=p->data;free(p);即可。

void delete_1(LNode *head,int i,Student *e)
{
	LinkList p,r;
	int k;
	r=head;k=0;
	printf("请输入你要删除的位置：\n");
	scanf("%d",&i);
	while(r->next!=NULL&&k<i-1)
	{
		r=r->next;
		k++;
	}
	if(r==NULL)
	{
		printf("删除失败！\n"); 
	}
	p=r->next;
	r->next=p->next;
	*e=p->data;
	free(p);
	printf("删除成功！\n"); 
}

源代码：

#include "stdio.h"
#include "stdlib.h"
#include "string.h"
typedef struct 
{
	char id[20];     // 学号 
	char name[50];   // 姓名 
	char sex[20];    // 性别 
	char grade[20];  // 班级 
	char math[10];        // 数学 
    char english[10];     // 英语 
	char Cyuyan[10];      // C语言 
	char Daolun[10];      // 软工导论 
} Student;

typedef struct LNode
{
	Student data;  //数据域 
	struct LNode *next;  // 指针域 
	
}LNode,*LinkList;
//输入学生信息 
void input(LNode *head){
	LinkList p,r; //p指向新结点，r指向当前链表的尾结点 
	int i,n; //n 为需要输入的学生人数
	r = head;
	printf("请输入学生的人数：");
	scanf("%d",&n);
	printf("请输入学生的信息");
	for(i=1;i<=n;i++){
		p = (LinkList)malloc(sizeof(LNode));
		p->next = NULL;
		printf("学号\n");
		scanf("%s",p->data.id);
		printf("姓名\n");
		scanf("%s",p->data.name);
		printf("性别\n");
		scanf("%s",p->data.sex);
		printf("班级\n");
		scanf("%s",p->data.grade);
		printf("数学成绩\n");
		scanf("%s",p->data.math);
		printf("英语成绩\n");
		scanf("%s",p->data.english);
		printf("C语言程序设计成绩\n");
		scanf("%s",p->data.Cyuyan);
		printf("软件工程导论成绩\n");
		scanf("%s",p->data.Daolun);
		r->next = p;
		r = r->next;
		printf("---------------------------");
	} 
	printf("************************");
} 
//输出学生的信息 
void output(LNode *head){
	LinkList p;
	p=head;
	printf("学号\t姓名\t性别\t班级\t数学\t英语\tC语言程序设计\t软件工程导论\n");
	while(p->next!=NULL){
		p = p->next;
		printf("%s\t%s\t%s\t%s\t%s\t%s\t%s\t\t%s\n",p->data.id,p->data.name,p->data.sex,p->data.grade,p->data.math,p->data.english,p->data.Cyuyan,p->data.Daolun);
		
	} 
	 
}
//通过学号查看学生的成绩 
void research_1(LNode *head,Student e)
{
	LinkList p;
	p=head;
	printf("请输入查找的学号：\n");
	scanf("%s",e.id);
	while((p->next!=NULL)&&strcmp(e.id,p->data.id))
	{
		p=p->next;
	}
	printf("数学\t英语\tC语言程序设计\t软件工程导论\n");
	printf("%s\t%s\t%s\t\t%s\n",p->data.math,p->data.english,p->data.Cyuyan,p->data.Daolun);
}
//插入学生的信息· 
void insert(LNode *head,int i,Student e)
{
	int k;
	LinkList p,r;
	r=head;k=0;
	printf("请输入你要插入的位置：\n");
	scanf("%d",&i);
		printf("学号\n");
		scanf("%s",e.id);
		printf("姓名\n");
		scanf("%s",e.name);
		printf("性别\n");
		scanf("%s",e.sex);
		printf("班级\n");
		scanf("%s",e.grade);
		printf("数学成绩\n");
		scanf("%s",e.math);
		printf("英语成绩\n");
		scanf("%s",e.english);
		printf("C语言程序设计成绩\n");
		scanf("%s",e.Cyuyan);
		printf("软件工程导论成绩\n");
		scanf("%s",e.Daolun);
	while(r!=NULL&&k<i-1)
	{
		r=r->next;
		k=k+1;
	}
	if(r==NULL)
	{
		printf("插入失败！\n");
	}
	p=(LinkList)malloc(sizeof(LNode));
	p->data=e;
	p->next=r->next;
	r->next=p;
	printf("插入成功！\n");
}
//删除 
void delete_1(LNode *head,int i,Student *e)
{
	LinkList p,r;
	int k;
	r=head;k=0;
	printf("请输入你要删除的位置：\n");
	scanf("%d",&i);
	while(r->next!=NULL&&k<i-1)
	{
		r=r->next;
		k++;
	}
	if(r==NULL)
	{
		printf("删除失败！\n"); 
	}
	p=r->next;
	r->next=p->next;
	*e=p->data;
	free(p);
	printf("删除成功！\n"); 
}
void  exit_1()
{
	printf("退出成功！请按任意键结束！");
	exit(0);
}

int main(){
	LNode *head;
	head = (LinkList)malloc(sizeof(LNode));
	head->next = NULL;
	int select = -1;
	int i;
	Student e;
		printf("********************************************************************\n"); 
	printf("*      1. 根据指定学生个数，逐个输入学生信息;                      *\n");
	printf("*      2. 逐个显示学生表中所有学生的相关信息；                     *\n");
	printf("*      3. 根据学号进行查找，返回此学生的成绩；               *\n");
	printf("*      4. 给定一个学生信息，插入到表中指定的位置；                 *\n");
	printf("*      5. 删除指定位置的学生记录；                                 *\n");
	printf("*      6.退出。                                                   *\n");
	printf("********************************************************************\n");
	printf("\n"); 
	
	while(select!=0){
		printf("请选择你要操作的选项：");
		scanf("%d",&select);
		printf("\n");
		switch(select)
		{
			case 1: input(head);break;
			case 2: output(head);break;
			case 3: research_1(head,e);break;
			case 4: insert(head,i,e);break;
			case 5: delete_1(head,i,&e);break;
			case 6: exit_1();break;
		}
		 
	}
	return 0;
}

链表

关于链表的原理已经有一篇链表文章写的很详细了，这篇文章主要侧重于代码的实现，主要使用go实现。

单链表实现

package List

type listNode struct {
	val  int
	next *listNode
}

func newNode(val int) *listNode {

	node := new(listNode)
	node.val = val
	node.next = nil
	return node
}

// NewList 初始化一个不带头结点的链表
func NewList(vals []int) *listNode {

	var fistNode *listNode
	var curNode *listNode
	for _, v := range vals {
		node := newNode(v)
		if curNode == nil {
			fistNode = node
			curNode = fistNode
			continue
		}

		curNode.next = node
		curNode = curNode.next
	}

	return fistNode
}

// FistAdd 头插
func FistAdd(fistNode *listNode, val int) *listNode{

	if fistNode == nil {
		return fistNode
	}
	node := newNode(val)
	node.next = fistNode
	return node
}

// LastAdd 尾插
func LastAdd(fistNode *listNode, val int)  {

	if fistNode == nil {
		return
	}

	curNode := fistNode
	for curNode.next != nil {
		curNode = curNode.next
	}

	node := newNode(val)
	curNode.next = node

	return
}

// IndexValAdd 在第一个指定值后插入，若没有，在链表尾部插入
// fistNode 链表第一个节点, indexVal 目标节点值, val 新节点值
func IndexValAdd(fistNode *listNode, indexVal, val int) {

	if fistNode == nil {
		return
	}

	curNode := fistNode
	for curNode.next != nil && curNode.val != indexVal {
		curNode = curNode.next
	}

	node := newNode(val)
	nextNode := curNode.next
	node.next = nextNode
	curNode.next = node

	return
}

// ChangVal 更改目标节点值，若没有，不做改动
// fistNode 链表第一个节点, indexVal 目标节点值, val 目标值
func ChangVal (fistNode *listNode,  indexVal, tarVal int)  {

	if fistNode == nil {
		return
	}

	curNode := fistNode
	for curNode != nil && curNode.val != indexVal {
		curNode = curNode.next
	}

	// 判断是走到最后都没有找到对应值还是找到对应值
	if curNode == nil{
		return
	}

	curNode.val = tarVal

	return

}

// DelNode 删除指定节点，若没有则不删除
func DelNode(fistNode *listNode, indexVal int)  {

	if fistNode == nil {
		return
	}

	curNode := fistNode
	// 查找要删除节点的前一个节点
	for curNode.next != nil  {

		nextNode := curNode.next
		if nextNode.val == indexVal {
			break
		}
		curNode = curNode.next
	}

	if curNode.next == nil {
		return
	}
	nextNode := curNode.next
	curNode.next = nextNode.next

}

// Show 不带头节点查
func Show(node *listNode) []int {
	if node == nil {
		return []int{}
	}

	valSlice := make([]int, 0, 4)
	curNode := node
	for curNode != nil {
		valSlice = append(valSlice, curNode.val)
		curNode = curNode.next
	}

	return valSlice
}

验证代码

package main

import (
	"Data/List"
	"fmt"
)

func main() {
	// 初始化一个链表
	fistNode := List.NewList([]int{1, 2, 3, 4, 5})
	fmt.Println("初始化一个链表 :",List.Show(fistNode))
	// 对链表进行头插
	fistNode = List.FistAdd(fistNode, 0)
	fmt.Println("对链表进行头插 0 :",List.Show(fistNode))
	// 对链表进行尾插
	List.LastAdd(fistNode, 6)
	fmt.Println("对链表进行尾插 6 :",List.Show(fistNode))
	// 删除指定节点
	List.DelNode(fistNode, 3)
	fmt.Println("删除指定节点 3 :",List.Show(fistNode))
	List.DelNode(fistNode, 3)
	fmt.Println("删除指定节点 3 :",List.Show(fistNode))
	List.DelNode(fistNode, 3)
	fmt.Println("删除指定节点 7 :",List.Show(fistNode))
	// 在第一个指定值后插入
	List.IndexValAdd(fistNode, 4, 41)
	fmt.Println("在第一个指定值后插入，若没有，在链表尾部插入 4 41 :",List.Show(fistNode))
	List.IndexValAdd(fistNode, 7, 42)
	fmt.Println("在第一个指定值后插入，若没有，在链表尾部插入 7 42 :",List.Show(fistNode))
	// 更改目标节点值
	List.ChangVal(fistNode, 4, 40)
	fmt.Println("更改目标节点值 4 40 :",List.Show(fistNode))
	List.ChangVal(fistNode, 7, 43)
	fmt.Println("更改目标节点值 7 43 :",List.Show(fistNode))
}

效果图

循环链表实现

package List

import "fmt"

func newCircleNode(val int) *listNode {

	node := new(listNode)
	node.val = val
	node.next = node
	return node
}

func NewCircleList(vals []int) *listNode {

	var fistNode *listNode
	var curNode *listNode
	for _, v := range vals {
		if curNode == nil {
			fistNode = newCircleNode(v)
			curNode = fistNode
			continue
		}

		node := newCircleNode(v)
		node.next = fistNode
		curNode.next = node
		curNode = curNode.next
	}

	return fistNode
}

func isLastNode(fistNode *listNode, node *listNode) bool {
	return node.next == fistNode
}

// CircleFistAdd 头插
func CircleFistAdd(fistNode **listNode, val int)  {

	if fistNode == nil {
		return
	}

	curNode := *fistNode
	for !isLastNode(*fistNode, curNode) {
		curNode = curNode.next
	}

	node := newCircleNode(val)
	curNode.next = node
	node.next = *fistNode
	*fistNode = node
}

// CircleLastAdd 尾插
func CircleLastAdd(fistNode *listNode, val int) {

	if fistNode == nil {
		return
	}

	curNode := fistNode
	for !isLastNode(fistNode, curNode) {
		curNode = curNode.next
	}

	node := newCircleNode(val)
	node.next = fistNode
	curNode.next = node

}

// CircleIndexValAdd 在第一个指定值后插入，若没有，在链表尾部插入
func CircleIndexValAdd(fistNode *listNode, indexVal,val int) {

	if fistNode == nil {
		return
	}

	curNode := fistNode

	for !isLastNode(fistNode, curNode) && curNode.val != indexVal {
		curNode = curNode.next
	}

	node := newCircleNode(val)
	node.next = curNode.next
	curNode.next = node

}

// CircleChangVal 更改目标节点值，若没有，不做改动
func CircleChangVal(fistNode *listNode, indexVal, tarVal int) {

	if fistNode == nil {
		return
	}

	curNode := fistNode
	for curNode.val != indexVal && !isLastNode(fistNode, curNode)  {
		curNode = curNode.next
	}

	if curNode.val == indexVal {
		curNode.val = tarVal
		return
	}
	fmt.Printf("节点 %d 不存在\n", indexVal)
}

// CircleDelNode 删除指定节点，若没有则不删除
func CircleDelNode(fistNode *listNode, indexVal int) {

	if fistNode == nil {
		return
	}

	curNode := fistNode
	for curNode.next.val != indexVal && !isLastNode(fistNode, curNode)  {
		curNode = curNode.next
	}

	if curNode.next.val == indexVal {
		curNode.next = curNode.next.next
		return
	}
	fmt.Printf("没有该节点 %d \n", indexVal)

}

// CircleShow 查看链表
func CircleShow(fistNode *listNode) {

	if fistNode == nil {
		return
	}

	curNode := fistNode
	for {
		if isLastNode(fistNode, curNode) {
			fmt.Printf("val:%d next:%d", curNode.val, curNode.next.val)
			break
		}
		fmt.Printf("val:%d next:%d -> ", curNode.val, curNode.next.val)
		curNode = curNode.next
	}

	fmt.Println()
}

验证代码

package main

import (
	"Data/List"
	"fmt"
)

func main() {

	// 初始化一个环形链表
	circleFistNode := List.NewCircleList([]int{1, 2, 3})
	fmt.Println("初始化一个链表 :")
	List.CircleShow(circleFistNode)
	// 对链表进行头插
	List.CircleFistAdd(&circleFistNode, 0)
	fmt.Println("对链表进行头插  0:")
	List.CircleShow(circleFistNode)
	// 对链表进行尾插
	List.CircleLastAdd(circleFistNode, 4)
	fmt.Println("对链表进行尾插 4 :")
	List.CircleShow(circleFistNode)
	// 删除指定节点
	fmt.Println("删除指定节点 3 :")
	List.CircleDelNode(circleFistNode, 3)
	List.CircleShow(circleFistNode)
	fmt.Println("删除指定节点 3 :")
	List.CircleDelNode(circleFistNode, 3)
	List.CircleShow(circleFistNode)
	fmt.Println("删除指定节点 7 :")
	List.CircleDelNode(circleFistNode, 7)
	List.CircleShow(circleFistNode)

	// 在第一个指定值后插入
	circleFistNode = List.NewCircleList([]int{1, 2, 3})
	fmt.Println("初始化一个链表 :")
	List.CircleShow(circleFistNode)
	List.CircleIndexValAdd(circleFistNode, 2, 41)
	fmt.Println("在第一个指定值后插入，若没有，在链表尾部插入 2 41 :")
	List.CircleShow(circleFistNode)
	List.CircleIndexValAdd(circleFistNode, 7, 42)
	fmt.Println("在第一个指定值后插入，若没有，在链表尾部插入 7 42 :")
	List.CircleShow(circleFistNode)
	// 更改目标节点值
	circleFistNode = List.NewCircleList([]int{1, 2, 3, 4})
	fmt.Println("初始化一个链表 :")
	List.CircleShow(circleFistNode)
	fmt.Println("更改目标节点值 3 40 :")
	List.CircleChangVal(circleFistNode, 3, 40)
	List.CircleShow(circleFistNode)
	fmt.Println("更改目标节点值 7 43 :")
	List.CircleChangVal(circleFistNode, 7, 43)
	List.CircleShow(circleFistNode)
	//
}

效果图

最近在linux了一个简单的单向链表，直接上代码

链表头文件   list.h

#ifndef _LIST_H_
#define _LIST_H_

typedef int T;

template<typename T>
class List
{
private:
    struct Node
    {
        T      data;
        Node*  next;
        Node(const T& d=T()):data(d),next(NULL){} //零初始化
    };
    Node* head;//头指针,用来保存头节点的地址
    int len;
public:
    List():head(NULL),len(0){}
    List(const List& l);
    void operator=(const List& l);
    ~List();
    T getElementAtIndex(int index)const;//取得链表中指定位置的元素值
    List<T>& push_front(const T& d);//前插
    List<T>& push_back(const T& d); //尾插
    int size()const;//获取链表中节点个数
    Node*& getptr(int pos); //在链表中找指向指定位置的指针
    List<T>& insert(const T& d,int pos); //在任意位置插入
    void travel()const; //遍历
    void clear(); //清空链表
    void erase(int pos); //删除链表中指定位置的元素
    int find(const T& d)const; //查找指定数值的元素在链表中出现的位置
    void remove(const T& d); //删除链表中指定的元素
    void set(int pos,const T& d);
    bool empty()const;
    const T& front()const;
    const T& back()const;
    void reverse();//链表元素倒置
};

#endif

链表实现文件 list.cpp

#include <iostream>
#include <string>
#include "list.h"

using namespace std;

template<typename T>
List<T>::List(const List<T>& l)
{
    len = l.len;
    Node* items[len];
    for(int i=0;i<len;i++)
    {
        items[i] = new Node(l.getElementAtIndex(i));
    }
    for(int i=0;i<len-1;i++)
    {
        items[i]->next = items[i+1];
    }
    head = items[0];
}

template<typename T>
void List<T>::operator=(const List<T>& l)
{
    clear();    
    len = l.len;
    Node* items[len];
    for(int i=0;i<len;i++)
    {
        items[i] = new Node(l.getElementAtIndex(i));
    }
    for(int i=0;i<len-1;i++)
    {
        items[i]->next = items[i+1];
    }
    head = items[0];
}

template<typename T>
List<T>::~List()
{
    clear();
}

//取得链表中指定位置的元素值
template<typename T>
T List<T>::getElementAtIndex(int index)const  
{
    if(index < 0 || index >= len) throw "索引位置越界";
    if(index == 0) return head->data;
    Node* p = head;
    for(int i=1;i<index;i++)
    {
        p = p->next;
    }
    return p->next->data;
}

//前插
template<typename T>
List<T>& List<T>::push_front(const T& d)
{
    insert(d,0);
    return *this;
}

//后插
template<typename T>
List<T>& List<T>::push_back(const T& d)
{
    insert(d,len);
    return *this;
}

//获取链表中节点个数
template<typename T>
int List<T>::size()const
{
    return len;
}
    
//在链表中找指向指定位置的指针
template<typename T>
typename List<T>::Node*& List<T>::getptr(int pos)
{
    if(pos < 0 || pos > len) pos = 0;
    if(pos == 0) return head;
    Node* p = head;
    for(int i=1;i<pos;i++)
    {
        p = p->next;
    }
    return p->next;
}

//在任意位置插入节点
template<typename T>
List<T>& List<T>::insert(const T& d,int pos)
{
    Node*& pn = getptr(pos);
    Node* p = new Node(d);
    p->next = pn;
    pn = p;
    ++len;
    return *this;
}

//遍历
template<typename T>
void List<T>::travel()const
{
    Node* p = head;
    while(p)
    {
        cout << p->data << ' ';
        p = p->next;
    }
    cout << endl;
}

//清空链表
template<typename T>
void List<T>::clear()
{
    while(head)
    {
        Node* p = head->next;
        delete head;
        head = p;
    }
    len = 0;
}
    
//删除链表中指定位置的节点
template<typename T>
void List<T>::erase(int pos)
{
    if(pos < 0 || pos >= len) return;//有效位置为0~len-1
    Node*& pn = getptr(pos);
    Node* p = pn;
    pn = pn->next;
    delete p;
    --len;
}

//查找指定数值的节点在链表中出现的位置
template<typename T>
int List<T>::find(const T& d)const
{
    Node* p = head;
    int pos = 0;
    while(p)
    {
        if(p->data == d)
          return pos;
        else
          p = p->next;
        ++pos;
    }
    return -1;
}
    
//删除链表中指定数值的节点
template<typename T>
void List<T>::remove(const T& d)
{
    int pos;
    while((pos = find(d))!= -1)
    {
        erase(pos);
    }
}

//修改指定位置的节点数据
template<typename T>
void List<T>::set(int pos,const T& d)
{
    if(pos < 0 || pos >= len) return;
    getptr(pos)->data = d;
}

//判断链表是否为空
template<typename T>
bool List<T>::empty()const
{
    return head == NULL;
}

//取得链表中第一个节点数据
template<typename T>
const T& List<T>::front()const
{
    if(empty()) throw "空";
    return head->data;
}

//取得链表中最后一个节点数据
template<typename T>
const T& List<T>::back()const
{
    if(empty()) throw "空";
    Node* p = head;
    while(p->next)
    {
        p = p->next;
    }
    return p->data;
}

//将链表中的元素倒置
template<typename T>
void List<T>::reverse()
{
    if(head == NULL) return;
    Node *pre,*cur,*next;
    pre = head;
    cur = head->next;
    while(cur)
    {
        next = cur->next;
         cur->next = pre;
         pre = cur;
         cur = next;
     }
     head->next = NULL;
     head = pre;
}


template class List<T>; // 显式实例化

链表测试文件 listTest.cpp

#include <iostream>
#include "list.h"

//typedef int T;
using namespace std;

int main()
{
    List<T> l;
    List<T> m;
    l.push_front(5); //5
    l.push_front(8); //8 5
    l.push_front(20);// 20 8 5
    l.insert(9,2); // 20 8 9 5
    l.insert(8,100); //6 20 8 9 5
    l.insert(11,-10);//11 6 20 8 9 5
    l.insert(9,2);//11 6 1 20 8 9 5
    l.push_back(10).push_back(19);//11 8 9 20 8 9 5 10 19
    l.travel();
    l.reverse();
    l.travel();

    l.remove(8);
    l.remove(9);
    l.set(1,33);
    l.set(l.find(19),-8);

//    cout << l.front() << "      " << l.back() << endl;
    l.travel();  // 11 33 5 10 -8

//    while(!l.empty()) l.erase(0);
 //   cout << l.size() << endl;
    
 //   cout << l.getElementAtIndex(0) << endl;
    m.insert(-9,0);
    m.insert(13,1);
    m.push_front(-5);
    m.push_back(2);
    cout << "========m链表原始值======" << endl;
    m.travel();// -5 -9 13 2

    m = l;
    cout <<"==========将链表m中元素倒置==========" << endl;
    m.reverse();
    m.travel();
    cout <<"===========程序结束======" << endl;

    return 0;
}