/*****************************************JAVA****************************************************/
JAVA封装了一个单链表的操作类
测试数据
/*
* 单链表类
*/
public class SingleLinkList_value {
public static void main(String[] args) {
SingleLinkList_value slist=new SingleLinkList_value();
//初始化两张链表
Node L1=null,L2=null;
L1=slist.initNode(L1);
L2=slist.initNode(L2);
//插入节点
for(int i=1;i<=10;i++){
slist.insertNode(L1, 2013+i, i);
}
slist.insertNode(L1, Integer.MAX_VALUE, 6);
slist.insertNode(L1, Integer.MIN_VALUE, 4);
slist.printList(L1);
//求链表长度
System.out.println(slist.listLength(L1));
//判断链表是否为空
System.out.println(slist.isListEmpty(L1));
//按序号查找
Node node=slist.get(L1, 6);
System.out.println(node.data);
//数据定位,返回节点序号
System.out.println(slist.pos(L1, 2019));
// 删除操作
slist.deleteEle(L1, 8);
slist.printList(L1);
//链表反转
slist.convert(L1);
slist.printList(L1);
}
/**
* 初始化链表
* @param headNode 链表头
* @return
*/
private Node initNode(Node headNode){
if(headNode!=null){
System.out.println("链表已存在");
return null;
}else{
headNode=new Node(-1);
headNode.next=null;
return headNode;
}
}
/**
* 插入节点
* @param headNode 链表头
* @param data 数据
* @param i 插入几个位置
* @return
*/
private boolean insertNode(Node headNode,int data,int i){
Node p=null,q=null; //p前一个位置,q后一个位置
int j=0;
=headNode; //头节点位置为0
while(p.next!=null && j<i-1){
p=p.next;
j++;
}
if(j!=i-1){
System.out.println("插入位置错误");
return false;
}
q=new Node(data);
q.next=p.next;
p.next=q;
return true;
}
/**
* 求链表长度
* @param headNode 链表头
* @return
*/
private int listLength(Node headNode){
Node p=headNode;
int count=1;
while(p.next!=null){
p=p.next;
count++;
}
return count;
}
/**
* 判断链表是否为空
* @param headNode 链表头
* @return
*/
private boolean isListEmpty(Node headNode){
if(headNode.next==null) return true;
return false;
}
/**
* 按序号查找
* @param headNode 链表头
* @param i 几个位置
* @return
*/
private Node get(Node headNode,int i){
Node p=null;
int j=0;
if(isListEmpty(headNode) || i<1) return null;
p=headNode;
while(p.next!=null && j<i){
p=p.next;
j++;
}
if(j==i) return p;
return null;
}
/**
* 数据定位,返回节点序号
* @param headNode 链表头
* @param e 数据
* @return
*/
private int pos(Node headNode,int e){
Node p=headNode.next;
int i=1;
while(p!=null){
if(p.data==e) return i;
p=p.next;
i++;
}
return -1;
}
/**
* 删除操作
* @param headNode 链表头
* @param i 待删除元素序号
* @return
*/
private boolean deleteEle(Node headNode,int i){
Node p=null,q=null;
int j=0;
p=headNode;
while(p.next!=null && p.next.next!=null && j<i-1){
p=p.next;
j++;
}
if(j!=i-1){
System.out.println("删除位置错误");
return false;
}
p.next=p.next.next;
return true;
}
/**
* 遍历链表
* @param headName 链表头
*/
private void printList(Node headNode){
Node p=headNode;
while(p!=null){
System.out.print(p.data+" ");
p=p.next;
if(p==null) System.out.println();
}
}
/**
* 链表反转
* @param headNode 链表头
*/
private void convert(Node headNode){
Node p=headNode.next,temp,q=p.next;
p.next=null;
while(q!=null){
temp=q.next;
q.next=p;
p=q;
q=temp;
}
headNode.next=p;
}
/**
* 节点类
* @author GetWay
*/
private class Node{
private Node next;
private int data;
public Node(int data) {
this.data = data;
}
}
}
/*************************************************C******************************************/
C单链表的操作方法
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
struct Node
{
int data; //数据域
struct Node *next; //指针域
};
typedef struct Node ListNode;
typedef struct Node* LinkList;
/*
初始化链表
*/
void InitList(LinkList *head)
{
if((*head=(LinkList)malloc(sizeof(ListNode)))==NULL)
{
exit(-1); //退出程序
}
(*head)->next=NULL;
}
/*
插入操作, 成功返回 1
参数一:头结点
参数二:第几个位置插入
参数三:插入元素的值
*/
int InsertList(LinkList head, int i,int e)
{
ListNode *p,*pre; //*p新生成的节点,*pre 要插入的前一个节点的指针
int j=0;
pre=head;
while(pre->next!=NULL && j<i-1) //pre->next!=NULL 下一个节点不为空
{
pre=pre->next;
j++;
}
if(j!=i-1)
{
printf("插入位置错误");
return 0;
}
p=(ListNode*)malloc(sizeof(ListNode));
p->data=e;
p->next=pre->next;
pre->next=p;
return 1;
}
/*
求链表长度
*/
int ListLength(LinkList head)
{
ListNode *p;
int count=0;
p=head;
while(p->next!=NULL)
{
p=p->next;
count++;
}
return count;
}
/*
判断链表是否为空,如果头结点的指针域为空域,那么链表肯定为空
如果为空,返回为1
*/
int ListEmpty(LinkList head)
{
if(head->next==NULL) //这是一个空链表
return 1;
else
return 0;
}
/*
按序号查找, 如果找到返回链表的指针
第一个参数:head,链表的头结点
第二个参数:i,第几个位置
*/
ListNode *Get(LinkList head,int i)
{
ListNode *p;
int j=0;
if(ListEmpty(head)) //判断链表是否为空
{
return NULL;
}
if(i<1)
{
return NULL;
}
p=head;
while(p->next!=NULL && j<i)
{
p=p->next;
j++;
}
if(j==i)
{
return p;
}
else
{
return NULL;
}
}
/*
定位操作 ,返回节点的序号
参数一:头结点
参数二:要比较的内容 ,e 是另外一个链表的数据
*/
int LocatePos(LinkList head, int e)
{
ListNode *p;
int i=1;
p=head->next;
while(p)
{
if(p->data==e)
return i;
else
{
p=p->next;
i++;
}
}
if(!p)
return 0;
}
/*
单链表反转
*/
void LinkListConvert(LinkList head)
{
int i;
ListNode *p2,*p,*last;
last=Get(head,ListLength(head)); //存储最后一个节点
for(i=ListLength(head);i>1;i--)
{
p=Get(head,i);
p2=Get(head,i-1);
p->next=p2;
if(i==2)
{
p2->next=NULL;
}
else
{
p=p2;
}
}
p=head;
p->next=last;
}
/*
销毁链表
*/
void DestroyList(LinkList head)
{
ListNode *p,*q;
p=head; //指向头结点
while(p!=NULL)
{
q=p;
p=p->next;
free(q);
}
}
int main(void)
{
int i;
int a[]={2,0,1,4,9,8,7,3,5,6};
ListNode *p;
//初始化
LinkList A;
InitList(&A); //带有头结点的 ,A链表
//插入
for(i=1;i<=sizeof(a)/sizeof(a[0]);i++) //头结点不存放数据,从第二个节点开始 .
{
if(InsertList(A,i,a[i-1])==0) //没有插入成功
{
printf("插入失败");
return;
}
}
//打印
for(i=1;i<=ListLength(A);i++)
{
p=Get(A,i); //定位
if(p) //如果 p 存在,不等于NULL
{
printf("%4d",p->data); //打印数据,
}
}
printf("\n");
//单链表反转
LinkListConvert(A);
for(i=1;i<=ListLength(A);i++)
{
p=Get(A,i); //定位
if(p) //如果 p 存在,不等于NULL
{
printf("%4d",p->data); //打印数据,
}
}
printf("\n");
//销毁链表
DestroyList(A);
system("pause");
return 0;
}
Mark:封装