数据结构与算法设计_单链表

/*****************************************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：封装